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

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