Merge "Add Text font size conversion description in documentation" into devel/master
[platform/core/uifw/dali-toolkit.git] / 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