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 <dali-toolkit/internal/visuals/image/image-visual.h>
  20
  21 // EXTERNAL HEADERS
  22 #include <cstring> // for strlen()
  23 #include <dali/public-api/actors/layer.h>
  24 #include <dali/public-api/images/resource-image.h>
  25 #include <dali/public-api/images/native-image.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/adaptor-framework/image-loading.h>
  29 #include <dali/devel-api/scripting/enum-helper.h>
  30 #include <dali/devel-api/scripting/scripting.h>
  31 #include <dali/integration-api/debug.h>
  32
  33 // INTERNAL HEADERS
  34 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  35 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  36 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  37 #include <dali-toolkit/internal/visuals/texture-manager.h>
  38 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  39 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
  40 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  41 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
  42 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
  43 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  44 #include <dali-toolkit/internal/visuals/visual-url.h>
  45
  46 namespace Dali
  47 {
  48
  49 namespace Toolkit
  50 {
  51
  52 namespace Internal
  53 {
  54
  55 namespace
  56 {
  57
  58 // property names
  59 const char * const IMAGE_FITTING_MODE( "fittingMode" );
  60 const char * const IMAGE_SAMPLING_MODE( "samplingMode" );
  61 const char * const IMAGE_DESIRED_WIDTH( "desiredWidth" );
  62 const char * const IMAGE_DESIRED_HEIGHT( "desiredHeight" );
  63 const char * const SYNCHRONOUS_LOADING( "synchronousLoading" );
  64 const char * const IMAGE_ATLASING("atlasing");
  65 const char * const ALPHA_MASK_URL("alphaMaskUrl");
  66
  67 // fitting modes
  68 DALI_ENUM_TO_STRING_TABLE_BEGIN( FITTING_MODE )
  69 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SHRINK_TO_FIT )
  70 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SCALE_TO_FILL )
  71 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, FIT_WIDTH )
  72 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, FIT_HEIGHT )
  73 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, DEFAULT )
  74 DALI_ENUM_TO_STRING_TABLE_END( FITTING_MODE )
  75
  76 // sampling modes
  77 DALI_ENUM_TO_STRING_TABLE_BEGIN( SAMPLING_MODE )
  78 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX )
  79 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, NEAREST )
  80 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, LINEAR )
  81 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX_THEN_NEAREST )
  82 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, BOX_THEN_LINEAR )
  83 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, NO_FILTER )
  84 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, DONT_CARE )
  85 DALI_ENUM_TO_STRING_TABLE_END( SAMPLING_MODE )
  86
  87 // wrap modes
  88 DALI_ENUM_TO_STRING_TABLE_BEGIN( WRAP_MODE )
  89 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, DEFAULT )
  90 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, CLAMP_TO_EDGE )
  91 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, REPEAT )
  92 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT )
  93 DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE )
  94
  95 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  96
  97 const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
  98
  99 const float PIXEL_ALIGN_ON = 1.0f;
 100 const float PIXEL_ALIGN_OFF = 0.0f;
 101
 102 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
 103   attribute mediump vec2 aPosition;\n
 104   uniform mediump mat4 uModelMatrix;\n
 105   uniform mediump mat4 uViewMatrix;\n
 106   uniform mediump mat4 uProjection;\n
 107   uniform mediump vec3 uSize;\n
 108   uniform mediump vec4 pixelArea;
 109   varying mediump vec2 vTexCoord;\n
 110   uniform lowp float uPixelAligned;\n
 111   \n
 112   //Visual size and offset
 113   uniform mediump vec2 offset;\n
 114   uniform mediump vec2 size;\n
 115   uniform mediump vec4 offsetSizeMode;\n
 116   uniform mediump vec2 origin;\n
 117   uniform mediump vec2 anchorPoint;\n
 118 \n
 119   vec4 ComputeVertexPosition()\n
 120   {\n
 121     vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
 122     vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
 123     return vec4( (aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
 124   }\n
 125 \n
 126   void main()\n
 127   {\n
 128     mediump vec4 vertexPosition = uViewMatrix * uModelMatrix * ComputeVertexPosition();\n
 129     vec4 alignedVertexPosition = vertexPosition;\n
 130     alignedVertexPosition.xy = floor ( vertexPosition.xy );\n // Pixel alignment
 131     vertexPosition = uProjection * mix( vertexPosition, alignedVertexPosition, uPixelAligned );\n
 132     vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
 133     gl_Position = vertexPosition;\n
 134   }\n
 135 );
 136
 137 const char* FRAGMENT_SHADER_NO_ATLAS = DALI_COMPOSE_SHADER(
 138   varying mediump vec2 vTexCoord;\n
 139   uniform sampler2D sTexture;\n
 140   uniform lowp vec4 uColor;\n
 141   uniform lowp vec3 mixColor;\n
 142   uniform lowp float opacity;\n
 143   uniform lowp float preMultipliedAlpha;\n
 144   \n
 145   lowp vec4 visualMixColor()\n
 146   {\n
 147     return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
 148   }\n
 149   void main()\n
 150   {\n
 151       gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * visualMixColor();\n
 152   }\n
 153 );
 154
 155 const char* FRAGMENT_SHADER_ATLAS_CLAMP = DALI_COMPOSE_SHADER(
 156     varying mediump vec2 vTexCoord;\n
 157     uniform sampler2D sTexture;\n
 158     uniform mediump vec4 uAtlasRect;\n
 159     uniform lowp vec4 uColor;\n
 160     uniform lowp vec3 mixColor;\n
 161     uniform lowp float opacity;\n
 162     uniform lowp float preMultipliedAlpha;\n
 163     \n
 164     lowp vec4 visualMixColor()\n
 165     {\n
 166         return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
 167     }\n
 168     \n
 169     void main()\n
 170     {\n
 171         mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );\n
 172         gl_FragColor = texture2D( sTexture, texCoord ) * uColor * visualMixColor();\n
 173      }\n
 174 );
 175
 176 const char* FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP = DALI_COMPOSE_SHADER(
 177     varying mediump vec2 vTexCoord;\n
 178     uniform sampler2D sTexture;\n
 179     uniform mediump vec4 uAtlasRect;\n
 180     // WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
 181     uniform lowp vec2 wrapMode;\n
 182     uniform lowp vec4 uColor;\n
 183     uniform lowp vec3 mixColor;\n
 184     uniform lowp float opacity;\n
 185     uniform lowp float preMultipliedAlpha;\n
 186     \n
 187     mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )\n
 188     {\n
 189       mediump float coord;\n
 190       if( wrap > 1.5 )\n // REFLECT
 191         coord = 1.0-abs(fract(coordinate*0.5)*2.0 - 1.0);\n
 192       else \n// warp == 0 or 1
 193         coord = mix(coordinate, fract( coordinate ), wrap);\n
 194       return clamp( mix(range.x, range.y, coord), range.x, range.y );
 195     }\n
 196     \n
 197     lowp vec4 visualMixColor()\n
 198     {\n
 199       return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
 200     }\n
 201     \n
 202     void main()\n
 203     {\n
 204         mediump vec2 texCoord = vec2( wrapCoordinate( uAtlasRect.xz, vTexCoord.x, wrapMode.x ),
 205                                       wrapCoordinate( uAtlasRect.yw, vTexCoord.y, wrapMode.y ) );\n
 206         gl_FragColor = texture2D( sTexture, texCoord ) * uColor * visualMixColor();\n
 207     }\n
 208 );
 209
 210 Geometry CreateGeometry( VisualFactoryCache& factoryCache, ImageDimensions gridSize )
 211 {
 212   Geometry geometry;
 213
 214   if( gridSize == ImageDimensions( 1, 1 ) )
 215   {
 216     geometry = factoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 217   }
 218   else
 219   {
 220     geometry = VisualFactoryCache::CreateGridGeometry( gridSize );
 221   }
 222
 223   return geometry;
 224 }
 225
 226 } // unnamed namespace
 227
 228 ImageVisualPtr ImageVisual::New( VisualFactoryCache& factoryCache,
 229                                  const VisualUrl& imageUrl,
 230                                  const Property::Map& properties,
 231                                  ImageDimensions size,
 232                                  FittingMode::Type fittingMode,
 233                                  Dali::SamplingMode::Type samplingMode )
 234 {
 235   ImageVisualPtr imageVisualPtr( new ImageVisual( factoryCache, imageUrl, size, fittingMode, samplingMode ) );
 236   imageVisualPtr->SetProperties( properties );
 237   return imageVisualPtr;
 238 }
 239
 240 ImageVisualPtr ImageVisual::New( VisualFactoryCache& factoryCache,
 241                                  const VisualUrl& imageUrl,
 242                                  ImageDimensions size,
 243                                  FittingMode::Type fittingMode,
 244                                  Dali::SamplingMode::Type samplingMode )
 245 {
 246   return new ImageVisual( factoryCache, imageUrl, size, fittingMode, samplingMode );
 247 }
 248
 249 ImageVisualPtr ImageVisual::New( VisualFactoryCache& factoryCache, const Image& image )
 250 {
 251   return new ImageVisual( factoryCache, image );
 252 }
 253
 254 ImageVisual::ImageVisual( VisualFactoryCache& factoryCache,
 255                           const VisualUrl& imageUrl,
 256                           ImageDimensions size,
 257                           FittingMode::Type fittingMode,
 258                           Dali::SamplingMode::Type samplingMode )
 259 : Visual::Base( factoryCache ),
 260   mImage(),
 261   mPixels(),
 262   mPixelArea( FULL_TEXTURE_RECT ),
 263   mPlacementActor(),
 264   mImageUrl( imageUrl ),
 265   mAlphaMaskUrl(),
 266   mDesiredSize( size ),
 267   mTextureId( TextureManager::INVALID_TEXTURE_ID ),
 268   mAlphaMaskId( TextureManager::INVALID_TEXTURE_ID ),
 269   mFittingMode( fittingMode ),
 270   mSamplingMode( samplingMode ),
 271   mWrapModeU( WrapMode::DEFAULT ),
 272   mWrapModeV( WrapMode::DEFAULT ),
 273   mAttemptAtlasing( false ),
 274   mTextureLoading( false )
 275 {
 276 }
 277
 278 ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, const Image& image )
 279 : Visual::Base( factoryCache ),
 280   mImage( image ),
 281   mPixels(),
 282   mPixelArea( FULL_TEXTURE_RECT ),
 283   mPlacementActor(),
 284   mImageUrl(),
 285   mAlphaMaskUrl(),
 286   mDesiredSize(),
 287   mTextureId( TextureManager::INVALID_TEXTURE_ID ),
 288   mAlphaMaskId( TextureManager::INVALID_TEXTURE_ID ),
 289   mFittingMode( FittingMode::DEFAULT ),
 290   mSamplingMode( SamplingMode::DEFAULT ),
 291   mWrapModeU( WrapMode::DEFAULT ),
 292   mWrapModeV( WrapMode::DEFAULT ),
 293   mAttemptAtlasing( false ),
 294   mTextureLoading( false )
 295 {
 296 }
 297
 298 ImageVisual::~ImageVisual()
 299 {
 300   if( mAlphaMaskId != TextureManager::INVALID_TEXTURE_ID )
 301   {
 302     TextureManager& textureManager = mFactoryCache.GetTextureManager();
 303     textureManager.Remove( mAlphaMaskId );
 304   }
 305 }
 306
 307 void ImageVisual::DoSetProperties( const Property::Map& propertyMap )
 308 {
 309   // Url is already received in constructor
 310   for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
 311   {
 312     KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
 313     if( keyValue.first.type == Property::Key::INDEX )
 314     {
 315       DoSetProperty( keyValue.first.indexKey, keyValue.second );
 316     }
 317     else
 318     {
 319       if( keyValue.first == IMAGE_FITTING_MODE )
 320       {
 321         DoSetProperty( Toolkit::ImageVisual::Property::FITTING_MODE, keyValue.second );
 322       }
 323       else if( keyValue.first == IMAGE_SAMPLING_MODE )
 324       {
 325         DoSetProperty( Toolkit::ImageVisual::Property::SAMPLING_MODE, keyValue.second );
 326       }
 327       else if( keyValue.first == IMAGE_DESIRED_WIDTH )
 328       {
 329         DoSetProperty( Toolkit::ImageVisual::Property::DESIRED_WIDTH, keyValue.second );
 330       }
 331       else if( keyValue.first == IMAGE_DESIRED_HEIGHT )
 332       {
 333         DoSetProperty( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, keyValue.second );
 334       }
 335       else if( keyValue.first == PIXEL_AREA_UNIFORM_NAME )
 336       {
 337         DoSetProperty( Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second );
 338       }
 339       else if( keyValue.first == IMAGE_WRAP_MODE_U )
 340       {
 341         DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second );
 342       }
 343       else if( keyValue.first == IMAGE_WRAP_MODE_V )
 344       {
 345         DoSetProperty( Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second );
 346       }
 347       else if( keyValue.first == SYNCHRONOUS_LOADING )
 348       {
 349         DoSetProperty( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second );
 350       }
 351       else if ( keyValue.first == IMAGE_ATLASING )
 352       {
 353         DoSetProperty( Toolkit::DevelImageVisual::Property::ATLASING, keyValue.second );
 354       }
 355       else if ( keyValue.first == ALPHA_MASK_URL )
 356       {
 357         DoSetProperty( Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL, keyValue.second );
 358       }
 359     }
 360   }
 361
 362   if( mAlphaMaskUrl.IsValid() )
 363   {
 364     // Immediately trigger the alpha mask loading (it may just get a cached value)
 365     TextureManager& textureManager = mFactoryCache.GetTextureManager();
 366     mAlphaMaskId = textureManager.RequestMaskLoad( mAlphaMaskUrl );
 367   }
 368
 369   if( ( mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING ) && mImageUrl.IsValid() )
 370   {
 371     // if sync loading is required, the loading should start
 372     // immediately when new image url is set or the actor is off stage
 373     // ( for on-stage actor with image url unchanged, resource loading
 374     // is already finished )
 375     LoadResourceSynchronously();
 376   }
 377 }
 378
 379 void ImageVisual::DoSetProperty( Property::Index index, const Property::Value& value )
 380 {
 381   switch( index )
 382   {
 383     case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING:
 384     {
 385       bool sync;
 386       if( value.Get( sync ) )
 387       {
 388         if( sync )
 389         {
 390           mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 391         }
 392         else
 393         {
 394           mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 395         }
 396       }
 397       else
 398       {
 399         DALI_LOG_ERROR("ImageVisual: synchronousLoading property has incorrect type\n");
 400       }
 401       break;
 402     }
 403
 404     case Toolkit::ImageVisual::Property::DESIRED_WIDTH:
 405     {
 406       float desiredWidth;
 407       if( value.Get( desiredWidth ) )
 408       {
 409         mDesiredSize.SetWidth( desiredWidth );
 410       }
 411       else
 412       {
 413         DALI_LOG_ERROR("ImageVisual: desiredWidth property has incorrect type\n");
 414       }
 415       break;
 416     }
 417
 418     case Toolkit::ImageVisual::Property::DESIRED_HEIGHT:
 419     {
 420       float desiredHeight;
 421       if( value.Get( desiredHeight ) )
 422       {
 423         mDesiredSize.SetHeight( desiredHeight );
 424       }
 425       else
 426       {
 427         DALI_LOG_ERROR("ImageVisual: desiredHeight property has incorrect type\n");
 428       }
 429       break;
 430     }
 431
 432     case Toolkit::ImageVisual::Property::FITTING_MODE:
 433     {
 434       int fittingMode;
 435       Scripting::GetEnumerationProperty( value, FITTING_MODE_TABLE, FITTING_MODE_TABLE_COUNT, fittingMode );
 436       mFittingMode = Dali::FittingMode::Type( fittingMode );
 437       break;
 438     }
 439
 440     case Toolkit::ImageVisual::Property::SAMPLING_MODE:
 441     {
 442       int samplingMode;
 443       Scripting::GetEnumerationProperty( value, SAMPLING_MODE_TABLE, SAMPLING_MODE_TABLE_COUNT, samplingMode );
 444       mSamplingMode = Dali::SamplingMode::Type( samplingMode );
 445       break;
 446     }
 447
 448     case Toolkit::ImageVisual::Property::PIXEL_AREA:
 449     {
 450       value.Get( mPixelArea );
 451       break;
 452     }
 453
 454     case Toolkit::ImageVisual::Property::WRAP_MODE_U:
 455     {
 456       int wrapMode;
 457       Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode );
 458       mWrapModeU = Dali::WrapMode::Type( wrapMode );
 459       break;
 460     }
 461
 462     case Toolkit::ImageVisual::Property::WRAP_MODE_V:
 463     {
 464       int wrapMode;
 465       Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode );
 466       mWrapModeV = Dali::WrapMode::Type( wrapMode );
 467       break;
 468     }
 469
 470     case Toolkit::DevelImageVisual::Property::ATLASING:
 471     {
 472       bool atlasing = false;
 473       mAttemptAtlasing = value.Get( atlasing );
 474     }
 475
 476     case Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL:
 477     {
 478       std::string alphaUrl;
 479       if( value.Get( alphaUrl ) )
 480       {
 481         mAlphaMaskUrl = VisualUrl( alphaUrl );
 482       }
 483     }
 484   }
 485 }
 486
 487 void ImageVisual::GetNaturalSize( Vector2& naturalSize )
 488 {
 489   if(mImage)
 490   {
 491     naturalSize.x = mImage.GetWidth();
 492     naturalSize.y = mImage.GetHeight();
 493     return;
 494   }
 495   else if( mDesiredSize.GetWidth()>0 && mDesiredSize.GetHeight()>0)
 496   {
 497     naturalSize.x = mDesiredSize.GetWidth();
 498     naturalSize.y = mDesiredSize.GetHeight();
 499     return;
 500   }
 501   else if( mImageUrl.IsValid() && mImageUrl.GetLocation() == VisualUrl::LOCAL )
 502   {
 503     ImageDimensions dimensions = Dali::GetClosestImageSize( mImageUrl.GetUrl() );
 504
 505     if( dimensions != ImageDimensions( 0, 0 ) )
 506     {
 507       naturalSize.x = dimensions.GetWidth();
 508       naturalSize.y = dimensions.GetHeight();
 509     }
 510     else
 511     {
 512       Image brokenImage = VisualFactoryCache::GetBrokenVisualImage();
 513
 514       naturalSize.x = brokenImage.GetWidth();
 515       naturalSize.y = brokenImage.GetWidth();
 516     }
 517     return;
 518   }
 519
 520   naturalSize = Vector2::ZERO;
 521 }
 522
 523 void ImageVisual::CreateRenderer( TextureSet& textureSet )
 524 {
 525   Geometry geometry;
 526   Shader shader;
 527
 528   if( !mImpl->mCustomShader )
 529   {
 530     geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 531
 532     shader = GetImageShader( mFactoryCache,
 533                              mImpl->mFlags & Impl::IS_ATLASING_APPLIED,
 534                              mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE );
 535   }
 536   else
 537   {
 538     geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
 539     if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
 540     {
 541       shader = GetImageShader( mFactoryCache, false, true );
 542     }
 543     else
 544     {
 545       shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
 546                              mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER_NO_ATLAS : mImpl->mCustomShader->mFragmentShader,
 547                              mImpl->mCustomShader->mHints );
 548       if( mImpl->mCustomShader->mVertexShader.empty() )
 549       {
 550         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 551       }
 552     }
 553   }
 554
 555   // Set pixel align off as default.
 556   // ToDo: Pixel align causes issues such as rattling image animation.
 557   // We should trun it off until issues are resolved
 558   shader.RegisterProperty( PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF );
 559
 560   mImpl->mRenderer = Renderer::New( geometry, shader );
 561   if( textureSet )
 562   {
 563     mImpl->mRenderer.SetTextures( textureSet );
 564   }
 565   // else still waiting for texture load to finish.
 566
 567   //Register transform properties
 568   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 569 }
 570
 571 void ImageVisual::CreateNativeImageRenderer( NativeImage& nativeImage )
 572 {
 573   Geometry geometry;
 574   Shader shader;
 575
 576   std::string fragmentShader;
 577   const char* fragmentPreFix = nativeImage.GetCustomFragmentPreFix();
 578   const char* customSamplerTypename = nativeImage.GetCustomSamplerTypename();
 579
 580   if( fragmentPreFix )
 581   {
 582     fragmentShader = fragmentPreFix;
 583     fragmentShader += "\n";
 584   }
 585
 586   if( mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty() )
 587   {
 588     fragmentShader += mImpl->mCustomShader->mFragmentShader;
 589   }
 590   else
 591   {
 592     fragmentShader += FRAGMENT_SHADER_NO_ATLAS;
 593   }
 594
 595   if( customSamplerTypename )
 596   {
 597     fragmentShader.replace( fragmentShader.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
 598   }
 599
 600   if( !mImpl->mCustomShader )
 601   {
 602     geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
 603
 604     shader  = Shader::New( VERTEX_SHADER, fragmentShader );
 605     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 606   }
 607   else
 608   {
 609     geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
 610     shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
 611                            fragmentShader,
 612                            mImpl->mCustomShader->mHints );
 613     if( mImpl->mCustomShader->mVertexShader.empty() )
 614     {
 615       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 616     }
 617   }
 618
 619   mImpl->mRenderer = Renderer::New( geometry, shader );
 620
 621   //Register transform properties
 622   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 623 }
 624
 625
 626 bool ImageVisual::IsSynchronousResourceLoading() const
 627 {
 628   return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 629 }
 630
 631 void ImageVisual::LoadResourceSynchronously()
 632 {
 633   if( mImageUrl.IsValid() )
 634   {
 635     BitmapLoader loader = BitmapLoader::New( mImageUrl.GetUrl(), mDesiredSize, mFittingMode, mSamplingMode );
 636     loader.Load();
 637     mPixels = loader.GetPixelData();
 638     mTextureLoading = false;
 639   }
 640 }
 641
 642 TextureSet ImageVisual::CreateTextureSet( Vector4& textureRect, bool synchronousLoading, bool attemptAtlasing )
 643 {
 644   TextureSet textureSet;
 645
 646   mTextureLoading = false;
 647
 648   textureRect = FULL_TEXTURE_RECT;
 649   if( synchronousLoading )
 650   {
 651     if( !mPixels )
 652     {
 653       // use broken image
 654       textureSet = TextureSet::New();
 655       TextureSetImage( textureSet, 0u, VisualFactoryCache::GetBrokenVisualImage() );
 656     }
 657     else
 658     {
 659       if( attemptAtlasing )
 660       {
 661         textureSet = mFactoryCache.GetAtlasManager()->Add(textureRect, mPixels );
 662         mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
 663       }
 664       if( !textureSet ) // big image, no atlasing or atlasing failed
 665       {
 666         mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 667         Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D, mPixels.GetPixelFormat(),
 668                                         mPixels.GetWidth(), mPixels.GetHeight() );
 669         texture.Upload( mPixels );
 670         textureSet = TextureSet::New();
 671         textureSet.SetTexture( 0u, texture );
 672       }
 673     }
 674   }
 675   else
 676   {
 677     if( attemptAtlasing )
 678     {
 679       textureSet = mFactoryCache.GetAtlasManager()->Add( textureRect, mImageUrl.GetUrl(), mDesiredSize, mFittingMode, true, this );
 680       mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
 681       mTextureLoading = true;
 682     }
 683     if( !textureSet ) // big image, no atlasing or atlasing failed
 684     {
 685       mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 686       TextureManager& textureManager = mFactoryCache.GetTextureManager();
 687       if( mAlphaMaskId == TextureManager::INVALID_TEXTURE_ID )
 688       {
 689         mTextureId = textureManager.RequestLoad( mImageUrl, mDesiredSize, mFittingMode,
 690                                                  mSamplingMode, TextureManager::NO_ATLAS, this );
 691       }
 692       else
 693       {
 694         mTextureId = textureManager.RequestLoad( mImageUrl, mAlphaMaskId, mDesiredSize,
 695                                                  mFittingMode, mSamplingMode,
 696                                                  TextureManager::NO_ATLAS, this );
 697       }
 698
 699       TextureManager::LoadState loadState = textureManager.GetTextureState( mTextureId );
 700
 701       mTextureLoading = ( loadState == TextureManager::LOADING );
 702
 703       if( loadState == TextureManager::UPLOADED )
 704       {
 705         // UploadComplete has already been called - keep the same texture set
 706         textureSet = textureManager.GetTextureSet(mTextureId);
 707       }
 708     }
 709   }
 710
 711   if( ! (mImpl->mFlags & Impl::IS_ATLASING_APPLIED) && textureSet )
 712   {
 713     Sampler sampler = Sampler::New();
 714     sampler.SetWrapMode(  mWrapModeU, mWrapModeV  );
 715     textureSet.SetSampler( 0u, sampler );
 716   }
 717
 718   return textureSet;
 719 }
 720
 721 void ImageVisual::InitializeRenderer()
 722 {
 723   mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 724
 725   if( ! mImpl->mCustomShader && mImageUrl.GetLocation() == VisualUrl::LOCAL )
 726   {
 727     bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
 728
 729     Vector4 atlasRect;
 730     // texture set has to be created first as we need to know if atlasing succeeded or not
 731     // when selecting the shader
 732     TextureSet textures = CreateTextureSet( atlasRect, IsSynchronousResourceLoading(), mAttemptAtlasing );
 733     CreateRenderer( textures );
 734
 735     if( mImpl->mFlags & Impl::IS_ATLASING_APPLIED ) // the texture is packed inside atlas
 736     {
 737       mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
 738       if( !defaultWrapMode ) // custom wrap mode, renderer is not cached.
 739       {
 740         Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE);
 741         wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) );
 742         mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode );
 743       }
 744     }
 745   }
 746   else
 747   {
 748     // for custom shader or remote image, atlas is not applied
 749     Vector4 atlasRect; // ignored in this case
 750     TextureSet textures = CreateTextureSet( atlasRect, IsSynchronousResourceLoading(), false );
 751     CreateRenderer( textures );
 752   }
 753 }
 754
 755 void ImageVisual::InitializeRenderer( const Image& image )
 756 {
 757   // don't reuse CreateTextureSet
 758   TextureSet textures = TextureSet::New();
 759
 760   NativeImage nativeImage = NativeImage::DownCast( image );
 761   if( nativeImage )
 762   {
 763     CreateNativeImageRenderer( nativeImage );
 764     DALI_ASSERT_DEBUG( textures );
 765     mImpl->mRenderer.SetTextures( textures );
 766   }
 767   else
 768   {
 769     // reuse existing code for regular images
 770     CreateRenderer( textures );
 771   }
 772   ApplyImageToSampler( image );
 773 }
 774
 775 void ImageVisual::DoSetOnStage( Actor& actor )
 776 {
 777   if( mImageUrl.IsValid() )
 778   {
 779     InitializeRenderer();
 780   }
 781   else if ( mImage )
 782   {
 783     InitializeRenderer( mImage );
 784   }
 785
 786   if ( !mImpl->mRenderer )
 787   {
 788     return;
 789   }
 790
 791   mPlacementActor = actor;
 792   // Search the Actor tree to find if Layer UI behaviour set.
 793   Layer layer = actor.GetLayer();
 794   if ( layer && layer.GetBehavior() == Layer::LAYER_3D )
 795   {
 796      // Layer 3D set, do not align pixels
 797      mImpl->mRenderer.RegisterProperty( PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF );
 798   }
 799
 800   if( mPixelArea != FULL_TEXTURE_RECT )
 801   {
 802     mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
 803   }
 804
 805   if( mTextureLoading == false )
 806   {
 807     actor.AddRenderer( mImpl->mRenderer );
 808     mPlacementActor.Reset();
 809
 810     // Image loaded and ready to display
 811     ResourceReady();
 812   }
 813 }
 814
 815 void ImageVisual::DoSetOffStage( Actor& actor )
 816 {
 817   // Visual::Base::SetOffStage only calls DoSetOffStage if mRenderer exists (is on onstage)
 818
 819   //If we own the image then make sure we release it when we go off stage
 820   actor.RemoveRenderer( mImpl->mRenderer);
 821   if( mImageUrl.IsValid() )
 822   {
 823     RemoveTexture( mImageUrl.GetUrl() );
 824     mImage.Reset();
 825   }
 826   mTextureLoading = false;
 827   mImpl->mRenderer.Reset();
 828   mPlacementActor.Reset();
 829 }
 830
 831 void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 832 {
 833   map.Clear();
 834   map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::IMAGE );
 835
 836   bool sync = IsSynchronousResourceLoading();
 837   map.Insert( SYNCHRONOUS_LOADING, sync );
 838   if( mImageUrl.IsValid() )
 839   {
 840     map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl() );
 841     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );
 842     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight() );
 843   }
 844   else if( mImage )
 845   {
 846     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, static_cast<int>(mImage.GetWidth()) );
 847     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, static_cast<int>(mImage.GetHeight()) );
 848
 849     ResourceImage resourceImage = ResourceImage::DownCast(mImage);
 850     if( resourceImage )
 851     {
 852       map.Insert( Toolkit::ImageVisual::Property::URL, resourceImage.GetUrl() );
 853     }
 854   }
 855
 856   map.Insert( Toolkit::ImageVisual::Property::FITTING_MODE, mFittingMode );
 857   map.Insert( Toolkit::ImageVisual::Property::SAMPLING_MODE, mSamplingMode );
 858
 859   map.Insert( Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea );
 860   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU );
 861   map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV );
 862
 863   map.Insert( Toolkit::DevelImageVisual::Property::ATLASING, mAttemptAtlasing );
 864   map.Insert( Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL, mAlphaMaskUrl.GetUrl() );
 865 }
 866
 867 void ImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 868 {
 869   map.Clear();
 870   map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::IMAGE );
 871   if( mImageUrl.IsValid() )
 872   {
 873     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth() );
 874     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight() );
 875   }
 876   else if( mImage )
 877   {
 878     map.Insert( Toolkit::ImageVisual::Property::DESIRED_WIDTH, static_cast<int>(mImage.GetWidth()) );
 879     map.Insert( Toolkit::ImageVisual::Property::DESIRED_HEIGHT, static_cast<int>(mImage.GetHeight()) );
 880   }
 881 }
 882
 883 void ImageVisual::OnSetTransform()
 884 {
 885   if( mImpl->mRenderer )
 886   {
 887     mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 888   }
 889 }
 890
 891 Shader ImageVisual::GetImageShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping )
 892 {
 893   Shader shader;
 894   if( atlasing )
 895   {
 896     if( defaultTextureWrapping )
 897     {
 898       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP );
 899       if( !shader )
 900       {
 901         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
 902         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 903         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader );
 904       }
 905     }
 906     else
 907     {
 908       shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP );
 909       if( !shader )
 910       {
 911         shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP );
 912         shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 913         factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP, shader );
 914       }
 915     }
 916   }
 917   else
 918   {
 919     shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
 920     if( !shader )
 921     {
 922       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
 923       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 924       factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
 925     }
 926   }
 927
 928   return shader;
 929 }
 930
 931 void ImageVisual::ApplyImageToSampler( const Image& image )
 932 {
 933   if( image )
 934   {
 935     TextureSet textureSet = mImpl->mRenderer.GetTextures();
 936     DALI_ASSERT_DEBUG( textureSet ); // texture set should always exist by this time
 937
 938     TextureSetImage( textureSet, 0u, image );
 939     Sampler sampler = Sampler::New();
 940     sampler.SetWrapMode(  mWrapModeU, mWrapModeV  );
 941     textureSet.SetSampler( 0u, sampler );
 942   }
 943 }
 944
 945 // From existing atlas manager
 946 void ImageVisual::UploadCompleted()
 947 {
 948   // Texture has been uploaded. If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 949   Actor actor = mPlacementActor.GetHandle();
 950   if( actor )
 951   {
 952     actor.AddRenderer( mImpl->mRenderer );
 953
 954     // reset the weak handle so that the renderer only get added to actor once
 955     mPlacementActor.Reset();
 956   }
 957   mTextureLoading = false;
 958 }
 959
 960 // From Texture Manager
 961 void ImageVisual::UploadComplete( bool loadingSuccess, TextureSet textureSet, bool usingAtlas, const Vector4& atlasRectangle )
 962 {
 963   Actor actor = mPlacementActor.GetHandle();
 964   if( actor )
 965   {
 966     if( mImpl->mRenderer )
 967     {
 968       actor.AddRenderer( mImpl->mRenderer );
 969       // reset the weak handle so that the renderer only get added to actor once
 970       mPlacementActor.Reset();
 971
 972       if( loadingSuccess )
 973       {
 974         Sampler sampler = Sampler::New();
 975         sampler.SetWrapMode(  mWrapModeU, mWrapModeV  );
 976         textureSet.SetSampler( 0u, sampler );
 977         mImpl->mRenderer.SetTextures(textureSet);
 978       }
 979       else
 980       {
 981         Image brokenImage = VisualFactoryCache::GetBrokenVisualImage();
 982
 983         textureSet = TextureSet::New();
 984         mImpl->mRenderer.SetTextures( textureSet );
 985
 986         ApplyImageToSampler( brokenImage );
 987       }
 988       // Image loaded and ready to display
 989       ResourceReady();
 990     }
 991   }
 992   mTextureLoading = false;
 993 }
 994
 995 void ImageVisual::RemoveTexture(const std::string& url)
 996 {
 997   if( mTextureId != TextureManager::INVALID_TEXTURE_ID )
 998   {
 999     mFactoryCache.GetTextureManager().Remove( mTextureId );
1000     mTextureId = TextureManager::INVALID_TEXTURE_ID;
1001   }
1002   else
1003   {
1004     Vector4 atlasRect( 0.f, 0.f, 1.f, 1.f );
1005     Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
1006     if( index != Property::INVALID_INDEX )
1007     {
1008       Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index );
1009       atlasRectValue.Get( atlasRect );
1010     }
1011
1012     TextureSet textureSet = mImpl->mRenderer.GetTextures();
1013     mImpl->mRenderer.Reset();
1014
1015     if( index != Property::INVALID_INDEX )
1016     {
1017       mFactoryCache.GetAtlasManager()->Remove( textureSet, atlasRect );
1018     }
1019   }
1020 }
1021
1022 } // namespace Internal
1023
1024 } // namespace Toolkit
1025
1026 } // namespace Dali