optional/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