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 const char * const BATCHING_ENABLED( "batchingEnabled" );
  62
  63 // fitting modes
  64 DALI_ENUM_TO_STRING_TABLE_BEGIN( FITTING_MODE )
  65 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SHRINK_TO_FIT )
  66 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SCALE_TO_FILL )
  67 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, FIT_WIDTH )
  68 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, FIT_HEIGHT )
  69 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, DEFAULT )
  70 DALI_ENUM_TO_STRING_TABLE_END( FITTING_MODE )
  71
  72 // sampling modes
  73 DALI_ENUM_TO_STRING_TABLE_BEGIN( SAMPLING_MODE )
  74 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX )
  75 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, NEAREST )
  76 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, LINEAR )
  77 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX_THEN_NEAREST )
  78 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX_THEN_LINEAR )
  79 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, NO_FILTER )
  80 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, DONT_CARE )
  81 DALI_ENUM_TO_STRING_TABLE_END( SAMPLING_MODE )
  82
  83 const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea";
  84
  85 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  86
  87 const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
  88
  89 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
  90   attribute mediump vec2 aPosition;\n
  91   uniform mediump mat4 uMvpMatrix;\n
  92   uniform mediump vec3 uSize;\n
  93   uniform mediump vec4 uAtlasRect;\n
  94   uniform mediump vec4 pixelArea;
  95   varying mediump vec2 vTexCoord;\n
  96   \n
  97   void main()\n
  98   {\n
  99     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
 100     vertexPosition.xyz *= uSize;\n
 101     vertexPosition = uMvpMatrix * vertexPosition;\n
 102     \n
 103     vTexCoord = mix( uAtlasRect.xy, uAtlasRect.zw, pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) ) );\n
 104     gl_Position = vertexPosition;\n
 105   }\n
 106 );
 107
 108 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
 109   varying mediump vec2 vTexCoord;\n
 110   uniform sampler2D sTexture;\n
 111   uniform lowp vec4 uColor;\n
 112   \n
 113   void main()\n
 114   {\n
 115     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
 116   }\n
 117 );
 118
 119 Geometry CreateGeometry( VisualFactoryCache& factoryCache, ImageDimensions gridSize )
 120 {
 121   Geometry geometry;
 122
 123   if( gridSize == ImageDimensions( 1, 1 ) )
 124   {
 125     geometry = factoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 126     if( !geometry )
 127     {
 128       geometry =  VisualFactoryCache::CreateQuadGeometry();
 129       factoryCache.SaveGeometry( VisualFactoryCache::QUAD_GEOMETRY, geometry );
 130     }
 131   }
 132   else
 133   {
 134     geometry = VisualFactoryCache::CreateGridGeometry( gridSize );
 135   }
 136
 137   return geometry;
 138 }
 139
 140 } //unnamed namespace
 141
 142 ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
 143 : Visual::Base( factoryCache ),
 144   mAtlasManager( atlasManager ),
 145   mDesiredSize(),
 146   mFittingMode( FittingMode::DEFAULT ),
 147   mSamplingMode( SamplingMode::DEFAULT ),
 148   mNativeFragmentShaderCode( ),
 149   mNativeImageFlag( false )
 150 {
 151 }
 152
 153 ImageVisual::~ImageVisual()
 154 {
 155 }
 156
 157 void ImageVisual::DoInitialize( Actor& actor, const Property::Map& propertyMap )
 158 {
 159   std::string oldImageUrl = mImageUrl;
 160
 161   Property::Value* imageURLValue = propertyMap.Find( Toolkit::ImageVisual::Property::URL, IMAGE_URL_NAME );
 162   if( imageURLValue )
 163   {
 164     imageURLValue->Get( mImageUrl );
 165     if( !mImageUrl.empty() )
 166     {
 167       mImage.Reset();
 168     }
 169
 170     Property::Value* fittingValue = propertyMap.Find( Toolkit::ImageVisual::Property::FITTING_MODE, IMAGE_FITTING_MODE );
 171     if( fittingValue )
 172     {
 173       Scripting::GetEnumerationProperty( *fittingValue, FITTING_MODE_TABLE, FITTING_MODE_TABLE_COUNT, mFittingMode );
 174     }
 175
 176     Property::Value* samplingValue = propertyMap.Find( Toolkit::ImageVisual::Property::SAMPLING_MODE, IMAGE_SAMPLING_MODE );
 177     if( samplingValue )
 178     {
 179       Scripting::GetEnumerationProperty( *samplingValue, SAMPLING_MODE_TABLE, SAMPLING_MODE_TABLE_COUNT, mSamplingMode );
 180     }
 181
 182     int desiredWidth = 0;
 183     Property::Value* desiredWidthValue = propertyMap.Find( Toolkit::ImageVisual::Property::DESIRED_WIDTH, IMAGE_DESIRED_WIDTH );
 184     if( desiredWidthValue )
 185     {
 186       desiredWidthValue->Get( desiredWidth );
 187     }
 188
 189     int desiredHeight = 0;
 190     Property::Value* desiredHeightValue = propertyMap.Find( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, IMAGE_DESIRED_HEIGHT );
 191     if( desiredHeightValue )
 192     {
 193       desiredHeightValue->Get( desiredHeight );
 194     }
 195
 196     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
 197   }
 198
 199   Property::Value* syncLoading = propertyMap.Find( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, SYNCHRONOUS_LOADING );
 200   if( syncLoading )
 201   {
 202     bool sync;
 203     syncLoading->Get( sync );
 204     if( sync )
 205     {
 206       mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 207     }
 208     else
 209     {
 210       mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 211     }
 212   }
 213
 214   // if sync loading is required, the loading should start immediately when new image url is set or the actor is off stage
 215   // ( for on-stage actor with image url unchanged, resource loading is already finished)
 216   if( ( !mImpl->mRenderer || imageURLValue) && IsSynchronousResourceLoading() )
 217   {
 218     DoSynchronousResourceLoading();
 219   }
 220
 221   // remove old renderer if exit
 222   if( mImpl->mRenderer )
 223   {
 224     if( actor ) //remove old renderer from actor
 225     {
 226       actor.RemoveRenderer( mImpl->mRenderer );
 227     }
 228     if( !oldImageUrl.empty() ) //clean old renderer from cache
 229     {
 230       CleanCache( oldImageUrl );
 231     }
 232   }
 233
 234   NativeImage nativeImage = NativeImage::DownCast( mImage );
 235
 236   if( nativeImage )
 237   {
 238     SetNativeFragmentShaderCode( nativeImage );
 239   }
 240
 241   // if actor is on stage, create new renderer and apply to actor
 242   if( actor && actor.OnStage() )
 243   {
 244     SetOnStage( actor );
 245   }
 246 }
 247
 248 void ImageVisual::SetSize( const Vector2& size )
 249 {
 250   Visual::Base::SetSize( size );
 251 }
 252
 253 void ImageVisual::GetNaturalSize( Vector2& naturalSize ) const
 254 {
 255   if(mImage)
 256   {
 257     naturalSize.x = mImage.GetWidth();
 258     naturalSize.y = mImage.GetHeight();
 259     return;
 260   }
 261   else if( mDesiredSize.GetWidth()>0 && mDesiredSize.GetHeight()>0)
 262   {
 263     naturalSize.x = mDesiredSize.GetWidth();
 264     naturalSize.y = mDesiredSize.GetHeight();
 265     return;
 266   }
 267   else if( !mImageUrl.empty() )
 268   {
 269     ImageDimensions dimentions = ResourceImage::GetImageSize( mImageUrl );
 270     naturalSize.x = dimentions.GetWidth();
 271     naturalSize.y = dimentions.GetHeight();
 272     return;
 273   }
 274
 275   naturalSize = Vector2::ZERO;
 276 }
 277
 278 void ImageVisual::SetClipRect( const Rect<int>& clipRect )
 279 {
 280   Visual::Base::SetClipRect( clipRect );
 281 }
 282
 283 void ImageVisual::SetOffset( const Vector2& offset )
 284 {
 285 }
 286
 287 Renderer ImageVisual::CreateRenderer() const
 288 {
 289   Geometry geometry;
 290   Shader shader;
 291
 292   // If mImage is nativeImage with custom sampler or prefix, mNativeFragmentShaderCode will be applied.
 293   // Renderer can't be shared between NativeImage and other image types.
 294   if( !mNativeFragmentShaderCode.empty() )
 295   {
 296     return CreateNativeImageRenderer();
 297   }
 298
 299   if( !mImpl->mCustomShader )
 300   {
 301     geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 302
 303     shader = GetImageShader(mFactoryCache);
 304   }
 305   else
 306   {
 307     geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
 308     if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
 309     {
 310       shader = GetImageShader(mFactoryCache);
 311     }
 312     else
 313     {
 314       shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
 315                              mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER : mImpl->mCustomShader->mFragmentShader,
 316                              mImpl->mCustomShader->mHints );
 317       if( mImpl->mCustomShader->mVertexShader.empty() )
 318       {
 319         shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
 320         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 321       }
 322     }
 323   }
 324
 325   Renderer renderer = Renderer::New( geometry, shader );
 326
 327   return renderer;
 328 }
 329
 330 Renderer ImageVisual::CreateNativeImageRenderer() const
 331 {
 332   Geometry geometry;
 333   Shader shader;
 334
 335   if( !mImpl->mCustomShader )
 336   {
 337     geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 338
 339     shader  = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
 340     shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
 341     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 342   }
 343   else
 344   {
 345     geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
 346     shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
 347                            mNativeFragmentShaderCode,
 348                            mImpl->mCustomShader->mHints );
 349     if( mImpl->mCustomShader->mVertexShader.empty() )
 350     {
 351       shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
 352       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 353     }
 354   }
 355
 356   TextureSet textureSet = TextureSet::New();
 357   Renderer renderer = Renderer::New( geometry, shader );
 358   renderer.SetTextures( textureSet );
 359
 360   return renderer;
 361 }
 362
 363
 364 bool ImageVisual::IsSynchronousResourceLoading() const
 365 {
 366   return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 367 }
 368
 369 void ImageVisual::DoSynchronousResourceLoading()
 370 {
 371   if( !mImageUrl.empty() )
 372   {
 373     BitmapLoader loader = BitmapLoader::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
 374     loader.Load();
 375     mPixels = loader.GetPixelData();
 376   }
 377 }
 378
 379 Image ImageVisual::LoadImage( const std::string& url, bool synchronousLoading )
 380 {
 381   if( synchronousLoading )
 382   {
 383     if( !mPixels )
 384     {
 385       // use broken image
 386       return VisualFactory::GetBrokenVisualImage();
 387     }
 388     Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
 389     image.Upload( mPixels, 0, 0 );
 390     return image;
 391   }
 392   else
 393   {
 394     ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
 395     resourceImage.LoadingFinishedSignal().Connect( this, &ImageVisual::OnImageLoaded );
 396     return resourceImage;
 397   }
 398 }
 399
 400 TextureSet ImageVisual::CreateTextureSet( Vector4& textureRect, const std::string& url, bool synchronousLoading )
 401 {
 402   TextureSet textureSet;
 403   textureRect = FULL_TEXTURE_RECT;
 404   if( synchronousLoading )
 405   {
 406     if( !mPixels )
 407     {
 408       // use broken image
 409       textureSet = TextureSet::New();
 410       TextureSetImage( textureSet, 0u, VisualFactory::GetBrokenVisualImage() );
 411     }
 412     else
 413     {
 414       textureSet = mAtlasManager.Add(textureRect, mPixels );
 415       if( !textureSet ) // big image, no atlasing
 416       {
 417         Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
 418         image.Upload( mPixels, 0, 0 );
 419         textureSet = TextureSet::New();
 420         TextureSetImage( textureSet, 0u, image );
 421       }
 422     }
 423   }
 424   else
 425   {
 426     textureSet = mAtlasManager.Add(textureRect, url, mDesiredSize, mFittingMode, mSamplingMode );
 427     if( !textureSet ) // big image, no atlasing
 428     {
 429       ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
 430       resourceImage.LoadingFinishedSignal().Connect( this, &ImageVisual::OnImageLoaded );
 431       textureSet = TextureSet::New();
 432       TextureSetImage( textureSet, 0u, resourceImage );
 433     }
 434   }
 435
 436   return textureSet;
 437 }
 438
 439 void ImageVisual::InitializeRenderer( const std::string& imageUrl )
 440 {
 441   if( imageUrl.empty() )
 442   {
 443     return;
 444   }
 445
 446   mImageUrl = imageUrl;
 447   mImpl->mRenderer.Reset();
 448
 449   if( !mImpl->mCustomShader &&
 450       ( strncasecmp( imageUrl.c_str(), HTTP_URL,  sizeof(HTTP_URL)  -1 ) != 0 ) && // ignore remote images
 451       ( strncasecmp( imageUrl.c_str(), HTTPS_URL, sizeof(HTTPS_URL) -1 ) != 0 ) )
 452   {
 453     mImpl->mRenderer = mFactoryCache.GetRenderer( imageUrl );
 454     if( !mImpl->mRenderer )
 455     {
 456       Vector4 atlasRect;
 457       TextureSet textureSet = CreateTextureSet(atlasRect, imageUrl, IsSynchronousResourceLoading() );
 458       Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 459       Shader shader( GetImageShader(mFactoryCache) );
 460       mImpl->mRenderer = Renderer::New( geometry, shader );
 461       mImpl->mRenderer.SetTextures( textureSet );
 462       if( atlasRect != FULL_TEXTURE_RECT )
 463       {
 464         mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
 465       }
 466       mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
 467     }
 468
 469     mImpl->mFlags |= Impl::IS_FROM_CACHE;
 470   }
 471   else
 472   {
 473     // for custom shader or remote image, renderer is not cached and atlas is not applied
 474
 475     mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
 476     mImpl->mRenderer = CreateRenderer();
 477     Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
 478     ApplyImageToSampler( image );
 479   }
 480 }
 481
 482 void ImageVisual::InitializeRenderer( const Image& image )
 483 {
 484   mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
 485
 486   mImpl->mRenderer = CreateRenderer();
 487
 488   if( image )
 489   {
 490     ApplyImageToSampler( image );
 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 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