Fixed ImageRenderer::DoSetOffStage inccorrectly calling ControlRenderer::SetOffStage.
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / renderers / image / image-renderer.cpp
1 /*
2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 // CLASS HEADER
19 #include "image-renderer.h"
20
21 #include <dali-toolkit/internal/controls/renderers/renderer-factory-impl.h>
22 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
23 #include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
24 #include <dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h>
25 #include <dali/public-api/images/resource-image.h>
26
27 namespace Dali
28 {
29
30 namespace Toolkit
31 {
32
33 namespace Internal
34 {
35
36 namespace
37 {
38
39 const char * const IMAGE_URL_NAME("image-url");
40 const char * const IMAGE_FITTING_MODE("image-fitting-mode");
41 const char * const IMAGE_SAMPLING_MODE("image-sampling-mode");
42 const char * const IMAGE_DESIRED_WIDTH("image-desired-width");
43 const char * const IMAGE_DESIRED_HEIGHT("image-desired-height");
44
45 std::string TEXTURE_UNIFORM_NAME = "sTexture";
46
47 #define MAKE_SHADER(A)#A
48
49 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
50   attribute mediump vec2 aPosition;\n
51   varying mediump vec2 vTexCoord;\n
52   uniform mediump mat4 uMvpMatrix;\n
53   uniform mediump vec3 uSize;\n
54   \n
55   void main()\n
56   {\n
57     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
58     vertexPosition.xyz *= uSize;\n
59     vertexPosition = uMvpMatrix * vertexPosition;\n
60     \n
61     vTexCoord = aPosition + vec2(0.5);\n
62     gl_Position = vertexPosition;\n
63   }\n
64 );
65
66 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
67   varying mediump vec2 vTexCoord;\n
68   uniform sampler2D sTexture;\n
69   uniform lowp vec4 uColor;\n
70   \n
71   void main()\n
72   {\n
73     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
74   }\n
75 );
76
77 } //unnamed namespace
78
79 ImageRenderer::ImageRenderer()
80 : ControlRenderer(),
81   mDesiredSize(),
82   mFittingMode( FittingMode::DEFAULT ),
83   mSamplingMode( SamplingMode::DEFAULT )
84 {
85 }
86
87 ImageRenderer::~ImageRenderer()
88 {
89 }
90
91 void ImageRenderer::Initialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
92 {
93   Initialize(factoryCache);
94
95   Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
96   if( imageURLValue )
97   {
98     imageURLValue->Get( mImageUrl );
99
100     Property::Value* fittingValue = propertyMap.Find( IMAGE_FITTING_MODE );
101     if( fittingValue )
102     {
103       std::string fitting;
104       fittingValue->Get( fitting );
105
106       mFittingMode = FittingMode::DEFAULT;
107       if( fitting == "shrink-to-fit" )
108       {
109         mFittingMode = FittingMode::SHRINK_TO_FIT;
110       }
111       else if( fitting == "scale-to-fill" )
112       {
113         mFittingMode = FittingMode::SCALE_TO_FILL;
114       }
115       else if( fitting == "fit-width" )
116       {
117         mFittingMode = FittingMode::FIT_WIDTH;
118       }
119       else if( fitting == "fit-height" )
120       {
121         mFittingMode = FittingMode::FIT_HEIGHT;
122       }
123       else if( fitting == "default" )
124       {
125         mFittingMode = FittingMode::DEFAULT;
126       }
127       else
128       {
129         DALI_ASSERT_ALWAYS("Unknown fitting mode");
130       }
131     }
132
133     Property::Value* samplingValue = propertyMap.Find( IMAGE_SAMPLING_MODE );
134     if( samplingValue )
135     {
136       std::string sampling;
137       samplingValue->Get( sampling );
138
139       mSamplingMode = SamplingMode::DEFAULT;
140       if( sampling == "box" )
141       {
142         mSamplingMode = SamplingMode::BOX;
143       }
144       else if( sampling == "nearest" )
145       {
146         mSamplingMode = SamplingMode::NEAREST;
147       }
148       else if( sampling == "linear" )
149       {
150         mSamplingMode = SamplingMode::LINEAR;
151       }
152       else if( sampling == "box-then-nearest" )
153       {
154         mSamplingMode = SamplingMode::BOX_THEN_NEAREST;
155       }
156       else if( sampling == "box-then-linear" )
157       {
158         mSamplingMode = SamplingMode::BOX_THEN_LINEAR;
159       }
160       else if( sampling == "no-filter" )
161       {
162         mSamplingMode = SamplingMode::NO_FILTER;
163       }
164       else if( sampling == "dont-care" )
165       {
166         mSamplingMode = SamplingMode::DONT_CARE;
167       }
168       else if( sampling == "default" )
169       {
170         mSamplingMode = SamplingMode::DEFAULT;
171       }
172       else
173       {
174         DALI_ASSERT_ALWAYS("Unknown sampling mode");
175       }
176     }
177
178     int desiredWidth = 0;
179     Property::Value* desiredWidthValue = propertyMap.Find( IMAGE_DESIRED_WIDTH );
180     if( desiredWidthValue )
181     {
182       desiredWidthValue->Get( desiredWidth );
183     }
184
185     int desiredHeight = 0;
186     Property::Value* desiredHeightValue = propertyMap.Find( IMAGE_DESIRED_HEIGHT );
187     if( desiredHeightValue )
188     {
189       desiredHeightValue->Get( desiredHeight );
190     }
191
192     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
193   }
194
195   mImage.Reset();
196 }
197
198 void ImageRenderer::SetSize( const Vector2& size )
199 {
200   ControlRenderer::SetSize( size );
201   // ToDo: renderer responds to the size change
202 }
203
204 void ImageRenderer::SetClipRect( const Rect<int>& clipRect )
205 {
206   ControlRenderer::SetClipRect( clipRect );
207   //ToDo: renderer responds to the clipRect change
208 }
209
210 void ImageRenderer::SetOffset( const Vector2& offset )
211 {
212   //ToDo: renderer applies the offset
213 }
214
215 void ImageRenderer::DoSetOnStage( Actor& actor )
216 {
217   if( !mImageUrl.empty() && !mImage )
218   {
219     mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
220   }
221
222   ApplyImageToSampler();
223 }
224
225 void ImageRenderer::DoSetOffStage( Actor& actor )
226 {
227   //If we own the image then make sure we release it when we go off stage
228   if( !mImageUrl.empty() )
229   {
230     mImage.Reset();
231   }
232 }
233
234 void ImageRenderer::Initialize( RendererFactoryCache& factoryCache )
235 {
236   mImpl->mGeometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
237   if( !(mImpl->mGeometry) )
238   {
239     mImpl->mGeometry =  factoryCache.CreateQuadGeometry();
240     factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, mImpl->mGeometry );
241   }
242
243   mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
244   if( !mImpl->mShader )
245   {
246     mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
247     factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, mImpl->mShader );
248   }
249
250   mDesiredSize = ImageDimensions();
251   mFittingMode = FittingMode::DEFAULT;
252   mSamplingMode = SamplingMode::DEFAULT;
253   mImageUrl.clear();
254 }
255
256 void ImageRenderer::SetImage( const std::string& imageUrl )
257 {
258   SetImage( imageUrl, 0, 0, Dali::FittingMode::DEFAULT, Dali::SamplingMode::DEFAULT );
259 }
260
261 void ImageRenderer::SetImage( const std::string& imageUrl, int desiredWidth, int desiredHeight, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
262 {
263   if( mImageUrl != imageUrl )
264   {
265     mImageUrl = imageUrl;
266     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
267     mFittingMode = fittingMode;
268     mSamplingMode = samplingMode;
269
270     if( !mImageUrl.empty() && mImpl->mIsOnStage )
271     {
272       mImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
273       ApplyImageToSampler();
274     }
275     else
276     {
277       mImage.Reset();
278     }
279   }
280 }
281
282 void ImageRenderer::SetImage( Image image )
283 {
284   if( mImage != image )
285   {
286     mImageUrl.clear();
287     mDesiredSize = ImageDimensions();
288     mFittingMode = FittingMode::DEFAULT;
289     mSamplingMode = SamplingMode::DEFAULT;
290     mImage = image;
291
292     if( mImage && mImpl->mIsOnStage )
293     {
294       ApplyImageToSampler();
295     }
296   }
297 }
298
299 Image ImageRenderer::GetImage() const
300 {
301   return mImage;
302 }
303
304 void ImageRenderer::ApplyImageToSampler()
305 {
306   if( mImage )
307   {
308     Material material = mImpl->mRenderer.GetMaterial();
309     if( material )
310     {
311       for( std::size_t i = 0; i < material.GetNumberOfSamplers(); ++i )
312       {
313         Sampler sampler = material.GetSamplerAt( i );
314         if( sampler.GetUniformName() == TEXTURE_UNIFORM_NAME )
315         {
316           sampler.SetImage( mImage );
317           return;
318         }
319       }
320
321       Sampler sampler = Sampler::New( mImage, TEXTURE_UNIFORM_NAME );
322       material.AddSampler( sampler );
323     }
324   }
325 }
326
327 } // namespace Internal
328
329 } // namespace Toolkit
330
331 } // namespace Dali