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 SYNCHRONOUS_LOADING( "synchronousLoading" );
  61
  62 // fitting modes
  63 DALI_ENUM_TO_STRING_TABLE_BEGIN( FITTING_MODE )
  64 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SHRINK_TO_FIT )
  65 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SCALE_TO_FILL )
  66 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, FIT_WIDTH )
  67 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, FIT_HEIGHT )
  68 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, DEFAULT )
  69 DALI_ENUM_TO_STRING_TABLE_END( FITTING_MODE )
  70
  71 // sampling modes
  72 DALI_ENUM_TO_STRING_TABLE_BEGIN( SAMPLING_MODE )
  73 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX )
  74 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, NEAREST )
  75 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, LINEAR )
  76 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX_THEN_NEAREST )
  77 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX_THEN_LINEAR )
  78 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, NO_FILTER )
  79 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, DONT_CARE )
  80 DALI_ENUM_TO_STRING_TABLE_END( SAMPLING_MODE )
  81
  82 const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea";
  83
  84 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  85
  86 const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
  87
  88 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
  89   attribute mediump vec2 aPosition;\n
  90   uniform mediump mat4 uMvpMatrix;\n
  91   uniform mediump vec3 uSize;\n
  92   uniform mediump vec4 uAtlasRect;\n
  93   uniform mediump vec4 pixelArea;
  94   varying mediump vec2 vTexCoord;\n
  95   \n
  96   void main()\n
  97   {\n
  98     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
  99     vertexPosition.xyz *= uSize;\n
 100     vertexPosition = uMvpMatrix * vertexPosition;\n
 101     \n
 102     vTexCoord = mix( uAtlasRect.xy, uAtlasRect.zw, pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) ) );\n
 103     gl_Position = vertexPosition;\n
 104   }\n
 105 );
 106
 107 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
 108   varying mediump vec2 vTexCoord;\n
 109   uniform sampler2D sTexture;\n
 110   uniform lowp vec4 uColor;\n
 111   \n
 112   void main()\n
 113   {\n
 114     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
 115   }\n
 116 );
 117
 118 Geometry CreateGeometry( VisualFactoryCache& factoryCache, ImageDimensions gridSize )
 119 {
 120   Geometry geometry;
 121
 122   if( gridSize == ImageDimensions( 1, 1 ) )
 123   {
 124     geometry = factoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 125     if( !geometry )
 126     {
 127       geometry =  VisualFactoryCache::CreateQuadGeometry();
 128       factoryCache.SaveGeometry( VisualFactoryCache::QUAD_GEOMETRY, geometry );
 129     }
 130   }
 131   else
 132   {
 133     geometry = VisualFactoryCache::CreateGridGeometry( gridSize );
 134   }
 135
 136   return geometry;
 137 }
 138
 139 } //unnamed namespace
 140
 141 ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
 142 : Visual::Base( factoryCache ),
 143   mAtlasManager( atlasManager ),
 144   mDesiredSize(),
 145   mFittingMode( FittingMode::DEFAULT ),
 146   mSamplingMode( SamplingMode::DEFAULT ),
 147   mNativeFragmentShaderCode( ),
 148   mNativeImageFlag( false )
 149 {
 150 }
 151
 152 ImageVisual::~ImageVisual()
 153 {
 154 }
 155
 156 void ImageVisual::DoInitialize( Actor& actor, const Property::Map& propertyMap )
 157 {
 158   std::string oldImageUrl = mImageUrl;
 159
 160   Property::Value* imageURLValue = propertyMap.Find( Toolkit::ImageVisual::Property::URL, IMAGE_URL_NAME );
 161   if( imageURLValue )
 162   {
 163     imageURLValue->Get( mImageUrl );
 164     if( !mImageUrl.empty() )
 165     {
 166       mImage.Reset();
 167     }
 168
 169     Property::Value* fittingValue = propertyMap.Find( Toolkit::ImageVisual::Property::FITTING_MODE, IMAGE_FITTING_MODE );
 170     if( fittingValue )
 171     {
 172       Scripting::GetEnumerationProperty( *fittingValue, FITTING_MODE_TABLE, FITTING_MODE_TABLE_COUNT, mFittingMode );
 173     }
 174
 175     Property::Value* samplingValue = propertyMap.Find( Toolkit::ImageVisual::Property::SAMPLING_MODE, IMAGE_SAMPLING_MODE );
 176     if( samplingValue )
 177     {
 178       Scripting::GetEnumerationProperty( *samplingValue, SAMPLING_MODE_TABLE, SAMPLING_MODE_TABLE_COUNT, mSamplingMode );
 179     }
 180
 181     int desiredWidth = 0;
 182     Property::Value* desiredWidthValue = propertyMap.Find( Toolkit::ImageVisual::Property::DESIRED_WIDTH, IMAGE_DESIRED_WIDTH );
 183     if( desiredWidthValue )
 184     {
 185       desiredWidthValue->Get( desiredWidth );
 186     }
 187
 188     int desiredHeight = 0;
 189     Property::Value* desiredHeightValue = propertyMap.Find( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, IMAGE_DESIRED_HEIGHT );
 190     if( desiredHeightValue )
 191     {
 192       desiredHeightValue->Get( desiredHeight );
 193     }
 194
 195     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
 196   }
 197
 198   Property::Value* syncLoading = propertyMap.Find( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, SYNCHRONOUS_LOADING );
 199   if( syncLoading )
 200   {
 201     bool sync;
 202     syncLoading->Get( sync );
 203     if( sync )
 204     {
 205       mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 206     }
 207     else
 208     {
 209       mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 210     }
 211   }
 212
 213   // if sync loading is required, the loading should start immediately when new image url is set or the actor is off stage
 214   // ( for on-stage actor with image url unchanged, resource loading is already finished)
 215   if( ( !mImpl->mRenderer || imageURLValue) && IsSynchronousResourceLoading() )
 216   {
 217     DoSynchronousResourceLoading();
 218   }
 219
 220   // remove old renderer if exit
 221   if( mImpl->mRenderer )
 222   {
 223     if( actor ) //remove old renderer from actor
 224     {
 225       actor.RemoveRenderer( mImpl->mRenderer );
 226     }
 227     if( !oldImageUrl.empty() ) //clean old renderer from cache
 228     {
 229       CleanCache( oldImageUrl );
 230     }
 231   }
 232
 233   NativeImage nativeImage = NativeImage::DownCast( mImage );
 234
 235   if( nativeImage )
 236   {
 237     SetNativeFragmentShaderCode( nativeImage );
 238   }
 239
 240   // if actor is on stage, create new renderer and apply to actor
 241   if( actor && actor.OnStage() )
 242   {
 243     SetOnStage( actor );
 244   }
 245 }
 246
 247 void ImageVisual::SetSize( const Vector2& size )
 248 {
 249   Visual::Base::SetSize( size );
 250 }
 251
 252 void ImageVisual::GetNaturalSize( Vector2& naturalSize ) const
 253 {
 254   if(mImage)
 255   {
 256     naturalSize.x = mImage.GetWidth();
 257     naturalSize.y = mImage.GetHeight();
 258     return;
 259   }
 260   else if( mDesiredSize.GetWidth()>0 && mDesiredSize.GetHeight()>0)
 261   {
 262     naturalSize.x = mDesiredSize.GetWidth();
 263     naturalSize.y = mDesiredSize.GetHeight();
 264     return;
 265   }
 266   else if( !mImageUrl.empty() )
 267   {
 268     ImageDimensions dimentions = ResourceImage::GetImageSize( mImageUrl );
 269     naturalSize.x = dimentions.GetWidth();
 270     naturalSize.y = dimentions.GetHeight();
 271     return;
 272   }
 273
 274   naturalSize = Vector2::ZERO;
 275 }
 276
 277 void ImageVisual::SetClipRect( const Rect<int>& clipRect )
 278 {
 279   Visual::Base::SetClipRect( clipRect );
 280 }
 281
 282 void ImageVisual::SetOffset( const Vector2& offset )
 283 {
 284 }
 285
 286 Renderer ImageVisual::CreateRenderer() const
 287 {
 288   Geometry geometry;
 289   Shader shader;
 290
 291   // If mImage is nativeImage with custom sampler or prefix, mNativeFragmentShaderCode will be applied.
 292   // Renderer can't be shared between NativeImage and other image types.
 293   if( !mNativeFragmentShaderCode.empty() )
 294   {
 295     return CreateNativeImageRenderer();
 296   }
 297
 298   if( !mImpl->mCustomShader )
 299   {
 300     geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 301
 302     shader = GetImageShader(mFactoryCache);
 303   }
 304   else
 305   {
 306     geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
 307     if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
 308     {
 309       shader = GetImageShader(mFactoryCache);
 310     }
 311     else
 312     {
 313       shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
 314                              mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER : mImpl->mCustomShader->mFragmentShader,
 315                              mImpl->mCustomShader->mHints );
 316       if( mImpl->mCustomShader->mVertexShader.empty() )
 317       {
 318         shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
 319         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 320       }
 321     }
 322   }
 323
 324   Renderer renderer = Renderer::New( geometry, shader );
 325
 326   return renderer;
 327 }
 328
 329 Renderer ImageVisual::CreateNativeImageRenderer() const
 330 {
 331   Geometry geometry;
 332   Shader shader;
 333
 334   if( !mImpl->mCustomShader )
 335   {
 336     geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 337
 338     shader  = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
 339     shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
 340     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 341   }
 342   else
 343   {
 344     geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
 345     shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
 346                            mNativeFragmentShaderCode,
 347                            mImpl->mCustomShader->mHints );
 348     if( mImpl->mCustomShader->mVertexShader.empty() )
 349     {
 350       shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
 351       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 352     }
 353   }
 354
 355   TextureSet textureSet = TextureSet::New();
 356   Renderer renderer = Renderer::New( geometry, shader );
 357   renderer.SetTextures( textureSet );
 358
 359   return renderer;
 360 }
 361
 362
 363 bool ImageVisual::IsSynchronousResourceLoading() const
 364 {
 365   return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 366 }
 367
 368 void ImageVisual::DoSynchronousResourceLoading()
 369 {
 370   if( !mImageUrl.empty() )
 371   {
 372     BitmapLoader loader = BitmapLoader::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
 373     loader.Load();
 374     mPixels = loader.GetPixelData();
 375   }
 376 }
 377
 378 Image ImageVisual::LoadImage( const std::string& url, bool synchronousLoading )
 379 {
 380   if( synchronousLoading )
 381   {
 382     if( !mPixels )
 383     {
 384       // use broken image
 385       return VisualFactory::GetBrokenVisualImage();
 386     }
 387     Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
 388     image.Upload( mPixels, 0, 0 );
 389     return image;
 390   }
 391   else
 392   {
 393     ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
 394     resourceImage.LoadingFinishedSignal().Connect( this, &ImageVisual::OnImageLoaded );
 395     return resourceImage;
 396   }
 397 }
 398
 399 TextureSet ImageVisual::CreateTextureSet( Vector4& textureRect, const std::string& url, bool synchronousLoading )
 400 {
 401   TextureSet textureSet;
 402   textureRect = FULL_TEXTURE_RECT;
 403   if( synchronousLoading )
 404   {
 405     if( !mPixels )
 406     {
 407       // use broken image
 408       textureSet = TextureSet::New();
 409       TextureSetImage( textureSet, 0u, VisualFactory::GetBrokenVisualImage() );
 410     }
 411     else
 412     {
 413       textureSet = mAtlasManager.Add(textureRect, mPixels );
 414       if( !textureSet ) // big image, no atlasing
 415       {
 416         Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
 417         image.Upload( mPixels, 0, 0 );
 418         textureSet = TextureSet::New();
 419         TextureSetImage( textureSet, 0u, image );
 420       }
 421     }
 422   }
 423   else
 424   {
 425     textureSet = mAtlasManager.Add(textureRect, url, mDesiredSize, mFittingMode, mSamplingMode );
 426     if( !textureSet ) // big image, no atlasing
 427     {
 428       ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
 429       resourceImage.LoadingFinishedSignal().Connect( this, &ImageVisual::OnImageLoaded );
 430       textureSet = TextureSet::New();
 431       TextureSetImage( textureSet, 0u, resourceImage );
 432     }
 433   }
 434
 435   return textureSet;
 436 }
 437
 438 void ImageVisual::InitializeRenderer( const std::string& imageUrl )
 439 {
 440   if( imageUrl.empty() )
 441   {
 442     return;
 443   }
 444
 445   mImageUrl = imageUrl;
 446   mImpl->mRenderer.Reset();
 447
 448   if( !mImpl->mCustomShader &&
 449       ( strncasecmp( imageUrl.c_str(), HTTP_URL,  sizeof(HTTP_URL)  -1 ) != 0 ) && // ignore remote images
 450       ( strncasecmp( imageUrl.c_str(), HTTPS_URL, sizeof(HTTPS_URL) -1 ) != 0 ) )
 451   {
 452     mImpl->mRenderer = mFactoryCache.GetRenderer( imageUrl );
 453     if( !mImpl->mRenderer )
 454     {
 455       Vector4 atlasRect;
 456       TextureSet textureSet = CreateTextureSet(atlasRect, imageUrl, IsSynchronousResourceLoading() );
 457       Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 458       Shader shader( GetImageShader(mFactoryCache) );
 459       mImpl->mRenderer = Renderer::New( geometry, shader );
 460       mImpl->mRenderer.SetTextures( textureSet );
 461       if( atlasRect != FULL_TEXTURE_RECT )
 462       {
 463         mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
 464       }
 465       mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
 466     }
 467
 468     mImpl->mFlags |= Impl::IS_FROM_CACHE;
 469   }
 470   else
 471   {
 472     // for custom shader or remote image, renderer is not cached and atlas is not applied
 473
 474     mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
 475     mImpl->mRenderer = CreateRenderer();
 476     Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
 477     ApplyImageToSampler( image );
 478   }
 479 }
 480
 481 void ImageVisual::InitializeRenderer( const Image& image )
 482 {
 483   mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
 484
 485   mImpl->mRenderer = CreateRenderer();
 486
 487   if( image )
 488   {
 489     ApplyImageToSampler( image );
 490   }
 491 }
 492
 493
 494 void ImageVisual::DoSetOnStage( Actor& actor )
 495 {
 496   if( !mImageUrl.empty() )
 497   {
 498     InitializeRenderer( mImageUrl );
 499   }
 500   else
 501   {
 502     InitializeRenderer( mImage );
 503   }
 504
 505 }
 506
 507 void ImageVisual::DoSetOffStage( Actor& actor )
 508 {
 509   //If we own the image then make sure we release it when we go off stage
 510   if( !mImageUrl.empty() )
 511   {
 512     actor.RemoveRenderer( mImpl->mRenderer );
 513     CleanCache(mImageUrl);
 514     mImage.Reset();
 515   }
 516   else
 517   {
 518     actor.RemoveRenderer( mImpl->mRenderer );
 519     mImpl->mRenderer.Reset();
 520   }
 521 }
 522
 523 void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 524 {
 525   map.Clear();
 526   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );
 527
 528   bool sync = IsSynchronousResourceLoading();
 529   map.Insert( SYNCHRONOUS_LOADING, sync );
 530   if( !mImageUrl.empty() )
 531   {
 532     map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl );
 533     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );
 534     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight() );
 535   }
 536   else if( mImage )
 537   {
 538     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, static_cast<int>(mImage.GetWidth()) );
 539     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, static_cast<int>(mImage.GetHeight()) );
 540
 541     ResourceImage resourceImage = ResourceImage::DownCast(mImage);
 542     if( resourceImage )
 543     {
 544       map.Insert( Toolkit::ImageVisual::Property::URL, resourceImage.GetUrl() );
 545     }
 546   }
 547
 548   map.Insert( Toolkit::ImageVisual::Property::FITTING_MODE, mFittingMode );
 549   map.Insert( Toolkit::ImageVisual::Property::SAMPLING_MODE, mSamplingMode );
 550 }
 551
 552 Shader ImageVisual::GetImageShader( VisualFactoryCache& factoryCache )
 553 {
 554   Shader shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
 555   if( !shader )
 556   {
 557     shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
 558     factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
 559     shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
 560     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 561   }
 562   return shader;
 563 }
 564
 565 void ImageVisual::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
 566 {
 567   if( mImageUrl != imageUrl )
 568   {
 569     std::string oldImageUrl = mImageUrl;
 570     mImageUrl = imageUrl;
 571     mDesiredSize = size;
 572     mFittingMode = fittingMode;
 573     mSamplingMode = samplingMode;
 574     mImage.Reset();
 575
 576     if( IsSynchronousResourceLoading() )
 577     {
 578       DoSynchronousResourceLoading();
 579     }
 580
 581     if( mImpl->mRenderer )
 582     {
 583       if( GetIsFromCache() ) // if renderer is from cache, remove the old one
 584       {
 585         //remove old renderer
 586         if( actor )
 587         {
 588           actor.RemoveRenderer( mImpl->mRenderer );
 589         }
 590
 591         //clean the cache
 592         if( !oldImageUrl.empty() )
 593         {
 594           CleanCache(oldImageUrl);
 595         }
 596
 597         if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
 598         {
 599           SetOnStage(actor);
 600         }
 601       }
 602       else // if renderer is not from cache, reuse the same renderer and only change the texture
 603       {
 604         Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
 605         ApplyImageToSampler( image );
 606       }
 607     }
 608   }
 609 }
 610
 611 void ImageVisual::SetImage( Actor& actor, const Image& image )
 612 {
 613   if( mImage != image )
 614   {
 615     NativeImage newNativeImage = NativeImage::DownCast( image );
 616     bool newRendererFlag = true;
 617
 618     if( newNativeImage && !mNativeImageFlag )
 619     {
 620       SetNativeFragmentShaderCode( newNativeImage );
 621     }
 622
 623     if( ( newNativeImage && mNativeImageFlag ) || ( !newNativeImage && !mNativeImageFlag ) )
 624     {
 625       newRendererFlag = false;
 626     }
 627
 628     if( newNativeImage )
 629     {
 630       mNativeImageFlag = true;
 631     }
 632     else
 633     {
 634       mNativeFragmentShaderCode.clear();
 635       mNativeImageFlag = false;
 636     }
 637
 638     mImage = image;
 639
 640     if( mImpl->mRenderer )
 641     {
 642       // if renderer is from cache, remove the old one, and create new renderer
 643       if( GetIsFromCache() )
 644       {
 645         //remove old renderer
 646         if( actor )
 647         {
 648           actor.RemoveRenderer( mImpl->mRenderer );
 649         }
 650
 651         //clean the cache
 652         if( !mImageUrl.empty() )
 653         {
 654           CleanCache(mImageUrl);
 655         }
 656         mImageUrl.clear();
 657
 658         if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
 659         {
 660           SetOnStage(actor);
 661         }
 662       }
 663       // if input image is nativeImage and mImage is regular image or the reverse, remove the old one, and create new renderer
 664       else if( newRendererFlag )
 665       {
 666         //remove old renderer
 667         if( actor )
 668         {
 669           actor.RemoveRenderer( mImpl->mRenderer );
 670         }
 671
 672         if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
 673         {
 674           SetOnStage(actor);
 675         }
 676       }
 677       else // if renderer is not from cache, reuse the same renderer and only change the texture
 678       {
 679         ApplyImageToSampler( image );
 680       }
 681     }
 682
 683     mImageUrl.clear();
 684     mDesiredSize = ImageDimensions();
 685     mFittingMode = FittingMode::DEFAULT;
 686     mSamplingMode = SamplingMode::DEFAULT;
 687   }
 688 }
 689
 690 void ImageVisual::ApplyImageToSampler( const Image& image )
 691 {
 692   if( image )
 693   {
 694     TextureSet textureSet = mImpl->mRenderer.GetTextures();
 695     if( !textureSet )
 696     {
 697       textureSet = TextureSet::New();
 698       mImpl->mRenderer.SetTextures( textureSet );
 699     }
 700     TextureSetImage( textureSet, 0u, image );
 701   }
 702 }
 703
 704 void ImageVisual::OnImageLoaded( ResourceImage image )
 705 {
 706   if( image.GetLoadingState() == Dali::ResourceLoadingFailed )
 707   {
 708     Image brokenImage = VisualFactory::GetBrokenVisualImage();
 709     if( mImpl->mRenderer )
 710     {
 711       ApplyImageToSampler( brokenImage );
 712     }
 713   }
 714 }
 715
 716 void ImageVisual::CleanCache(const std::string& url)
 717 {
 718   TextureSet textureSet = mImpl->mRenderer.GetTextures();
 719
 720   Vector4 atlasRect( 0.f, 0.f, 1.f, 1.f );
 721   Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
 722   if( index != Property::INVALID_INDEX )
 723   {
 724     Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index );
 725     atlasRectValue.Get( atlasRect );
 726   }
 727
 728   mImpl->mRenderer.Reset();
 729   if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX )
 730   {
 731     mAtlasManager.Remove( textureSet, atlasRect );
 732   }
 733 }
 734
 735 void ImageVisual::SetNativeFragmentShaderCode( Dali::NativeImage& nativeImage )
 736 {
 737   const char* fragmentPreFix = nativeImage.GetCustomFragmentPreFix();
 738   const char* customSamplerTypename = nativeImage.GetCustomSamplerTypename();
 739
 740   if( fragmentPreFix )
 741   {
 742     mNativeFragmentShaderCode = fragmentPreFix;
 743     mNativeFragmentShaderCode += "\n";
 744   }
 745
 746   if( mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty() )
 747   {
 748     mNativeFragmentShaderCode += mImpl->mCustomShader->mFragmentShader;
 749   }
 750   else
 751   {
 752     mNativeFragmentShaderCode += FRAGMENT_SHADER;
 753   }
 754
 755   if( customSamplerTypename )
 756   {
 757     mNativeFragmentShaderCode.replace( mNativeFragmentShaderCode.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
 758   }
 759 }
 760
 761 } // namespace Internal
 762
 763 } // namespace Toolkit
 764
 765 } // namespace Dali