[dali_1.2.23] Merge branch 'devel/master'
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / wireframe / wireframe-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
19 // CLASS HEADER
20 #include "wireframe-visual.h"
21
22 // INTERNAL INCLUDES
23 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
24 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
25 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
26 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
27 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
28
29 namespace Dali
30 {
31
32 namespace Toolkit
33 {
34
35 namespace Internal
36 {
37
38 namespace
39 {
40 const char * const POSITION_ATTRIBUTE_NAME("aPosition");
41 const char * const INDEX_NAME("indices");
42
43 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
44 attribute mediump vec2  aPosition;\n
45 uniform   mediump mat4  uMvpMatrix;\n
46 uniform   mediump vec3  uSize;\n
47 \n
48
49 //Visual size and offset
50 uniform mediump vec2 offset;\n
51 uniform mediump vec2 size;\n
52 uniform mediump vec4 offsetSizeMode;\n
53 uniform mediump vec2 origin;\n
54 uniform mediump vec2 anchorPoint;\n
55
56 vec4 ComputeVertexPosition()\n
57 {\n
58   vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
59   vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
60   return vec4( (aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
61 }\n
62
63 void main()\n
64 {\n
65   gl_Position = uMvpMatrix * ComputeVertexPosition();\n
66 }\n
67 );
68
69 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(\n
70 uniform lowp vec4 uColor;\n
71 uniform lowp vec4 mixColor;\n
72 \n
73 void main()\n
74 {\n
75   gl_FragColor = uColor*mixColor;\n
76 }\n
77 );
78
79 }
80
81 WireframeVisualPtr WireframeVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties )
82 {
83   Visual::BasePtr emtptyVisual;
84
85   return New(factoryCache, emtptyVisual, properties);
86 }
87
88 WireframeVisualPtr WireframeVisual::New( VisualFactoryCache& factoryCache, Visual::BasePtr actualVisual )
89 {
90   return new WireframeVisual( factoryCache, actualVisual );
91 }
92
93 WireframeVisualPtr WireframeVisual::New( VisualFactoryCache& factoryCache, Visual::BasePtr actualVisual, const Property::Map& properties )
94 {
95   WireframeVisualPtr wireframeVisual( new WireframeVisual( factoryCache, actualVisual ) );
96
97   // Instead of calling SetProperties, looking for the only valid property 'transform'
98   Property::Value* transformValue = properties.Find( DevelVisual::Property::TRANSFORM, TRANSFORM );
99   Property::Map transformMap;
100   if( transformValue && transformValue->Get( transformMap ) )
101   {
102     wireframeVisual->SetTransformAndSize( transformMap, Vector2::ZERO );
103   }
104
105   return wireframeVisual;
106 }
107
108 WireframeVisual::WireframeVisual( VisualFactoryCache& factoryCache, Visual::BasePtr actualVisual )
109 : Visual::Base( factoryCache ),
110   mActualVisual( actualVisual )
111 {
112 }
113
114 WireframeVisual::~WireframeVisual()
115 {
116 }
117
118 float WireframeVisual::GetHeightForWidth( float width )
119 {
120   if( mActualVisual )
121   {
122     return mActualVisual->GetHeightForWidth( width );
123   }
124   else
125   {
126     return Visual::Base::GetHeightForWidth( width );
127   }
128 }
129
130 void WireframeVisual::GetNaturalSize( Vector2& naturalSize )
131 {
132   if( mActualVisual )
133   {
134     mActualVisual->GetNaturalSize( naturalSize );
135   }
136   else
137   {
138     Visual::Base::GetNaturalSize( naturalSize );
139   }
140 }
141
142 void WireframeVisual::DoCreatePropertyMap( Property::Map& map ) const
143 {
144   if( mActualVisual )
145   {
146     mActualVisual->CreatePropertyMap( map );
147   }
148   else
149   {
150     map.Clear();
151     map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::WIREFRAME );
152   }
153 }
154
155 void WireframeVisual::DoSetProperties( const Property::Map& propertyMap )
156 {
157   Property::Value* mixValue = propertyMap.Find( Toolkit::DevelVisual::Property::MIX_COLOR, MIX_COLOR );
158   if( mixValue )
159   {
160     Vector4 mixColor;
161     mixValue->Get( mixColor );
162     SetMixColor( mixColor );
163   }
164 }
165
166 void WireframeVisual::DoSetOnStage( Actor& actor )
167 {
168   InitializeRenderer();
169
170   actor.AddRenderer( mImpl->mRenderer );
171 }
172
173 void WireframeVisual::InitializeRenderer()
174 {
175   Shader shader = mFactoryCache.GetShader( VisualFactoryCache::WIREFRAME_SHADER );
176   if( !shader )
177   {
178     shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
179     mFactoryCache.SaveShader( VisualFactoryCache::WIREFRAME_SHADER, shader );
180   }
181
182   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::WIREFRAME_GEOMETRY );
183   if( !geometry )
184   {
185     geometry = CreateQuadWireframeGeometry();
186     mFactoryCache.SaveGeometry( VisualFactoryCache::WIREFRAME_GEOMETRY, geometry );
187   }
188
189   //Create the renderer
190   mImpl->mRenderer = Renderer::New( geometry, shader);
191
192   //Register transform properties
193   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
194 }
195
196 Geometry WireframeVisual::CreateQuadWireframeGeometry()
197 {
198   const float halfWidth = 0.5f;
199   const float halfHeight = 0.5f;
200   struct QuadVertex { Vector2 position;};
201   QuadVertex quadVertexData[4] =
202   {
203       { Vector2(-halfWidth, -halfHeight) },
204       { Vector2( halfWidth, -halfHeight) },
205       { Vector2( halfWidth,  halfHeight) },
206       { Vector2(-halfWidth,  halfHeight) }
207   };
208
209   Property::Map quadVertexFormat;
210   quadVertexFormat[POSITION_ATTRIBUTE_NAME] = Property::VECTOR2;
211   PropertyBuffer quadVertices = PropertyBuffer::New( quadVertexFormat );
212   quadVertices.SetData( quadVertexData, 4 );
213
214   // Create indices
215   unsigned short indexData[10] = { 0, 1, 1, 2, 2, 3, 3, 0 };
216
217   // Create the geometry object
218   Geometry geometry = Geometry::New();
219   geometry.AddVertexBuffer( quadVertices );
220   geometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0]) );
221   geometry.SetType( Geometry::LINES );
222
223   return geometry;
224 }
225
226 void WireframeVisual::OnSetTransform()
227 {
228   if( mImpl->mRenderer )
229   {
230     //Register transform properties
231     mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
232   }
233 }
234
235 } // namespace Internal
236
237 } // namespace Toolkit
238
239 } // namespace Dali