dali-toolkit/internal/controls/renderers/image/image-renderer.cpp

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