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=058f2b90cb9bcc199470cb0ad75097f88463b74d;hp=a9af3ec7222f2dc27c1b1a35fa6f0a7f24562882;hb=54fbf47db890d0479d19d780de5ea5d860924632;hpb=bf55f2a930b7fb89786b58a511cde6e987154034

diff --git a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
index a9af3ec..058f2b9 100644
--- a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
+++ b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,10 +19,16 @@
 #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/devel-api/images/atlas.h>
+#include <dali/devel-api/images/texture-set-image.h>
+#include <dali/devel-api/adaptor-framework/bitmap-loader.h>
 #include <dali/integration-api/debug.h>
 
 // INTERNAL HEADER
+#include <dali-toolkit/internal/controls/renderers/renderer-string-constants.h>
 #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>
@@ -40,42 +46,45 @@ namespace Internal
 
 namespace
 {
-const char * const RENDERER_TYPE("rendererType");
-const char * const RENDERER_TYPE_VALUE("imageRenderer");
+const char HTTP_URL[] = "http://";
+const char HTTPS_URL[] = "https://";
 
 // property names
-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" );
+const char * const IMAGE_FITTING_MODE( "fittingMode" );
+const char * const IMAGE_SAMPLING_MODE( "samplingMode" );
+const char * const IMAGE_DESIRED_WIDTH( "desiredWidth" );
+const char * const IMAGE_DESIRED_HEIGHT( "desiredHeight" );
+const char * const SYNCHRONOUS_LOADING( "synchronousLoading" );
 
 // fitting modes
-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");
+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 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("boxThenNearest");
-const char * const BOX_THEN_LINEAR("boxThenLinear");
-const char * const NO_FILTER("noFilter");
-const char * const DONT_CARE("dontCare");
-
-const std::string TEXTURE_UNIFORM_NAME = "sTexture";
-const std::string TEXTURE_RECT_UNIFORM_NAME = "uTextureRect";
+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 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 uTextureRect;\n
+  uniform mediump vec4 uAtlasRect;\n
+  uniform mediump vec4 pixelArea;
+  varying mediump vec2 vTexCoord;\n
   \n
   void main()\n
   {\n
@@ -83,7 +92,7 @@ const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
     vertexPosition.xyz *= uSize;\n
     vertexPosition = uMvpMatrix * vertexPosition;\n
     \n
-    vTexCoord = mix( uTextureRect.xy, uTextureRect.zw, 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
 );
@@ -99,33 +108,6 @@ const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
   }\n
 );
 
-Geometry GenerateGeometry( const Vector< Vector2 >& vertices, const Vector< unsigned int >& indices )
-{
-  Property::Map vertexFormat;
-  vertexFormat[ "aPosition" ] = Property::VECTOR2;
-  PropertyBuffer vertexPropertyBuffer = PropertyBuffer::New( vertexFormat, vertices.Size() );
-  if( vertices.Size() > 0 )
-  {
-    vertexPropertyBuffer.SetData( &vertices[ 0 ] );
-  }
-
-  Property::Map indexFormat;
-  indexFormat[ "indices" ] = Property::INTEGER;
-  PropertyBuffer indexPropertyBuffer = PropertyBuffer::New( indexFormat, indices.Size() );
-  if( indices.Size() > 0 )
-  {
-    indexPropertyBuffer.SetData( &indices[ 0 ] );
-  }
-
-  // Create the geometry object
-  Geometry geometry = Geometry::New();
-  geometry.AddVertexBuffer( vertexPropertyBuffer );
-  geometry.SetIndexBuffer( indexPropertyBuffer );
-  geometry.SetGeometryType( Geometry::TRIANGLE_STRIP );
-
-  return geometry;
-}
-
 Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gridSize )
 {
   Geometry geometry;
@@ -135,54 +117,13 @@ Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gri
     geometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
     if( !geometry )
     {
-      geometry =  factoryCache.CreateQuadGeometry();
+      geometry =  RendererFactoryCache::CreateQuadGeometry();
       factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, geometry );
     }
   }
   else
   {
-    uint16_t gridWidth = gridSize.GetWidth();
-    uint16_t gridHeight = gridSize.GetHeight();
-
-    // Create vertices
-    Vector< Vector2 > vertices;
-    vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
-
-    for( int y = 0; y < gridHeight + 1; ++y )
-    {
-      for( int x = 0; x < gridWidth + 1; ++x )
-      {
-        vertices.PushBack( Vector2( (float)x/gridWidth - 0.5f, (float)y/gridHeight  - 0.5f) );
-      }
-    }
-
-    // Create indices
-    Vector< unsigned int > indices;
-    indices.Reserve( (gridWidth+2)*gridHeight*2 - 2);
-
-    for( unsigned int row = 0u; row < gridHeight; ++row )
-    {
-      unsigned int rowStartIndex = row*(gridWidth+1u);
-      unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u;
-
-      if( row != 0u ) // degenerate index on non-first row
-      {
-        indices.PushBack( rowStartIndex );
-      }
-
-      for( unsigned int column = 0u; column < gridWidth+1u; column++) // main strip
-      {
-        indices.PushBack( rowStartIndex + column);
-        indices.PushBack( nextRowStartIndex + column);
-      }
-
-      if( row != gridHeight-1u ) // degenerate index on non-last row
-      {
-        indices.PushBack( nextRowStartIndex + gridWidth );
-      }
-    }
-
-    return GenerateGeometry( vertices, indices );
+    geometry = RendererFactoryCache::CreateGridGeometry( gridSize );
   }
 
   return geometry;
@@ -193,10 +134,11 @@ Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gri
 ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
 : ControlRenderer( factoryCache ),
   mAtlasManager( atlasManager ),
-  mTextureRect( FULL_TEXTURE_RECT ),
   mDesiredSize(),
   mFittingMode( FittingMode::DEFAULT ),
-  mSamplingMode( SamplingMode::DEFAULT )
+  mSamplingMode( SamplingMode::DEFAULT ),
+  mNativeFragmentShaderCode( ),
+  mNativeImageFlag( false )
 {
 }
 
@@ -310,37 +252,55 @@ void ImageRenderer::DoInitialize( Actor& actor, const Property::Map& propertyMap
     }
 
     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
+
   }
 
-  if( mImpl->mRenderer )
+  Property::Value* syncLoading = propertyMap.Find( SYNCHRONOUS_LOADING );
+  if( syncLoading )
   {
-    //remove old renderer
-    if( actor )
+    bool sync;
+    syncLoading->Get( sync );
+    if( sync )
     {
-      actor.RemoveRenderer( mImpl->mRenderer );
+      mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
     }
-
-    //clean the cache
-    if( !oldImageUrl.empty() )
+    else
     {
-      CleanCache( oldImageUrl );
+      mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
     }
+  }
 
-    //Initialize the renderer
-    if( !mImageUrl.empty() )
+  // if sync loading is required, the loading should start immediately when new image url is set or the actor is off stage
+  // ( for on-stage actor with image url unchanged, resource loading is already finished)
+  if( ( !mImpl->mRenderer || imageURLValue) && IsSynchronousResourceLoading() )
+  {
+    DoSynchronousResourceLoading();
+  }
+
+  // remove old renderer if exit
+  if( mImpl->mRenderer )
+  {
+    if( actor ) //remove old renderer from actor
     {
-      InitializeRenderer( mImageUrl );
+      actor.RemoveRenderer( mImpl->mRenderer );
     }
-    else if( mImage )
+    if( !oldImageUrl.empty() ) //clean old renderer from cache
     {
-      InitializeRenderer( mImage );
+      CleanCache( oldImageUrl );
     }
+  }
 
-    //add the new renderer to the actor
-    if( actor && mImpl->mRenderer )
-    {
-      actor.AddRenderer( mImpl->mRenderer );
-    }
+  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 );
   }
 }
 
@@ -388,9 +348,17 @@ 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
@@ -405,60 +373,167 @@ Renderer ImageRenderer::CreateRenderer() const
       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 );
+      }
     }
   }
 
-  Material material = Material::New( shader );
-  return Renderer::New( geometry, material );
+  Renderer renderer = Renderer::New( geometry, shader );
+
+  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 );
+    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;
+}
+
+
+bool ImageRenderer::IsSynchronousResourceLoading() const
+{
+  return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
+}
+
+void ImageRenderer::DoSynchronousResourceLoading()
+{
+  if( !mImageUrl.empty() )
+  {
+    BitmapLoader loader = BitmapLoader::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+    loader.Load();
+    mPixels = loader.GetPixelData();
+  }
+}
+
+Image ImageRenderer::LoadImage( const std::string& url, bool synchronousLoading )
+{
+  if( synchronousLoading )
+  {
+    if( !mPixels )
+    {
+      // use broken image
+      return RendererFactory::GetBrokenRendererImage();
+    }
+    Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
+    image.Upload( mPixels, 0, 0 );
+    return image;
+  }
+  else
+  {
+    ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
+    resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+    return resourceImage;
+  }
+}
+
+TextureSet ImageRenderer::CreateTextureSet( Vector4& textureRect, const std::string& url, bool synchronousLoading )
+{
+  TextureSet textureSet;
+  textureRect = FULL_TEXTURE_RECT;
+  if( synchronousLoading )
+  {
+    if( !mPixels )
+    {
+      // use broken image
+      textureSet = TextureSet::New();
+      TextureSetImage( textureSet, 0u, RendererFactory::GetBrokenRendererImage() );
+    }
+    else
+    {
+      textureSet = mAtlasManager.Add(textureRect, mPixels );
+      if( !textureSet ) // big image, no atlasing
+      {
+        Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
+        image.Upload( mPixels, 0, 0 );
+        textureSet = TextureSet::New();
+        TextureSetImage( textureSet, 0u, image );
+      }
+    }
+  }
+  else
+  {
+    textureSet = mAtlasManager.Add(textureRect, url, mDesiredSize, mFittingMode, mSamplingMode );
+    if( !textureSet ) // big image, no atlasing
+    {
+      ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
+      resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+      textureSet = TextureSet::New();
+      TextureSetImage( textureSet, 0u, resourceImage );
+    }
+  }
+
+  return textureSet;
 }
 
 void ImageRenderer::InitializeRenderer( const std::string& imageUrl )
 {
-  if( mImageUrl.empty() )
+  if( imageUrl.empty() )
   {
-    mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
     return;
   }
 
+  mImageUrl = imageUrl;
   mImpl->mRenderer.Reset();
-  if( !mImpl->mCustomShader )
+
+  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 )
     {
-        Material material = mAtlasManager.Add(mTextureRect, imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
-        if( material )
-        {
-          Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
-          mImpl->mRenderer = Renderer::New( geometry, material );
-          SetTextureRectUniform(mTextureRect);
-        }
-        else // big image, atlasing is not applied
-        {
-          mImpl->mRenderer = CreateRenderer();
-          SetTextureRectUniform(FULL_TEXTURE_RECT);
-
-          ResourceImage image = Dali::ResourceImage::New( imageUrl );
-          image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
-          Material material = mImpl->mRenderer.GetMaterial();
-          material.AddTexture( image, TEXTURE_UNIFORM_NAME );
-        }
-
-        mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
-    }
-    else
-    {
-      Property::Value textureRect = mImpl->mRenderer.GetProperty( mImpl->mRenderer.GetPropertyIndex(TEXTURE_RECT_UNIFORM_NAME) );
-      textureRect.Get( mTextureRect );
+      Vector4 atlasRect;
+      TextureSet textureSet = CreateTextureSet(atlasRect, imageUrl, IsSynchronousResourceLoading() );
+      Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+      Shader shader( GetImageShader(mFactoryCache) );
+      mImpl->mRenderer = Renderer::New( geometry, shader );
+      mImpl->mRenderer.SetTextures( textureSet );
+      if( atlasRect != FULL_TEXTURE_RECT )
+      {
+        mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
+      }
+      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 image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
-    image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+    Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
     ApplyImageToSampler( image );
   }
 }
@@ -467,14 +542,12 @@ void ImageRenderer::InitializeRenderer( const Image& image )
 {
   mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
 
-  if( !image )
+  mImpl->mRenderer = CreateRenderer();
+
+  if( image )
   {
-    return;
+    ApplyImageToSampler( image );
   }
-
-  mImpl->mRenderer = CreateRenderer();
-  ApplyImageToSampler( image );
-  SetTextureRectUniform( FULL_TEXTURE_RECT );
 }
 
 
@@ -484,26 +557,11 @@ void ImageRenderer::DoSetOnStage( Actor& actor )
   {
     InitializeRenderer( mImageUrl );
   }
-  else if( mImage )
+  else
   {
     InitializeRenderer( mImage );
   }
 
-  if( !GetIsFromCache() )
-  {
-    Image image = mImage;
-    if( !mImageUrl.empty() )
-    {
-      ResourceImage resourceImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
-      resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
-      image = resourceImage;
-
-      // Set value to the uTextureRect uniform
-      SetTextureRectUniform( FULL_TEXTURE_RECT );
-    }
-
-    ApplyImageToSampler( image );
-  }
 }
 
 void ImageRenderer::DoSetOffStage( Actor& actor )
@@ -513,7 +571,6 @@ void ImageRenderer::DoSetOffStage( Actor& actor )
   {
     actor.RemoveRenderer( mImpl->mRenderer );
     CleanCache(mImageUrl);
-
     mImage.Reset();
   }
   else
@@ -526,7 +583,10 @@ void ImageRenderer::DoSetOffStage( Actor& actor )
 void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const
 {
   map.Clear();
-  map.Insert( RENDERER_TYPE, RENDERER_TYPE_VALUE );
+  map.Insert( RENDERER_TYPE, IMAGE_RENDERER );
+
+  bool sync = IsSynchronousResourceLoading();
+  map.Insert( SYNCHRONOUS_LOADING, sync );
   if( !mImageUrl.empty() )
   {
     map.Insert( IMAGE_URL_NAME, mImageUrl );
@@ -626,21 +686,31 @@ Shader ImageRenderer::GetImageShader( RendererFactoryCache& factoryCache )
   {
     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 );
   }
   return shader;
 }
 
 void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
 {
-  mDesiredSize = size;
-  mFittingMode = fittingMode;
-  mSamplingMode = samplingMode;
-
   if( mImageUrl != imageUrl )
   {
+    std::string oldImageUrl = mImageUrl;
+    mImageUrl = imageUrl;
+    mDesiredSize = size;
+    mFittingMode = fittingMode;
+    mSamplingMode = samplingMode;
+    mImage.Reset();
+
+    if( IsSynchronousResourceLoading() )
+    {
+      DoSynchronousResourceLoading();
+    }
+
     if( mImpl->mRenderer )
     {
-      if( GetIsFromCache() )
+      if( GetIsFromCache() ) // if renderer is from cache, remove the old one
       {
         //remove old renderer
         if( actor )
@@ -649,31 +719,22 @@ void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl, ImageDi
         }
 
         //clean the cache
-        if( !mImageUrl.empty() )
+        if( !oldImageUrl.empty() )
         {
-          CleanCache(mImageUrl);
+          CleanCache(oldImageUrl);
         }
 
-        //Initialize the renderer
-        InitializeRenderer( imageUrl );
-
-        //add the new renderer to the actor
-        if( actor && mImpl->mRenderer )
+        if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
         {
-          actor.AddRenderer( mImpl->mRenderer );
+          SetOnStage(actor);
         }
       }
-      else
+      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 );
+        Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
         ApplyImageToSampler( image );
       }
     }
-
-    mImageUrl = imageUrl;
-
-    mImage.Reset();
   }
 }
 
@@ -681,8 +742,34 @@ 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
@@ -696,24 +783,33 @@ void ImageRenderer::SetImage( Actor& actor, const Image& image )
         {
           CleanCache(mImageUrl);
         }
+        mImageUrl.clear();
 
-        //Initialize the renderer
-        InitializeRenderer( image );
+        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 );
+        }
 
-        //add the new renderer to the actor
-        if( actor && mImpl->mRenderer )
+        if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
         {
-          actor.AddRenderer( mImpl->mRenderer );
+          SetOnStage(actor);
         }
       }
-      else
+      else // if renderer is not from cache, reuse the same renderer and only change the texture
       {
         ApplyImageToSampler( image );
       }
     }
-    SetTextureRectUniform( FULL_TEXTURE_RECT );
 
-    mImage = image;
     mImageUrl.clear();
     mDesiredSize = ImageDimensions();
     mFittingMode = FittingMode::DEFAULT;
@@ -725,18 +821,13 @@ void ImageRenderer::ApplyImageToSampler( const Image& image )
 {
   if( image )
   {
-    Material material = mImpl->mRenderer.GetMaterial();
-    if( material )
+    TextureSet textureSet = mImpl->mRenderer.GetTextures();
+    if( !textureSet )
     {
-      int index = material.GetTextureIndex( TEXTURE_UNIFORM_NAME );
-      if( index != -1 )
-      {
-        material.SetTextureImage( index, image );
-        return;
-      }
-
-      material.AddTexture( image, TEXTURE_UNIFORM_NAME );
+      textureSet = TextureSet::New();
+      mImpl->mRenderer.SetTextures( textureSet );
     }
+    TextureSetImage( textureSet, 0u, image );
   }
 }
 
@@ -744,37 +835,56 @@ void ImageRenderer::OnImageLoaded( ResourceImage image )
 {
   if( image.GetLoadingState() == Dali::ResourceLoadingFailed )
   {
-    Image image = RendererFactory::GetBrokenRendererImage();
+    Image brokenImage = RendererFactory::GetBrokenRendererImage();
     if( mImpl->mRenderer )
     {
-      ApplyImageToSampler( image );
+      ApplyImageToSampler( brokenImage );
     }
   }
 }
 
-void ImageRenderer::SetTextureRectUniform( const Vector4& textureRect )
+void ImageRenderer::CleanCache(const std::string& url)
 {
-  if( mImpl->mRenderer )
+  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 )
   {
-    Property::Index index = mImpl->mRenderer.GetPropertyIndex( TEXTURE_RECT_UNIFORM_NAME );
-    if( index == Property::INVALID_INDEX )
-    {
-      index = mImpl->mRenderer.RegisterProperty( TEXTURE_RECT_UNIFORM_NAME, textureRect );
-    }
-    else
-    {
-      mImpl->mRenderer.SetProperty( index, textureRect );
-    }
+    Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index );
+    atlasRectValue.Get( atlasRect );
+  }
+
+  mImpl->mRenderer.Reset();
+  if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX )
+  {
+    mAtlasManager.Remove( textureSet, atlasRect );
   }
 }
 
-void ImageRenderer::CleanCache(const std::string& url)
+void ImageRenderer::SetNativeFragmentShaderCode( Dali::NativeImage& nativeImage )
 {
-  Material material = mImpl->mRenderer.GetMaterial();
-  mImpl->mRenderer.Reset();
-  if( mFactoryCache.CleanRendererCache( url ) )
+  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 )
   {
-    mAtlasManager.Remove( material, mTextureRect );
+    mNativeFragmentShaderCode.replace( mNativeFragmentShaderCode.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
   }
 }