X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Frenderers%2Fimage%2Fimage-renderer.cpp;h=c2bec8574a9f62e24a6a29893a76b0d6f8c8f0c1;hp=b84b5f5d3094b99e9db6563d2f4f073f35774242;hb=a2de9cf491172cd5da9dc9ed60b17683dab6d7bc;hpb=5eac3823385c43627c80d0f10f2aa1b3465cb250

diff --git a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
index b84b5f5..c2bec85 100644
--- a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
+++ b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
@@ -18,11 +18,18 @@
 // CLASS HEADER
 #include "image-renderer.h"
 
+// EXTERNAL HEADER
+#include <cstring> // for strncasecmp
+#include <dali/public-api/images/resource-image.h>
+#include <dali/public-api/images/native-image.h>
+#include <dali/integration-api/debug.h>
+
+// INTERNAL HEADER
 #include <dali-toolkit/internal/controls/renderers/renderer-factory-impl.h>
 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
 #include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
 #include <dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h>
-#include <dali/public-api/images/resource-image.h>
+#include <dali-toolkit/internal/controls/renderers/image-atlas-manager.h>
 
 namespace Dali
 {
@@ -35,39 +42,49 @@ namespace Internal
 
 namespace
 {
-const char * const RENDERER_TYPE("renderer-type");
-const char * const RENDERER_TYPE_VALUE("image-renderer");
+const char HTTP_URL[] = "http://";
+const char HTTPS_URL[] = "https://";
+
+const char * const RENDERER_TYPE("rendererType");
+const char * const RENDERER_TYPE_VALUE("image");
 
 // property names
-const char * const IMAGE_URL_NAME("image-url");
-const char * const IMAGE_FITTING_MODE("image-fitting-mode");
-const char * const IMAGE_SAMPLING_MODE("image-sampling-mode");
-const char * const IMAGE_DESIRED_WIDTH("image-desired-width");
-const char * const IMAGE_DESIRED_HEIGHT("image-desired-height");
+const char * const IMAGE_URL_NAME( "imageUrl" );
+const char * const IMAGE_FITTING_MODE( "imageFittingMode" );
+const char * const IMAGE_SAMPLING_MODE( "imageSamplingMode" );
+const char * const IMAGE_DESIRED_WIDTH( "imageDesiredWidth" );
+const char * const IMAGE_DESIRED_HEIGHT( "imageDesiredHeight" );
 
 // fitting modes
-const char * const SHRINK_TO_FIT("shrink-to-fit");
-const char * const SCALE_TO_FILL("scale-to-fill");
-const char * const FIT_WIDTH("fit-width");
-const char * const FIT_HEIGHT("fit-height");
+const char * const SHRINK_TO_FIT("shrinkToFit");
+const char * const SCALE_TO_FILL("scaleToFill");
+const char * const FIT_WIDTH("fitWidth");
+const char * const FIT_HEIGHT("fitHeight");
 const char * const DEFAULT("default");
 
 // sampling modes
 const char * const BOX("box");
 const char * const NEAREST("nearest");
 const char * const LINEAR("linear");
-const char * const BOX_THEN_NEAREST("box-then-nearest");
-const char * const BOX_THEN_LINEAR("box-then-linear");
-const char * const NO_FILTER("no-filter");
-const char * const DONT_CARE("dont-care");
+const char * const BOX_THEN_NEAREST("boxThenNearest");
+const char * const BOX_THEN_LINEAR("boxThenLinear");
+const char * const NO_FILTER("noFilter");
+const char * const DONT_CARE("dontCare");
 
-std::string TEXTURE_UNIFORM_NAME = "sTexture";
+const std::string ATLAS_RECT_UNIFORM_NAME = "uAtlasRect";
+const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea";
+
+const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
+
+const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
 
 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
   attribute mediump vec2 aPosition;\n
-  varying mediump vec2 vTexCoord;\n
   uniform mediump mat4 uMvpMatrix;\n
   uniform mediump vec3 uSize;\n
+  uniform mediump vec4 uAtlasRect;\n
+  uniform mediump vec4 pixelArea;
+  varying mediump vec2 vTexCoord;\n
   \n
   void main()\n
   {\n
@@ -75,7 +92,7 @@ const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
     vertexPosition.xyz *= uSize;\n
     vertexPosition = uMvpMatrix * vertexPosition;\n
     \n
-    vTexCoord = aPosition + vec2(0.5);\n
+    vTexCoord = mix( uAtlasRect.xy, uAtlasRect.zw, pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) ) );\n
     gl_Position = vertexPosition;\n
   }\n
 );
@@ -91,13 +108,37 @@ const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
   }\n
 );
 
+Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gridSize )
+{
+  Geometry geometry;
+
+  if( gridSize == ImageDimensions( 1, 1 ) )
+  {
+    geometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
+    if( !geometry )
+    {
+      geometry =  RendererFactoryCache::CreateQuadGeometry();
+      factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, geometry );
+    }
+  }
+  else
+  {
+    geometry = RendererFactoryCache::CreateGridGeometry( gridSize );
+  }
+
+  return geometry;
+}
+
 } //unnamed namespace
 
-ImageRenderer::ImageRenderer()
-: ControlRenderer(),
+ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
+: ControlRenderer( factoryCache ),
+  mAtlasManager( atlasManager ),
   mDesiredSize(),
   mFittingMode( FittingMode::DEFAULT ),
-  mSamplingMode( SamplingMode::DEFAULT )
+  mSamplingMode( SamplingMode::DEFAULT ),
+  mNativeFragmentShaderCode( ),
+  mNativeImageFlag( false )
 {
 }
 
@@ -105,14 +146,18 @@ ImageRenderer::~ImageRenderer()
 {
 }
 
-void ImageRenderer::Initialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
+void ImageRenderer::DoInitialize( Actor& actor, const Property::Map& propertyMap )
 {
-  Initialize(factoryCache);
+  std::string oldImageUrl = mImageUrl;
 
   Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
   if( imageURLValue )
   {
     imageURLValue->Get( mImageUrl );
+    if( !mImageUrl.empty() )
+    {
+      mImage.Reset();
+    }
 
     Property::Value* fittingValue = propertyMap.Find( IMAGE_FITTING_MODE );
     if( fittingValue )
@@ -209,7 +254,31 @@ void ImageRenderer::Initialize( RendererFactoryCache& factoryCache, const Proper
     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
   }
 
-  mImage.Reset();
+  // remove old renderer if exit
+  if( mImpl->mRenderer )
+  {
+    if( actor ) //remove old renderer from actor
+    {
+      actor.RemoveRenderer( mImpl->mRenderer );
+    }
+    if( !oldImageUrl.empty() ) //clean old renderer from cache
+    {
+      CleanCache( oldImageUrl );
+    }
+  }
+
+  NativeImage nativeImage = NativeImage::DownCast( mImage );
+
+  if( nativeImage )
+  {
+    SetNativeFragmentShaderCode( nativeImage );
+  }
+
+  // if actor is on stage, create new renderer and apply to actor
+  if( actor && actor.OnStage() )
+  {
+    SetOnStage( actor );
+  }
 }
 
 void ImageRenderer::SetSize( const Vector2& size )
@@ -251,14 +320,170 @@ void ImageRenderer::SetOffset( const Vector2& offset )
 {
 }
 
+Renderer ImageRenderer::CreateRenderer() const
+{
+  Geometry geometry;
+  Shader shader;
+
+  // If mImage is nativeImage with custom sampler or prefix, mNativeFragmentShaderCode will be applied.
+  // Renderer can't be shared between NativeImage and other image types.
+  if( !mNativeFragmentShaderCode.empty() )
+  {
+    return CreateNativeImageRenderer();
+  }
+
+  if( !mImpl->mCustomShader )
+  {
+    geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+
+    shader = GetImageShader(mFactoryCache);
+  }
+  else
+  {
+    geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
+    if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
+    {
+      shader = GetImageShader(mFactoryCache);
+    }
+    else
+    {
+      shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
+                             mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER : mImpl->mCustomShader->mFragmentShader,
+                             mImpl->mCustomShader->mHints );
+      if( mImpl->mCustomShader->mVertexShader.empty() )
+      {
+        shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+        shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+      }
+    }
+  }
+
+  TextureSet textureSet = TextureSet::New();
+
+  Renderer renderer = Renderer::New( geometry, shader );
+  renderer.SetTextures( textureSet );
+
+  return renderer;
+}
+
+Renderer ImageRenderer::CreateNativeImageRenderer() const
+{
+  Geometry geometry;
+  Shader shader;
+
+  if( !mImpl->mCustomShader )
+  {
+    geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+
+    shader  = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
+    shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+    shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+  }
+  else
+  {
+    geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
+    if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
+    {
+      shader  = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
+    }
+    else
+    {
+      shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
+                             mNativeFragmentShaderCode,
+                             mImpl->mCustomShader->mHints );
+      if( mImpl->mCustomShader->mVertexShader.empty() )
+      {
+        shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+        shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+      }
+    }
+  }
+
+  TextureSet textureSet = TextureSet::New();
+  Renderer renderer = Renderer::New( geometry, shader );
+  renderer.SetTextures( textureSet );
+
+  return renderer;
+}
+
+void ImageRenderer::InitializeRenderer( const std::string& imageUrl )
+{
+  if( imageUrl.empty() )
+  {
+    return;
+  }
+
+  mImageUrl = imageUrl;
+  mImpl->mRenderer.Reset();
+
+  if( !mImpl->mCustomShader &&
+      ( strncasecmp( imageUrl.c_str(), HTTP_URL,  sizeof(HTTP_URL)  -1 ) != 0 ) && // ignore remote images
+      ( strncasecmp( imageUrl.c_str(), HTTPS_URL, sizeof(HTTPS_URL) -1 ) != 0 ) )
+  {
+    mImpl->mRenderer = mFactoryCache.GetRenderer( imageUrl );
+    if( !mImpl->mRenderer )
+    {
+      Vector4 atlasRect;
+      TextureSet textureSet = mAtlasManager.Add(atlasRect, imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+      if( textureSet )
+      {
+        Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+        Shader shader( GetImageShader(mFactoryCache) );
+        mImpl->mRenderer = Renderer::New( geometry, shader );
+        mImpl->mRenderer.SetTextures( textureSet );
+        mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
+      }
+      else // big image, atlasing is not applied
+      {
+        mImpl->mRenderer = CreateRenderer();
+
+        ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+        image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+        TextureSet textureSet = mImpl->mRenderer.GetTextures();
+        textureSet.SetImage( 0u, image );
+      }
+
+      mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
+    }
+
+    mImpl->mFlags |= Impl::IS_FROM_CACHE;
+  }
+  else
+  {
+    // for custom shader or remote image, renderer is not cached and atlas is not applied
+
+    mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
+    mImpl->mRenderer = CreateRenderer();
+    ResourceImage resourceImage = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+    resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+    ApplyImageToSampler( resourceImage );
+  }
+}
+
+void ImageRenderer::InitializeRenderer( const Image& image )
+{
+  mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
+
+  mImpl->mRenderer = CreateRenderer();
+
+  if( image )
+  {
+    ApplyImageToSampler( image );
+  }
+}
+
+
 void ImageRenderer::DoSetOnStage( Actor& actor )
 {
-  if( !mImageUrl.empty() && !mImage )
+  if( !mImageUrl.empty() )
   {
-    mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+    InitializeRenderer( mImageUrl );
+  }
+  else
+  {
+    InitializeRenderer( mImage );
   }
 
-  ApplyImageToSampler();
 }
 
 void ImageRenderer::DoSetOffStage( Actor& actor )
@@ -266,11 +491,18 @@ void ImageRenderer::DoSetOffStage( Actor& actor )
   //If we own the image then make sure we release it when we go off stage
   if( !mImageUrl.empty() )
   {
+    actor.RemoveRenderer( mImpl->mRenderer );
+    CleanCache(mImageUrl);
     mImage.Reset();
   }
+  else
+  {
+    actor.RemoveRenderer( mImpl->mRenderer );
+    mImpl->mRenderer.Reset();
+  }
 }
 
-void ImageRenderer::CreatePropertyMap( Property::Map& map ) const
+void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const
 {
   map.Clear();
   map.Insert( RENDERER_TYPE, RENDERER_TYPE_VALUE );
@@ -366,99 +598,210 @@ void ImageRenderer::CreatePropertyMap( Property::Map& map ) const
   }
 }
 
-void ImageRenderer::Initialize( RendererFactoryCache& factoryCache )
+Shader ImageRenderer::GetImageShader( RendererFactoryCache& factoryCache )
 {
-  mImpl->mGeometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
-  if( !(mImpl->mGeometry) )
+  Shader shader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
+  if( !shader )
   {
-    mImpl->mGeometry =  factoryCache.CreateQuadGeometry();
-    factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, mImpl->mGeometry );
+    shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+    factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader );
+    shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+    shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
   }
-
-  mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
-  if( !mImpl->mShader )
-  {
-    mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
-    factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, mImpl->mShader );
-  }
-
-  mDesiredSize = ImageDimensions();
-  mFittingMode = FittingMode::DEFAULT;
-  mSamplingMode = SamplingMode::DEFAULT;
-  mImageUrl.clear();
-}
-
-void ImageRenderer::SetImage( const std::string& imageUrl )
-{
-  SetImage( imageUrl, 0, 0, Dali::FittingMode::DEFAULT, Dali::SamplingMode::DEFAULT );
+  return shader;
 }
 
-void ImageRenderer::SetImage( const std::string& imageUrl, int desiredWidth, int desiredHeight, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
+void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
 {
   if( mImageUrl != imageUrl )
   {
+    std::string oldImageUrl = mImageUrl;
     mImageUrl = imageUrl;
-    mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
+    mDesiredSize = size;
     mFittingMode = fittingMode;
     mSamplingMode = samplingMode;
+    mImage.Reset();
 
-    if( !mImageUrl.empty() && mImpl->mIsOnStage )
+    if( mImpl->mRenderer )
     {
-      mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
-      ApplyImageToSampler();
-    }
-    else
-    {
-      mImage.Reset();
+      if( GetIsFromCache() ) // if renderer is from cache, remove the old one
+      {
+        //remove old renderer
+        if( actor )
+        {
+          actor.RemoveRenderer( mImpl->mRenderer );
+        }
+
+        //clean the cache
+        if( !oldImageUrl.empty() )
+        {
+          CleanCache(oldImageUrl);
+        }
+
+        if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
+        {
+          SetOnStage(actor);
+        }
+      }
+      else // if renderer is not from cache, reuse the same renderer and only change the texture
+      {
+        ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+        image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+        ApplyImageToSampler( image );
+      }
     }
   }
 }
 
-void ImageRenderer::SetImage( Image image )
+void ImageRenderer::SetImage( Actor& actor, const Image& image )
 {
   if( mImage != image )
   {
+    NativeImage newNativeImage = NativeImage::DownCast( image );
+    bool newRendererFlag = true;
+
+    if( newNativeImage && !mNativeImageFlag )
+    {
+      SetNativeFragmentShaderCode( newNativeImage );
+    }
+
+    if( ( newNativeImage && mNativeImageFlag ) || ( !newNativeImage && !mNativeImageFlag ) )
+    {
+      newRendererFlag = false;
+    }
+
+    if( newNativeImage )
+    {
+      mNativeImageFlag = true;
+    }
+    else
+    {
+      mNativeFragmentShaderCode.clear();
+      mNativeImageFlag = false;
+    }
+
+    mImage = image;
+
+    if( mImpl->mRenderer )
+    {
+      // if renderer is from cache, remove the old one, and create new renderer
+      if( GetIsFromCache() )
+      {
+        //remove old renderer
+        if( actor )
+        {
+          actor.RemoveRenderer( mImpl->mRenderer );
+        }
+
+        //clean the cache
+        if( !mImageUrl.empty() )
+        {
+          CleanCache(mImageUrl);
+        }
+        mImageUrl.clear();
+
+        if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
+        {
+          SetOnStage(actor);
+        }
+      }
+      // if input image is nativeImage and mImage is regular image or the reverse, remove the old one, and create new renderer
+      else if( newRendererFlag )
+      {
+        //remove old renderer
+        if( actor )
+        {
+          actor.RemoveRenderer( mImpl->mRenderer );
+        }
+
+        if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
+        {
+          SetOnStage(actor);
+        }
+      }
+      else // if renderer is not from cache, reuse the same renderer and only change the texture
+      {
+        ApplyImageToSampler( image );
+      }
+    }
+
     mImageUrl.clear();
     mDesiredSize = ImageDimensions();
     mFittingMode = FittingMode::DEFAULT;
     mSamplingMode = SamplingMode::DEFAULT;
-    mImage = image;
+  }
+}
 
-    if( mImage && mImpl->mIsOnStage )
+void ImageRenderer::ApplyImageToSampler( const Image& image )
+{
+  if( image )
+  {
+    TextureSet textureSet = mImpl->mRenderer.GetTextures();
+    if( textureSet )
     {
-      ApplyImageToSampler();
+      textureSet.SetImage( 0u, image );
     }
   }
 }
 
-Image ImageRenderer::GetImage() const
+void ImageRenderer::OnImageLoaded( ResourceImage image )
 {
-  return mImage;
+  if( image.GetLoadingState() == Dali::ResourceLoadingFailed )
+  {
+    Image brokenImage = RendererFactory::GetBrokenRendererImage();
+    if( mImpl->mRenderer )
+    {
+      ApplyImageToSampler( brokenImage );
+    }
+  }
 }
 
-void ImageRenderer::ApplyImageToSampler()
+void ImageRenderer::CleanCache(const std::string& url)
 {
-  if( mImage )
+  TextureSet textureSet = mImpl->mRenderer.GetTextures();
+
+  Vector4 atlasRect( 0.f, 0.f, 1.f, 1.f );
+  Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
+  if( index != Property::INVALID_INDEX )
   {
-    Material material = mImpl->mRenderer.GetMaterial();
-    if( material )
-    {
-      for( std::size_t i = 0; i < material.GetNumberOfSamplers(); ++i )
-      {
-        Sampler sampler = material.GetSamplerAt( i );
-        if( sampler.GetUniformName() == TEXTURE_UNIFORM_NAME )
-        {
-          sampler.SetImage( mImage );
-          return;
-        }
-      }
+    Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index );
+    atlasRectValue.Get( atlasRect );
+  }
 
-      Sampler sampler = Sampler::New( mImage, TEXTURE_UNIFORM_NAME );
-      material.AddSampler( sampler );
-    }
+  mImpl->mRenderer.Reset();
+  if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX )
+  {
+    mAtlasManager.Remove( textureSet, atlasRect );
   }
 }
 
+void ImageRenderer::SetNativeFragmentShaderCode( Dali::NativeImage& nativeImage )
+{
+  const char* fragmentPreFix = nativeImage.GetCustomFragmentPreFix();
+  const char* customSamplerTypename = nativeImage.GetCustomSamplerTypename();
+
+  if( fragmentPreFix )
+  {
+    mNativeFragmentShaderCode = fragmentPreFix;
+    mNativeFragmentShaderCode += "\n";
+  }
+
+  if( mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty() )
+  {
+    mNativeFragmentShaderCode += mImpl->mCustomShader->mFragmentShader;
+  }
+  else
+  {
+    mNativeFragmentShaderCode += FRAGMENT_SHADER;
+  }
+
+  if( customSamplerTypename )
+  {
+    mNativeFragmentShaderCode.replace( mNativeFragmentShaderCode.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
+  }
+
+}
+
 } // namespace Internal
 
 } // namespace Toolkit