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 void ImageVisual::DoSetOnStage( Actor& actor )
 494 {
 495   if( !mImageUrl.empty() )
 496   {
 497     InitializeRenderer( mImageUrl );
 498   }
 499   else
 500   {
 501     InitializeRenderer( mImage );
 502   }
 503
 504 }
 505
 506 void ImageVisual::DoSetOffStage( Actor& actor )
 507 {
 508   //If we own the image then make sure we release it when we go off stage
 509   if( !mImageUrl.empty() )
 510   {
 511     actor.RemoveRenderer( mImpl->mRenderer );
 512     CleanCache(mImageUrl);
 513     mImage.Reset();
 514   }
 515   else
 516   {
 517     actor.RemoveRenderer( mImpl->mRenderer );
 518     mImpl->mRenderer.Reset();
 519   }
 520 }
 521
 522 void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 523 {
 524   map.Clear();
 525   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );
 526
 527   bool sync = IsSynchronousResourceLoading();
 528   map.Insert( SYNCHRONOUS_LOADING, sync );
 529   if( !mImageUrl.empty() )
 530   {
 531     map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl );
 532     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );
 533     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight() );
 534   }
 535   else if( mImage )
 536   {
 537     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, static_cast<int>(mImage.GetWidth()) );
 538     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, static_cast<int>(mImage.GetHeight()) );
 539
 540     ResourceImage resourceImage = ResourceImage::DownCast(mImage);
 541     if( resourceImage )
 542     {
 543       map.Insert( Toolkit::ImageVisual::Property::URL, resourceImage.GetUrl() );
 544     }
 545   }
 546
 547   map.Insert( Toolkit::ImageVisual::Property::FITTING_MODE, mFittingMode );
 548   map.Insert( Toolkit::ImageVisual::Property::SAMPLING_MODE, mSamplingMode );
 549 }
 550
 551 Shader ImageVisual::GetImageShader( VisualFactoryCache& factoryCache )
 552 {
 553   Shader shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
 554   if( !shader )
 555   {
 556     shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
 557     factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
 558     shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
 559     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 560   }
 561   return shader;
 562 }
 563
 564 void ImageVisual::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
 565 {
 566   if( mImageUrl != imageUrl )
 567   {
 568     std::string oldImageUrl = mImageUrl;
 569     mImageUrl = imageUrl;
 570     mDesiredSize = size;
 571     mFittingMode = fittingMode;
 572     mSamplingMode = samplingMode;
 573     mImage.Reset();
 574
 575     if( IsSynchronousResourceLoading() )
 576     {
 577       DoSynchronousResourceLoading();
 578     }
 579
 580     if( mImpl->mRenderer )
 581     {
 582       if( GetIsFromCache() ) // if renderer is from cache, remove the old one
 583       {
 584         //remove old renderer
 585         if( actor )
 586         {
 587           actor.RemoveRenderer( mImpl->mRenderer );
 588         }
 589
 590         //clean the cache
 591         if( !oldImageUrl.empty() )
 592         {
 593           CleanCache(oldImageUrl);
 594         }
 595
 596         if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
 597         {
 598           SetOnStage(actor);
 599         }
 600       }
 601       else // if renderer is not from cache, reuse the same renderer and only change the texture
 602       {
 603         Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
 604         ApplyImageToSampler( image );
 605       }
 606     }
 607   }
 608 }
 609
 610 void ImageVisual::SetImage( Actor& actor, const Image& image )
 611 {
 612   if( mImage != image )
 613   {
 614     NativeImage newNativeImage = NativeImage::DownCast( image );
 615     bool newRendererFlag = true;
 616
 617     if( newNativeImage && !mNativeImageFlag )
 618     {
 619       SetNativeFragmentShaderCode( newNativeImage );
 620     }
 621
 622     if( ( newNativeImage && mNativeImageFlag ) || ( !newNativeImage && !mNativeImageFlag ) )
 623     {
 624       newRendererFlag = false;
 625     }
 626
 627     if( newNativeImage )
 628     {
 629       mNativeImageFlag = true;
 630     }
 631     else
 632     {
 633       mNativeFragmentShaderCode.clear();
 634       mNativeImageFlag = false;
 635     }
 636
 637     mImage = image;
 638
 639     if( mImpl->mRenderer )
 640     {
 641       // if renderer is from cache, remove the old one, and create new renderer
 642       if( GetIsFromCache() )
 643       {
 644         //remove old renderer
 645         if( actor )
 646         {
 647           actor.RemoveRenderer( mImpl->mRenderer );
 648         }
 649
 650         //clean the cache
 651         if( !mImageUrl.empty() )
 652         {
 653           CleanCache(mImageUrl);
 654         }
 655         mImageUrl.clear();
 656
 657         if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
 658         {
 659           SetOnStage(actor);
 660         }
 661       }
 662       // if input image is nativeImage and mImage is regular image or the reverse, remove the old one, and create new renderer
 663       else if( newRendererFlag )
 664       {
 665         //remove old renderer
 666         if( actor )
 667         {
 668           actor.RemoveRenderer( mImpl->mRenderer );
 669         }
 670
 671         if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
 672         {
 673           SetOnStage(actor);
 674         }
 675       }
 676       else // if renderer is not from cache, reuse the same renderer and only change the texture
 677       {
 678         ApplyImageToSampler( image );
 679       }
 680     }
 681
 682     mImageUrl.clear();
 683     mDesiredSize = ImageDimensions();
 684     mFittingMode = FittingMode::DEFAULT;
 685     mSamplingMode = SamplingMode::DEFAULT;
 686   }
 687 }
 688
 689 void ImageVisual::ApplyImageToSampler( const Image& image )
 690 {
 691   if( image )
 692   {
 693     TextureSet textureSet = mImpl->mRenderer.GetTextures();
 694     if( !textureSet )
 695     {
 696       textureSet = TextureSet::New();
 697       mImpl->mRenderer.SetTextures( textureSet );
 698     }
 699     TextureSetImage( textureSet, 0u, image );
 700   }
 701 }
 702
 703 void ImageVisual::OnImageLoaded( ResourceImage image )
 704 {
 705   if( image.GetLoadingState() == Dali::ResourceLoadingFailed )
 706   {
 707     Image brokenImage = VisualFactory::GetBrokenVisualImage();
 708     if( mImpl->mRenderer )
 709     {
 710       ApplyImageToSampler( brokenImage );
 711     }
 712   }
 713 }
 714
 715 void ImageVisual::CleanCache(const std::string& url)
 716 {
 717   TextureSet textureSet = mImpl->mRenderer.GetTextures();
 718
 719   Vector4 atlasRect( 0.f, 0.f, 1.f, 1.f );
 720   Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
 721   if( index != Property::INVALID_INDEX )
 722   {
 723     Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index );
 724     atlasRectValue.Get( atlasRect );
 725   }
 726
 727   mImpl->mRenderer.Reset();
 728   if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX )
 729   {
 730     mAtlasManager.Remove( textureSet, atlasRect );
 731   }
 732 }
 733
 734 void ImageVisual::SetNativeFragmentShaderCode( Dali::NativeImage& nativeImage )
 735 {
 736   const char* fragmentPreFix = nativeImage.GetCustomFragmentPreFix();
 737   const char* customSamplerTypename = nativeImage.GetCustomSamplerTypename();
 738
 739   if( fragmentPreFix )
 740   {
 741     mNativeFragmentShaderCode = fragmentPreFix;
 742     mNativeFragmentShaderCode += "\n";
 743   }
 744
 745   if( mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty() )
 746   {
 747     mNativeFragmentShaderCode += mImpl->mCustomShader->mFragmentShader;
 748   }
 749   else
 750   {
 751     mNativeFragmentShaderCode += FRAGMENT_SHADER;
 752   }
 753
 754   if( customSamplerTypename )
 755   {
 756     mNativeFragmentShaderCode.replace( mNativeFragmentShaderCode.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
 757   }
 758 }
 759
 760 } // namespace Internal
 761
 762 } // namespace Toolkit
 763
 764 } // namespace Dali