dali-toolkit/internal/visuals/image/image-visual.cpp

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "image-visual.h"
  20
  21 // EXTERNAL HEADER
  22 #include <cstring> // for strncasecmp
  23 #include <dali/public-api/images/resource-image.h>
  24 #include <dali/public-api/images/native-image.h>
  25 #include <dali/devel-api/images/atlas.h>
  26 #include <dali/devel-api/images/texture-set-image.h>
  27 #include <dali/devel-api/adaptor-framework/bitmap-loader.h>
  28 #include <dali/devel-api/scripting/enum-helper.h>
  29 #include <dali/devel-api/scripting/scripting.h>
  30 #include <dali/integration-api/debug.h>
  31
  32 // INTERNAL HEADER
  33 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  34 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  35 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
  36 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  37 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
  38 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
  39 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  40
  41 namespace Dali
  42 {
  43
  44 namespace Toolkit
  45 {
  46
  47 namespace Internal
  48 {
  49
  50 namespace
  51 {
  52 const char HTTP_URL[] = "http://";
  53 const char HTTPS_URL[] = "https://";
  54
  55 // property names
  56 const char * const IMAGE_FITTING_MODE( "fittingMode" );
  57 const char * const IMAGE_SAMPLING_MODE( "samplingMode" );
  58 const char * const IMAGE_DESIRED_WIDTH( "desiredWidth" );
  59 const char * const IMAGE_DESIRED_HEIGHT( "desiredHeight" );
  60 const char * const IMAGE_WRAP_MODE_U("wrapModeU");
  61 const char * const IMAGE_WRAP_MODE_V("wrapModeV");
  62 const char * const SYNCHRONOUS_LOADING( "synchronousLoading" );
  63 const char * const BATCHING_ENABLED( "batchingEnabled" );
  64
  65 // fitting modes
  66 DALI_ENUM_TO_STRING_TABLE_BEGIN( FITTING_MODE )
  67 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SHRINK_TO_FIT )
  68 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SCALE_TO_FILL )
  69 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, FIT_WIDTH )
  70 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, FIT_HEIGHT )
  71 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, DEFAULT )
  72 DALI_ENUM_TO_STRING_TABLE_END( FITTING_MODE )
  73
  74 // sampling modes
  75 DALI_ENUM_TO_STRING_TABLE_BEGIN( SAMPLING_MODE )
  76 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX )
  77 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, NEAREST )
  78 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, LINEAR )
  79 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX_THEN_NEAREST )
  80 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX_THEN_LINEAR )
  81 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, NO_FILTER )
  82 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, DONT_CARE )
  83 DALI_ENUM_TO_STRING_TABLE_END( SAMPLING_MODE )
  84
  85 // wrap modes
  86 DALI_ENUM_TO_STRING_TABLE_BEGIN( WRAP_MODE )
  87 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, DEFAULT )
  88 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, CLAMP_TO_EDGE )
  89 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, REPEAT )
  90 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT )
  91 DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE )
  92
  93 const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea";
  94 const std::string WRAP_MODE_UNIFORM_NAME = "wrapMode";
  95
  96 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  97
  98 const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
  99
 100 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
 101   attribute mediump vec2 aPosition;\n
 102   uniform mediump mat4 uMvpMatrix;\n
 103   uniform mediump vec3 uSize;\n
 104   uniform mediump vec4 pixelArea;
 105   varying mediump vec2 vTexCoord;\n
 106   \n
 107   void main()\n
 108   {\n
 109     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
 110     vertexPosition.xyz *= uSize;\n
 111     vertexPosition = uMvpMatrix * vertexPosition;\n
 112     \n
 113     vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
 114     gl_Position = vertexPosition;\n
 115   }\n
 116 );
 117
 118 const char* FRAGMENT_SHADER_NO_ATLAS = DALI_COMPOSE_SHADER(
 119   varying mediump vec2 vTexCoord;\n
 120   uniform sampler2D sTexture;\n
 121   uniform lowp vec4 uColor;\n
 122   \n
 123   void main()\n
 124   {\n
 125     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
 126   }\n
 127 );
 128
 129 const char* FRAGMENT_SHADER_ATLAS_CLAMP = DALI_COMPOSE_SHADER(
 130     varying mediump vec2 vTexCoord;\n
 131     uniform sampler2D sTexture;\n
 132     uniform mediump vec4 uAtlasRect;\n
 133     uniform lowp vec4 uColor;\n
 134     \n
 135     void main()\n
 136     {\n
 137       mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );\n
 138       gl_FragColor = texture2D( sTexture, texCoord ) * uColor;\n
 139     }\n
 140 );
 141
 142 const char* FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP = DALI_COMPOSE_SHADER(
 143     varying mediump vec2 vTexCoord;\n
 144     uniform sampler2D sTexture;\n
 145     uniform mediump vec4 uAtlasRect;\n
 146     // WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
 147     uniform lowp vec2 wrapMode;\n
 148     uniform lowp vec4 uColor;\n
 149     \n
 150     mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )\n
 151     {\n
 152       mediump float coord;\n
 153       if( wrap > 1.5 )\n // REFLECT
 154         coord = 1.0-abs(fract(coordinate*0.5)*2.0 - 1.0);\n
 155       else \n// warp == 0 or 1
 156         coord = mix(coordinate, fract( coordinate ), wrap);\n
 157       return clamp( mix(range.x, range.y, coord), range.x, range.y );
 158     }\n
 159     \n
 160     void main()\n
 161     {\n
 162       mediump vec2 texCoord = vec2( wrapCoordinate( uAtlasRect.xz, vTexCoord.x, wrapMode.x ),
 163                                     wrapCoordinate( uAtlasRect.yw, vTexCoord.y, wrapMode.y ) );\n
 164       gl_FragColor = texture2D( sTexture, texCoord ) * uColor;\n
 165     }\n
 166 );
 167
 168 Geometry CreateGeometry( VisualFactoryCache& factoryCache, ImageDimensions gridSize )
 169 {
 170   Geometry geometry;
 171
 172   if( gridSize == ImageDimensions( 1, 1 ) )
 173   {
 174     geometry = factoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 175     if( !geometry )
 176     {
 177       geometry =  VisualFactoryCache::CreateQuadGeometry();
 178       factoryCache.SaveGeometry( VisualFactoryCache::QUAD_GEOMETRY, geometry );
 179     }
 180   }
 181   else
 182   {
 183     geometry = VisualFactoryCache::CreateGridGeometry( gridSize );
 184   }
 185
 186   return geometry;
 187 }
 188
 189 } //unnamed namespace
 190
 191 ImageVisual::ImageVisual( VisualFactoryCache& factoryCache )
 192 : Visual::Base( factoryCache ),
 193   mImage(),
 194   mPixels(),
 195   mPixelArea( FULL_TEXTURE_RECT ),
 196   mPlacementActor(),
 197   mImageUrl(),
 198   mDesiredSize(),
 199   mFittingMode( FittingMode::DEFAULT ),
 200   mSamplingMode( SamplingMode::DEFAULT ),
 201   mWrapModeU( WrapMode::DEFAULT ),
 202   mWrapModeV( WrapMode::DEFAULT ),
 203   mNativeFragmentShaderCode(),
 204   mNativeImageFlag( false )
 205 {
 206 }
 207
 208 ImageVisual::ImageVisual( VisualFactoryCache& factoryCache,
 209                           const std::string& imageUrl,
 210                           ImageDimensions size,
 211                           FittingMode::Type fittingMode,
 212                           Dali::SamplingMode::Type samplingMode )
 213 : Visual::Base( factoryCache ),
 214   mImage(),
 215   mPixels(),
 216   mPixelArea( FULL_TEXTURE_RECT ),
 217   mPlacementActor(),
 218   mImageUrl( imageUrl ),
 219   mDesiredSize( size ),
 220   mFittingMode( fittingMode ),
 221   mSamplingMode( samplingMode ),
 222   mWrapModeU( WrapMode::DEFAULT ),
 223   mWrapModeV( WrapMode::DEFAULT ),
 224   mNativeFragmentShaderCode(),
 225   mNativeImageFlag( false )
 226 {
 227 }
 228
 229 ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, const Image& image )
 230 : Visual::Base( factoryCache ),
 231   mImage( image ),
 232   mPixels(),
 233   mPixelArea( FULL_TEXTURE_RECT ),
 234   mPlacementActor(),
 235   mImageUrl(),
 236   mDesiredSize(),
 237   mFittingMode( FittingMode::DEFAULT ),
 238   mSamplingMode( SamplingMode::DEFAULT ),
 239   mWrapModeU( WrapMode::DEFAULT ),
 240   mWrapModeV( WrapMode::DEFAULT ),
 241   mNativeFragmentShaderCode(),
 242   mNativeImageFlag( false )
 243 {
 244   NativeImage newNativeImage = NativeImage::DownCast( image );
 245   if( newNativeImage )
 246   {
 247     SetNativeFragmentShaderCode( newNativeImage );
 248     mNativeImageFlag = true;
 249   }
 250   else
 251   {
 252     mNativeImageFlag = false;
 253   }
 254 }
 255
 256 ImageVisual::~ImageVisual()
 257 {
 258 }
 259
 260 void ImageVisual::DoInitialize( Actor& actor, const Property::Map& propertyMap )
 261 {
 262   std::string oldImageUrl = mImageUrl;
 263
 264   Property::Value* imageURLValue = propertyMap.Find( Toolkit::ImageVisual::Property::URL, IMAGE_URL_NAME );
 265   if( imageURLValue )
 266   {
 267     imageURLValue->Get( mImageUrl );
 268     if( !mImageUrl.empty() )
 269     {
 270       mImage.Reset();
 271     }
 272
 273     Property::Value* fittingValue = propertyMap.Find( Toolkit::ImageVisual::Property::FITTING_MODE, IMAGE_FITTING_MODE );
 274     if( fittingValue )
 275     {
 276       Scripting::GetEnumerationProperty( *fittingValue, FITTING_MODE_TABLE, FITTING_MODE_TABLE_COUNT, mFittingMode );
 277     }
 278
 279     Property::Value* samplingValue = propertyMap.Find( Toolkit::ImageVisual::Property::SAMPLING_MODE, IMAGE_SAMPLING_MODE );
 280     if( samplingValue )
 281     {
 282       Scripting::GetEnumerationProperty( *samplingValue, SAMPLING_MODE_TABLE, SAMPLING_MODE_TABLE_COUNT, mSamplingMode );
 283     }
 284
 285     int desiredWidth = 0;
 286     Property::Value* desiredWidthValue = propertyMap.Find( Toolkit::ImageVisual::Property::DESIRED_WIDTH, IMAGE_DESIRED_WIDTH );
 287     if( desiredWidthValue )
 288     {
 289       desiredWidthValue->Get( desiredWidth );
 290     }
 291
 292     int desiredHeight = 0;
 293     Property::Value* desiredHeightValue = propertyMap.Find( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, IMAGE_DESIRED_HEIGHT );
 294     if( desiredHeightValue )
 295     {
 296       desiredHeightValue->Get( desiredHeight );
 297     }
 298
 299     Property::Value* pixelAreaValue = propertyMap.Find( Toolkit::ImageVisual::Property::PIXEL_AREA, PIXEL_AREA_UNIFORM_NAME );
 300     if( pixelAreaValue )
 301     {
 302       pixelAreaValue->Get( mPixelArea );
 303     }
 304
 305     Property::Value* wrapModeValueU = propertyMap.Find( Toolkit::ImageVisual::Property::WRAP_MODE_U, IMAGE_WRAP_MODE_U );
 306     if( wrapModeValueU )
 307     {
 308       Scripting::GetEnumerationProperty( *wrapModeValueU, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, mWrapModeU );
 309     }
 310
 311     Property::Value* wrapModeValueV = propertyMap.Find( Toolkit::ImageVisual::Property::WRAP_MODE_V, IMAGE_WRAP_MODE_V );
 312     if( wrapModeValueV )
 313     {
 314       Scripting::GetEnumerationProperty( *wrapModeValueV, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, mWrapModeV );
 315     }
 316
 317     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
 318   }
 319
 320   Property::Value* syncLoading = propertyMap.Find( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, SYNCHRONOUS_LOADING );
 321   if( syncLoading )
 322   {
 323     bool sync;
 324     syncLoading->Get( sync );
 325     if( sync )
 326     {
 327       mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 328     }
 329     else
 330     {
 331       mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 332     }
 333   }
 334
 335   // if sync loading is required, the loading should start immediately when new image url is set or the actor is off stage
 336   // ( for on-stage actor with image url unchanged, resource loading is already finished)
 337   if( imageURLValue && IsSynchronousResourceLoading() )
 338   {
 339     LoadResourceSynchronously();
 340   }
 341
 342   NativeImage nativeImage = NativeImage::DownCast( mImage );
 343
 344   if( nativeImage )
 345   {
 346     SetNativeFragmentShaderCode( nativeImage );
 347   }
 348
 349   // if actor is on stage, create new renderer and apply to actor
 350   if( actor && actor.OnStage() )
 351   {
 352     SetOnStage( actor );
 353   }
 354 }
 355
 356 void ImageVisual::GetNaturalSize( Vector2& naturalSize ) const
 357 {
 358   if(mImage)
 359   {
 360     naturalSize.x = mImage.GetWidth();
 361     naturalSize.y = mImage.GetHeight();
 362     return;
 363   }
 364   else if( mDesiredSize.GetWidth()>0 && mDesiredSize.GetHeight()>0)
 365   {
 366     naturalSize.x = mDesiredSize.GetWidth();
 367     naturalSize.y = mDesiredSize.GetHeight();
 368     return;
 369   }
 370   else if( !mImageUrl.empty() )
 371   {
 372     ImageDimensions dimentions = ResourceImage::GetImageSize( mImageUrl );
 373     naturalSize.x = dimentions.GetWidth();
 374     naturalSize.y = dimentions.GetHeight();
 375     return;
 376   }
 377
 378   naturalSize = Vector2::ZERO;
 379 }
 380
 381 Renderer ImageVisual::CreateRenderer() const
 382 {
 383   Geometry geometry;
 384   Shader shader;
 385
 386   // If mImage is nativeImage with custom sampler or prefix, mNativeFragmentShaderCode will be applied.
 387   // Renderer can't be shared between NativeImage and other image types.
 388   if( !mNativeFragmentShaderCode.empty() )
 389   {
 390     return CreateNativeImageRenderer();
 391   }
 392
 393   if( !mImpl->mCustomShader )
 394   {
 395     geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 396
 397     shader = GetImageShader( mFactoryCache,
 398                              mImpl->mFlags & Impl::IS_ATLASING_APPLIED,
 399                              mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE );
 400   }
 401   else
 402   {
 403     geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
 404     if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
 405     {
 406       shader = GetImageShader(mFactoryCache, false, true);
 407     }
 408     else
 409     {
 410       shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
 411                              mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER_NO_ATLAS : mImpl->mCustomShader->mFragmentShader,
 412                              mImpl->mCustomShader->mHints );
 413       if( mImpl->mCustomShader->mVertexShader.empty() )
 414       {
 415         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 416       }
 417     }
 418   }
 419
 420   Renderer renderer = Renderer::New( geometry, shader );
 421
 422   return renderer;
 423 }
 424
 425 Renderer ImageVisual::CreateNativeImageRenderer() const
 426 {
 427   Geometry geometry;
 428   Shader shader;
 429
 430   if( !mImpl->mCustomShader )
 431   {
 432     geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 433
 434     shader  = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
 435     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 436   }
 437   else
 438   {
 439     geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
 440     shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
 441                            mNativeFragmentShaderCode,
 442                            mImpl->mCustomShader->mHints );
 443     if( mImpl->mCustomShader->mVertexShader.empty() )
 444     {
 445       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 446     }
 447   }
 448
 449   TextureSet textureSet = TextureSet::New();
 450   Renderer renderer = Renderer::New( geometry, shader );
 451   renderer.SetTextures( textureSet );
 452   return renderer;
 453 }
 454
 455
 456 bool ImageVisual::IsSynchronousResourceLoading() const
 457 {
 458   return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 459 }
 460
 461 void ImageVisual::LoadResourceSynchronously()
 462 {
 463   if( !mImageUrl.empty() )
 464   {
 465     BitmapLoader loader = BitmapLoader::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
 466     loader.Load();
 467     mPixels = loader.GetPixelData();
 468   }
 469 }
 470
 471 Image ImageVisual::LoadImage( const std::string& url, bool synchronousLoading )
 472 {
 473   if( synchronousLoading )
 474   {
 475     if( !mPixels )
 476     {
 477       // use broken image
 478       return VisualFactoryCache::GetBrokenVisualImage();
 479     }
 480     Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
 481     image.Upload( mPixels, 0, 0 );
 482     return image;
 483   }
 484   else
 485   {
 486     ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
 487     resourceImage.LoadingFinishedSignal().Connect( this, &ImageVisual::OnImageLoaded );
 488     return resourceImage;
 489   }
 490 }
 491
 492 TextureSet ImageVisual::CreateTextureSet( Vector4& textureRect, const std::string& url, bool synchronousLoading )
 493 {
 494   TextureSet textureSet;
 495   textureRect = FULL_TEXTURE_RECT;
 496   if( synchronousLoading )
 497   {
 498     if( !mPixels )
 499     {
 500       // use broken image
 501       textureSet = TextureSet::New();
 502       TextureSetImage( textureSet, 0u, VisualFactoryCache::GetBrokenVisualImage() );
 503     }
 504     else
 505     {
 506       textureSet = mFactoryCache.GetAtlasManager()->Add(textureRect, mPixels );
 507       mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
 508       if( !textureSet ) // big image, no atlasing
 509       {
 510         mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 511         Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
 512         image.Upload( mPixels, 0, 0 );
 513         textureSet = TextureSet::New();
 514         TextureSetImage( textureSet, 0u, image );
 515       }
 516     }
 517   }
 518   else
 519   {
 520     textureSet = mFactoryCache.GetAtlasManager()->Add(textureRect, url, mDesiredSize, mFittingMode, true, this );
 521     mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
 522     if( !textureSet ) // big image, no atlasing
 523     {
 524       mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 525       ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
 526       resourceImage.LoadingFinishedSignal().Connect( this, &ImageVisual::OnImageLoaded );
 527       textureSet = TextureSet::New();
 528       TextureSetImage( textureSet, 0u, resourceImage );
 529     }
 530   }
 531
 532   if( !(mImpl->mFlags & Impl::IS_ATLASING_APPLIED) )
 533   {
 534     Sampler sampler = Sampler::New();
 535     sampler.SetWrapMode(  mWrapModeU, mWrapModeV  );
 536     textureSet.SetSampler( 0u, sampler );
 537   }
 538
 539   return textureSet;
 540 }
 541
 542 void ImageVisual::InitializeRenderer( const std::string& imageUrl )
 543 {
 544   if( imageUrl.empty() )
 545   {
 546     return;
 547   }
 548
 549   mImageUrl = imageUrl;
 550   mImpl->mRenderer.Reset();
 551   mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 552
 553   if( !mImpl->mCustomShader &&
 554       ( strncasecmp( imageUrl.c_str(), HTTP_URL,  sizeof(HTTP_URL)  -1 ) != 0 ) && // ignore remote images
 555       ( strncasecmp( imageUrl.c_str(), HTTPS_URL, sizeof(HTTPS_URL) -1 ) != 0 ) )
 556   {
 557     bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
 558     bool cacheable =  defaultWrapMode &&  mPixelArea == FULL_TEXTURE_RECT;
 559
 560     mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
 561     if( cacheable ) // fetch the renderer from cache if exist
 562     {
 563       mImpl->mRenderer = mFactoryCache.GetRenderer( imageUrl );
 564       mImpl->mFlags |= Impl::IS_FROM_CACHE;
 565     }
 566
 567     if( !mImpl->mRenderer ) // new renderer is needed
 568     {
 569       Vector4 atlasRect;
 570       TextureSet textureSet = CreateTextureSet(atlasRect, imageUrl, IsSynchronousResourceLoading() );
 571       Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 572       Shader shader( GetImageShader(mFactoryCache, mImpl->mFlags & Impl::IS_ATLASING_APPLIED, defaultWrapMode) );
 573       mImpl->mRenderer = Renderer::New( geometry, shader );
 574       mImpl->mRenderer.SetTextures( textureSet );
 575
 576       if( mImpl->mFlags & Impl::IS_ATLASING_APPLIED ) // the texture is packed inside atlas
 577       {
 578         mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
 579         if( !defaultWrapMode ) // custom wrap mode, renderer is not cached.
 580         {
 581           Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE);
 582           wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) );
 583           mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode );
 584         }
 585       }
 586
 587       // save the renderer to cache only when default wrap mode and default pixel area is used
 588       if( cacheable )
 589       {
 590         mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
 591       }
 592     }
 593   }
 594   else
 595   {
 596     // for custom shader or remote image, renderer is not cached and atlas is not applied
 597     mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
 598     mImpl->mRenderer = CreateRenderer();
 599     Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
 600     ApplyImageToSampler( image );
 601   }
 602 }
 603
 604 void ImageVisual::InitializeRenderer( const Image& image )
 605 {
 606   mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
 607
 608   mImpl->mRenderer = CreateRenderer();
 609
 610   if( image )
 611   {
 612     ApplyImageToSampler( image );
 613   }
 614 }
 615
 616 void ImageVisual::UploadCompleted()
 617 {
 618   // Resource image is loaded. If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 619   Actor actor = mPlacementActor.GetHandle();
 620   if( actor )
 621   {
 622     actor.AddRenderer( mImpl->mRenderer );
 623     // reset the weak handle so that the renderer only get added to actor once
 624     mPlacementActor.Reset();
 625   }
 626 }
 627
 628 void ImageVisual::DoSetOnStage( Actor& actor )
 629 {
 630   mPlacementActor = actor;
 631
 632   if( !mImageUrl.empty() )
 633   {
 634     InitializeRenderer( mImageUrl );
 635   }
 636   else
 637   {
 638     InitializeRenderer( mImage );
 639   }
 640
 641   if( mPixelArea != FULL_TEXTURE_RECT )
 642   {
 643     mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
 644   }
 645
 646   if( IsSynchronousResourceLoading() || !(mImpl->mFlags & Impl::IS_ATLASING_APPLIED) )
 647   {
 648     actor.AddRenderer( mImpl->mRenderer );
 649     mPlacementActor.Reset();
 650   }
 651 }
 652
 653 void ImageVisual::DoSetOffStage( Actor& actor )
 654 {
 655   //If we own the image then make sure we release it when we go off stage
 656   if( !mImageUrl.empty() )
 657   {
 658     actor.RemoveRenderer( mImpl->mRenderer );
 659     CleanCache(mImageUrl);
 660     mImage.Reset();
 661   }
 662   else
 663   {
 664     actor.RemoveRenderer( mImpl->mRenderer );
 665     mImpl->mRenderer.Reset();
 666   }
 667   mPlacementActor.Reset();
 668 }
 669
 670 void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 671 {
 672   map.Clear();
 673   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );
 674
 675   bool sync = IsSynchronousResourceLoading();
 676   map.Insert( SYNCHRONOUS_LOADING, sync );
 677   if( !mImageUrl.empty() )
 678   {
 679     map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl );
 680     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );
 681     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight() );
 682   }
 683   else if( mImage )
 684   {
 685     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, static_cast<int>(mImage.GetWidth()) );
 686     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, static_cast<int>(mImage.GetHeight()) );
 687
 688     ResourceImage resourceImage = ResourceImage::DownCast(mImage);
 689     if( resourceImage )
 690     {
 691       map.Insert( Toolkit::ImageVisual::Property::URL, resourceImage.GetUrl() );
 692     }
 693   }
 694
 695   map.Insert( Toolkit::ImageVisual::Property::FITTING_MODE, mFittingMode );
 696   map.Insert( Toolkit::ImageVisual::Property::SAMPLING_MODE, mSamplingMode );
 697
 698   map.Insert( Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea );
 699   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU );
 700   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV );
 701 }
 702
 703 void ImageVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue )
 704 {
 705   // TODO
 706 }
 707
 708 Dali::Property::Value ImageVisual::DoGetProperty( Dali::Property::Index index )
 709 {
 710   // TODO
 711   return Dali::Property::Value();
 712 }
 713
 714 Shader ImageVisual::GetImageShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping )
 715 {
 716   Shader shader;
 717   if( atlasing )
 718   {
 719     if( defaultTextureWrapping )
 720     {
 721       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP );
 722       if( !shader )
 723       {
 724         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
 725         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader );
 726       }
 727     }
 728     else
 729     {
 730       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP );
 731       if( !shader )
 732       {
 733         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP );
 734         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP, shader );
 735       }
 736     }
 737   }
 738   else
 739   {
 740     shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
 741     if( !shader )
 742     {
 743       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
 744       factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
 745     }
 746   }
 747   shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 748   return shader;
 749 }
 750
 751 void ImageVisual::ApplyImageToSampler( const Image& image )
 752 {
 753   if( image )
 754   {
 755     TextureSet textureSet = mImpl->mRenderer.GetTextures();
 756     if( !textureSet )
 757     {
 758       textureSet = TextureSet::New();
 759       mImpl->mRenderer.SetTextures( textureSet );
 760     }
 761     TextureSetImage( textureSet, 0u, image );
 762     Sampler sampler = Sampler::New();
 763     sampler.SetWrapMode(  mWrapModeU, mWrapModeV  );
 764     textureSet.SetSampler( 0u, sampler );
 765   }
 766 }
 767
 768 void ImageVisual::OnImageLoaded( ResourceImage image )
 769 {
 770   if( image.GetLoadingState() == Dali::ResourceLoadingFailed )
 771   {
 772     Image brokenImage = VisualFactoryCache::GetBrokenVisualImage();
 773     if( mImpl->mRenderer )
 774     {
 775       ApplyImageToSampler( brokenImage );
 776     }
 777   }
 778 }
 779
 780 void ImageVisual::CleanCache(const std::string& url)
 781 {
 782   if( IsFromCache() )
 783   {
 784     TextureSet textureSet = mImpl->mRenderer.GetTextures();
 785
 786     Vector4 atlasRect( 0.f, 0.f, 1.f, 1.f );
 787     Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
 788     if( index != Property::INVALID_INDEX )
 789     {
 790       Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index );
 791       atlasRectValue.Get( atlasRect );
 792     }
 793
 794     mImpl->mRenderer.Reset();
 795     if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX )
 796     {
 797       mFactoryCache.GetAtlasManager()->Remove( textureSet, atlasRect );
 798     }
 799   }
 800 }
 801
 802 void ImageVisual::SetNativeFragmentShaderCode( Dali::NativeImage& nativeImage )
 803 {
 804   const char* fragmentPreFix = nativeImage.GetCustomFragmentPreFix();
 805   const char* customSamplerTypename = nativeImage.GetCustomSamplerTypename();
 806
 807   if( fragmentPreFix )
 808   {
 809     mNativeFragmentShaderCode = fragmentPreFix;
 810     mNativeFragmentShaderCode += "\n";
 811   }
 812
 813   if( mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty() )
 814   {
 815     mNativeFragmentShaderCode += mImpl->mCustomShader->mFragmentShader;
 816   }
 817   else
 818   {
 819     mNativeFragmentShaderCode += FRAGMENT_SHADER_NO_ATLAS;
 820   }
 821
 822   if( customSamplerTypename )
 823   {
 824     mNativeFragmentShaderCode.replace( mNativeFragmentShaderCode.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
 825   }
 826 }
 827
 828 } // namespace Internal
 829
 830 } // namespace Toolkit
 831
 832 } // namespace Dali