Prevent Image visuals creating a renderer and putting it on stage even if url provide...
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / border / border-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 "border-visual.h"
20
21 // EXTERNAL INCLUDES
22 #include <dali/integration-api/debug.h>
23
24 // INTERNAL INCLUDES
25 #include <dali-toolkit/public-api/visuals/border-visual-properties.h>
26 #include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
27 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
28 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
29 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
30 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
31
32 namespace Dali
33 {
34
35 namespace Toolkit
36 {
37
38 namespace Internal
39 {
40
41 namespace
42 {
43 const char * const COLOR_NAME("borderColor");
44 const char * const SIZE_NAME("borderSize");
45 const char * const ANTI_ALIASING("antiAliasing");
46
47 const char * const POSITION_ATTRIBUTE_NAME("aPosition");
48 const char * const DRIFT_ATTRIBUTE_NAME("aDrift");
49 const char * const INDEX_NAME("indices");
50
51
52 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
53   attribute mediump vec2 aPosition;\n
54   attribute mediump vec2 aDrift;\n
55   uniform mediump mat4 uMvpMatrix;\n
56   uniform mediump vec3 uSize;\n
57   uniform mediump float borderSize;\n
58   \n
59
60   //Visual size and offset
61   uniform mediump vec2 offset;\n
62   uniform mediump vec2 size;\n
63   uniform mediump vec4 offsetSizeMode;\n
64   uniform mediump vec2 origin;\n
65   uniform mediump vec2 anchorPoint;\n
66
67   vec4 ComputeVertexPosition()\n
68   {\n
69     vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
70     vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
71     return vec4( (aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
72   }\n
73
74   void main()\n
75   {\n
76     vec2 position = ComputeVertexPosition().xy + aDrift*borderSize;\n
77     gl_Position = uMvpMatrix * vec4(position, 0.0, 1.0);\n
78   }\n
79 );
80
81 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
82   uniform lowp vec4 uColor;\n
83   uniform lowp vec4 borderColor;\n
84   \n
85   void main()\n
86   {\n
87     gl_FragColor = borderColor*uColor;\n
88   }\n
89 );
90
91 const char* VERTEX_SHADER_ANTI_ALIASING = DALI_COMPOSE_SHADER(
92   attribute mediump vec2 aPosition;\n
93   attribute mediump vec2 aDrift;\n
94   uniform mediump mat4 uMvpMatrix;\n
95   uniform mediump vec3 uSize;\n
96   uniform mediump float borderSize;\n
97   varying mediump float vAlpha;\n
98   \n
99   void main()\n
100   {\n
101     vec2 position = aPosition*(uSize.xy+vec2(0.75)) + aDrift*(borderSize+1.5);\n
102     gl_Position = uMvpMatrix * vec4(position, 0.0, 1.0);\n
103     vAlpha = min( abs(aDrift.x), abs(aDrift.y) )*(borderSize+1.5);
104   }\n
105 );
106
107 const char* FRAGMENT_SHADER_ANTI_ALIASING = DALI_COMPOSE_SHADER(
108   uniform lowp vec4 uColor;\n
109   uniform lowp vec4 borderColor;\n
110   uniform mediump float borderSize;\n
111   varying mediump float vAlpha;\n
112   \n
113   void main()\n
114   {\n
115     gl_FragColor = borderColor*uColor;\n
116     gl_FragColor.a *= smoothstep(0.0, 1.5, vAlpha)*smoothstep( borderSize+1.5, borderSize, vAlpha );\n
117   }\n
118 );
119 }
120
121 BorderVisualPtr BorderVisual::New( VisualFactoryCache& factoryCache )
122 {
123   return new BorderVisual( factoryCache );
124 }
125
126 BorderVisual::BorderVisual( VisualFactoryCache& factoryCache )
127 : Visual::Base( factoryCache ),
128   mBorderColor( Color::TRANSPARENT ),
129   mBorderSize( 0.f ),
130   mBorderColorIndex( Property::INVALID_INDEX ),
131   mBorderSizeIndex( Property::INVALID_INDEX ),
132   mAntiAliasing( false )
133 {
134 }
135
136 BorderVisual::~BorderVisual()
137 {
138 }
139
140 void BorderVisual::DoSetProperties( const Property::Map& propertyMap )
141 {
142   Property::Value* color = propertyMap.Find( Toolkit::BorderVisual::Property::COLOR, COLOR_NAME );
143   if( !( color && color->Get(mBorderColor) ) )
144   {
145     DALI_LOG_ERROR( "Fail to provide a border color to the BorderVisual object\n" );
146   }
147
148   Property::Value* size = propertyMap.Find( Toolkit::BorderVisual::Property::SIZE, SIZE_NAME );
149   if( !( size && size->Get(mBorderSize) ) )
150   {
151     DALI_LOG_ERROR( "Fail to provide a border size to the BorderVisual object\n" );
152   }
153
154   Property::Value* antiAliasing = propertyMap.Find( Toolkit::BorderVisual::Property::ANTI_ALIASING, ANTI_ALIASING );
155   if( antiAliasing )
156   {
157     antiAliasing->Get( mAntiAliasing );
158   }
159 }
160
161 void BorderVisual::DoSetOnStage( Actor& actor )
162 {
163   InitializeRenderer();
164
165   mBorderColorIndex = (mImpl->mRenderer).RegisterProperty( Toolkit::BorderVisual::Property::COLOR, COLOR_NAME, mBorderColor );
166   if( mBorderColor.a < 1.f || mAntiAliasing)
167   {
168     mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
169   }
170   mBorderSizeIndex = (mImpl->mRenderer).RegisterProperty( Toolkit::BorderVisual::Property::SIZE, SIZE_NAME, mBorderSize );
171
172   actor.AddRenderer( mImpl->mRenderer );
173 }
174
175 void BorderVisual::DoCreatePropertyMap( Property::Map& map ) const
176 {
177   map.Clear();
178   map.Insert( VisualProperty::TYPE, Toolkit::Visual::BORDER );
179   map.Insert( Toolkit::BorderVisual::Property::COLOR, mBorderColor );
180   map.Insert( Toolkit::BorderVisual::Property::SIZE, mBorderSize );
181   map.Insert( Toolkit::BorderVisual::Property::ANTI_ALIASING, mAntiAliasing );
182 }
183
184 void BorderVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue )
185 {
186   // TODO
187 }
188
189 Dali::Property::Value BorderVisual::DoGetProperty( Dali::Property::Index index )
190 {
191   // TODO
192   return Dali::Property::Value();
193 }
194
195 void BorderVisual::OnSetTransform()
196 {
197   if( mImpl->mRenderer )
198   {
199     mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
200   }
201 }
202
203 void BorderVisual::InitializeRenderer()
204 {
205   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::BORDER_GEOMETRY );
206   if( !geometry )
207   {
208     geometry =  CreateBorderGeometry();
209     mFactoryCache.SaveGeometry( VisualFactoryCache::BORDER_GEOMETRY, geometry );
210   }
211
212
213   Shader shader = GetBorderShader();
214   mImpl->mRenderer = Renderer::New( geometry, shader  );
215
216   //Register transform properties
217   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
218
219 }
220
221 void BorderVisual::SetBorderColor(const Vector4& color)
222 {
223   mBorderColor = color;
224
225   if( mImpl->mRenderer )
226   {
227     (mImpl->mRenderer).SetProperty( mBorderColorIndex, color );
228     if( color.a < 1.f )
229     {
230       mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
231     }
232   }
233 }
234
235 void BorderVisual::SetBorderSize( float size )
236 {
237   mBorderSize = size;
238
239   if( mImpl->mRenderer )
240   {
241     (mImpl->mRenderer).SetProperty( mBorderSizeIndex, size );
242   }
243 }
244
245 void BorderVisual::RequireAntiAliasing( bool antiAliasing )
246 {
247   if( mAntiAliasing != antiAliasing )
248   {
249     mAntiAliasing = antiAliasing;
250     if( mImpl->mRenderer )
251     {
252       Shader borderShader( GetBorderShader() );
253       mImpl->mRenderer.SetShader( borderShader );
254       if( mAntiAliasing )
255       {
256         mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
257       }
258     }
259   }
260 }
261
262 Shader BorderVisual::GetBorderShader()
263 {
264   Shader shader;
265   if( mAntiAliasing )
266   {
267     shader = mFactoryCache.GetShader( VisualFactoryCache::BORDER_SHADER_ANTI_ALIASING );
268     if( !shader )
269     {
270       shader = Shader::New( VERTEX_SHADER_ANTI_ALIASING, FRAGMENT_SHADER_ANTI_ALIASING );
271       mFactoryCache.SaveShader( VisualFactoryCache::BORDER_SHADER_ANTI_ALIASING, shader );
272     }
273   }
274   else
275   {
276     shader = mFactoryCache.GetShader( VisualFactoryCache::BORDER_SHADER );
277     if( !shader )
278     {
279       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
280       mFactoryCache.SaveShader( VisualFactoryCache::BORDER_SHADER, shader );
281     }
282   }
283
284   return shader;
285 }
286
287 /**
288  * Vertices and triangles of the border geometry:
289  *
290  * vertex position = aPosition*uSize.xy + aDrift*uBorderSize;
291  *
292  * 0--1--2--3
293  * |\ | /| /|
294  * | \|/ |/ |
295  * 4--5--6--7
296  * |\ |  |\ |
297  * | \|  | \|
298  * 8--9--10-11
299  * | /| /|\ |
300  * |/ |/ | \|
301  * 12-13-14-15
302  */
303 Geometry BorderVisual::CreateBorderGeometry()
304 {
305   const float halfWidth = 0.5f;
306   const float halfHeight = 0.5f;
307   struct BorderVertex { Vector2 position; Vector2 drift;};
308   BorderVertex borderVertexData[16] =
309   {
310       { Vector2(-halfWidth, -halfHeight), Vector2(0.f, 0.f) },
311       { Vector2(-halfWidth, -halfHeight), Vector2(1.f, 0.f) },
312       { Vector2(halfWidth, -halfHeight),  Vector2(-1.f, 0.f) },
313       { Vector2(halfWidth, -halfHeight),  Vector2(0.f, 0.f) },
314
315       { Vector2(-halfWidth, -halfHeight), Vector2(0.f, 1.f) },
316       { Vector2(-halfWidth, -halfHeight), Vector2(1.f, 1.f) },
317       { Vector2(halfWidth, -halfHeight),  Vector2(-1.f, 1.f) },
318       { Vector2(halfWidth, -halfHeight),  Vector2(0.f, 1.f) },
319
320       { Vector2(-halfWidth, halfHeight), Vector2(0.f, -1.f) },
321       { Vector2(-halfWidth, halfHeight), Vector2(1.f, -1.f) },
322       { Vector2(halfWidth, halfHeight),  Vector2(-1.f, -1.f) },
323       { Vector2(halfWidth, halfHeight),  Vector2(0.f, -1.f) },
324
325       { Vector2(-halfWidth, halfHeight), Vector2(0.f, 0.f) },
326       { Vector2(-halfWidth, halfHeight), Vector2(1.f, 0.f) },
327       { Vector2(halfWidth, halfHeight),  Vector2(-1.f, 0.f) },
328       { Vector2(halfWidth, halfHeight),  Vector2(0.f, 0.f) },
329   };
330
331   Property::Map borderVertexFormat;
332   borderVertexFormat[POSITION_ATTRIBUTE_NAME] = Property::VECTOR2;
333   borderVertexFormat[DRIFT_ATTRIBUTE_NAME] = Property::VECTOR2;
334   PropertyBuffer borderVertices = PropertyBuffer::New( borderVertexFormat );
335   borderVertices.SetData( borderVertexData, 16 );
336
337   // Create indices
338   unsigned short indexData[24] = { 1,5,2,6,3,7,7,6,11,10,15,14,14,10,13,9,12,8,8,9,4,5,0,1};
339
340   // Create the geometry object
341   Geometry geometry = Geometry::New();
342   geometry.AddVertexBuffer( borderVertices );
343   geometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0]) );
344   geometry.SetType( Geometry::TRIANGLE_STRIP );
345
346   return geometry;
347 }
348
349 } // namespace Internal
350
351 } // namespace Toolkit
352
353 } // namespace Dali