Add 'ExclusiveArch: armv7l' limit build to arm architecture
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / public-api / shader-effects / displacement-effect.cpp
1 //
2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
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 #include <dali-toolkit/public-api/shader-effects/displacement-effect.h>
18 namespace Dali
19 {
20
21 namespace Toolkit
22 {
23
24 namespace
25 {
26
27 const std::string DISPLACEMENT_EFFECT_LIGHT_DIRECTION_PROPERTY_NAME( "uLightDirection" );
28 const std::string DISPLACEMENT_EFFECT_AMBIENT_LIGHT_COLOR_PROPERTY_NAME( "uAmbientLightColor" );
29 const std::string DISPLACEMENT_EFFECT_DIFFUSE_LIGHT_COLOR_PROPERTY_NAME( "uDiffuseLightColor" );
30 const std::string DISPLACEMENT_EFFECT_LIGHT_MULTIPLIER_PROPERTY_NAME( "uLightMultiplier" );
31 const std::string DISPLACEMENT_EFFECT_STATE_PROPERTY_NAME( "uState" );
32 const std::string DISPLACEMENT_EFFECT_HEIGHT_SCALE_PROPERTY_NAME( "uHightScale" );
33 const std::string DISPLACEMENT_EFFECT_FIXED_NORMAL_PROPERTY_NAME( "uFixedNormal" );
34
35 // factors that scale the look, defaults
36 const Vector3 DISPLACEMENT_EFFECT_LIGHT_DIRECTION_DEFAULT = Vector3(0.0, 0.7070168f, 0.7071068f);
37 const Vector3 DISPLACEMENT_EFFECT_AMBIENT_LIGHT_COLOR_DEFAULT = Vector3(0.15f, 0.15f, 0.15f);
38 const Vector3 DISPLACEMENT_EFFECT_DIFFUSE_LIGHT_COLOR_DEFAULT = Vector3(1.0f, 1.0f, 1.0f);
39 const float   DISPLACEMENT_EFFECT_LIGHT_MULTIPLIER_DEFAULT = 1.0f;
40 const float   DISPLACEMENT_EFFECT_STATE_DEFAULT = 0.0f;
41 const float   DISPLACEMENT_EFFECT_HEIGHT_SCALE_DEFAULT = 0.1f;
42 const Vector3 DISPLACEMENT_EFFECT_FIXED_NORMAL_DEFAULT = Vector3(0.0f, 0.0f, 1.0f);
43
44 } // namespace
45
46
47 ////////////////////////////////////////////////////
48 //
49 // Soft button shader / actor tweaking parameters
50 //
51
52
53 DisplacementEffect::DisplacementEffect()
54 {
55 }
56
57 //Call the Parent copy constructor to add reference to the implementation for this object
58 DisplacementEffect::DisplacementEffect(ShaderEffect handle)
59 :ShaderEffect(handle)
60 {
61 }
62
63 DisplacementEffect::~DisplacementEffect()
64 {
65 }
66
67 DisplacementEffect DisplacementEffect::New(Type type)
68 {
69
70   std::string fragmentSourceFixed;
71   fragmentSourceFixed =  "precision mediump float;\n"
72     "uniform vec3 uLightDirection;\n"
73     "uniform vec3 uAmbientLightColor;\n"
74     "uniform vec3 uDiffuseLightColor;\n"
75     "uniform float uLightMultiplier;\n"
76     "uniform float uState;\n"
77     "uniform float uHightScale;\n"
78     "uniform vec3 uFixedNormal;\n"
79
80     "void main()\n"
81     "{\n"
82     "   vec4 col = texture2D(sTexture, vTexCoord);\n"
83     // calc lighting
84     "  float intensity = dot(uLightDirection, uFixedNormal);"
85     "  vec3 lighting = (intensity * uDiffuseLightColor) + uAmbientLightColor;\n"
86     "  lighting *= uLightMultiplier;\n"
87     // output col = image * light
88     "  gl_FragColor = vec4(col.rgb * lighting * uColor.rgb, col.a * uColor.a);\n"
89     "}\n";
90
91
92
93   std::string fragmentSourceDisplaced(
94       "precision mediump float;\n"
95       "uniform vec3 uLightDirection;\n"
96       "uniform vec3 uAmbientLightColor;\n"
97       "uniform vec3 uDiffuseLightColor;\n"
98       "uniform float uLightMultiplier;\n"
99       "uniform float uState;\n"
100       "uniform float uHightScale;\n"
101       "void main()\n"
102       "{\n"
103       "  highp vec4 displacementMap1 = texture2D(sEffect, vec2(vTexCoord.s, vTexCoord.t/2.0));\n"
104       "  highp vec4 displacementMap2 = texture2D(sEffect, vec2(vTexCoord.s, 0.5+vTexCoord.t/2.0));\n"
105       "  highp vec4 displacementMap = mix(displacementMap1, displacementMap2, uState);\n"
106
107       "  vec3 normalAdjusted = normalize(displacementMap.rgb*2.0-1.0);\n"
108       "  float height = uHightScale * (displacementMap.a*2.0 - 1.0);\n"
109       "  vec2 displacement = vec2(0.0);\n"
110       "  displacement += (vec2(0.5)-vTexCoord.st)*height;\n"
111       "  vec2 newCoord = vTexCoord.st + displacement.xy;\n"
112
113       "  vec4 col = texture2D(sTexture, newCoord);\n"
114       // Y-Axis for the normal map is taken as in Y-Down format, So inverting it for GL
115       "  float intensity = dot(uLightDirection, vec3(1.0,-1.0, 1.0) * normalAdjusted);"
116       "  vec3 lighting = (intensity * uDiffuseLightColor) + uAmbientLightColor;\n"
117       "  lighting *= uLightMultiplier;\n"
118       "  vec3 color = col.rgb * lighting * uColor.rgb;\n"
119       "  gl_FragColor = vec4(color, col.a * uColor.a);\n"
120       "}\n");
121
122   //////////////////////////////////////
123   // Create shader effect
124   //
125   //
126
127   ShaderEffect shader;
128   switch(type)
129   {
130     case DISPLACED:
131       shader = ShaderEffect::New( "", fragmentSourceDisplaced);
132       break;
133
134     case FIXED:
135     default:
136       shader = ShaderEffect::New( "", fragmentSourceFixed);
137       break;
138   }
139   DisplacementEffect handle( shader );
140
141
142   //////////////////////////////////////
143   // Register uniform properties
144   //
145   //
146   // factors that scale the look, defaults
147
148   handle.SetLightDirection(DISPLACEMENT_EFFECT_LIGHT_DIRECTION_DEFAULT);
149   handle.SetAmbientLightColorProperty(DISPLACEMENT_EFFECT_AMBIENT_LIGHT_COLOR_DEFAULT);
150   handle.SetDiffuseLightColorProperty(DISPLACEMENT_EFFECT_DIFFUSE_LIGHT_COLOR_DEFAULT);
151   handle.SetLightingMultiplierProperty(DISPLACEMENT_EFFECT_LIGHT_MULTIPLIER_DEFAULT);
152   handle.SetStateProperty(DISPLACEMENT_EFFECT_STATE_DEFAULT);
153   handle.SetHeightScaleProperty(DISPLACEMENT_EFFECT_HEIGHT_SCALE_DEFAULT);
154
155   if(type == FIXED)
156   {
157     handle.SetFixedNormalProperty(DISPLACEMENT_EFFECT_FIXED_NORMAL_DEFAULT);
158   }
159
160
161   return handle;
162 }
163
164 const std::string& DisplacementEffect::GetLightDirectionPropertyName() const
165 {
166   return DISPLACEMENT_EFFECT_LIGHT_DIRECTION_PROPERTY_NAME;
167 }
168
169 const std::string& DisplacementEffect::GetAmbientLightColorPropertyName() const
170 {
171   return DISPLACEMENT_EFFECT_AMBIENT_LIGHT_COLOR_PROPERTY_NAME;
172 }
173
174 const std::string& DisplacementEffect::GetDiffuseLightColorPropertyName() const
175 {
176   return DISPLACEMENT_EFFECT_DIFFUSE_LIGHT_COLOR_PROPERTY_NAME;
177 }
178
179 const std::string& DisplacementEffect::GetLightingMultiplierPropertyName() const
180 {
181   return DISPLACEMENT_EFFECT_LIGHT_MULTIPLIER_PROPERTY_NAME;
182 }
183
184 const std::string& DisplacementEffect::GetStatePropertyName() const
185 {
186   return DISPLACEMENT_EFFECT_STATE_PROPERTY_NAME;
187 }
188
189 const std::string& DisplacementEffect::GetHeightScalePropertyName() const
190 {
191   return DISPLACEMENT_EFFECT_HEIGHT_SCALE_PROPERTY_NAME;
192 }
193
194 const std::string& DisplacementEffect::GetFixedNormalPropertyName() const
195 {
196   return DISPLACEMENT_EFFECT_FIXED_NORMAL_PROPERTY_NAME;
197 }
198
199 void DisplacementEffect::SetLightDirection(const Vector3 lightDirection)
200 {
201   SetUniform( DISPLACEMENT_EFFECT_LIGHT_DIRECTION_PROPERTY_NAME, lightDirection);
202 }
203
204 void DisplacementEffect::SetAmbientLightColorProperty(const Vector3 ambientLight)
205 {
206   SetUniform( DISPLACEMENT_EFFECT_AMBIENT_LIGHT_COLOR_PROPERTY_NAME, ambientLight);
207 }
208
209 void DisplacementEffect::SetDiffuseLightColorProperty(const Vector3 diffuseLight)
210 {
211   SetUniform( DISPLACEMENT_EFFECT_DIFFUSE_LIGHT_COLOR_PROPERTY_NAME, diffuseLight);
212 }
213
214 void DisplacementEffect::SetLightingMultiplierProperty(const float lightMultiplier)
215 {
216   SetUniform( DISPLACEMENT_EFFECT_LIGHT_MULTIPLIER_PROPERTY_NAME, lightMultiplier);
217 }
218
219 void DisplacementEffect::SetStateProperty(const float state)
220 {
221   SetUniform( DISPLACEMENT_EFFECT_STATE_PROPERTY_NAME, state);
222 }
223
224 void DisplacementEffect::SetHeightScaleProperty(const float heightScale)
225 {
226   SetUniform( DISPLACEMENT_EFFECT_HEIGHT_SCALE_PROPERTY_NAME, heightScale);
227 }
228
229 void DisplacementEffect::SetFixedNormalProperty(const Vector3 fixedNormal)
230 {
231   Vector3 newFixedNormal(fixedNormal);
232   newFixedNormal.Normalize();
233
234   SetUniform( DISPLACEMENT_EFFECT_FIXED_NORMAL_PROPERTY_NAME, newFixedNormal);
235 }
236
237 }
238
239 }
240