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