examples/refraction-effect/refraction-effect-example.cpp

   1 /*
   2  * Copyright (c) 2014 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/dali.h>
  19 #include <dali-toolkit/dali-toolkit.h>
  20 #include "shared/view.h"
  21
  22 #include <fstream>
  23 #include <sstream>
  24
  25 using namespace Dali;
  26
  27 namespace
  28 {
  29 const char * const APPLICATION_TITLE( "Refraction Effect" );
  30 const char * const TOOLBAR_IMAGE( DALI_IMAGE_DIR "top-bar.png" );
  31 const char * const CHANGE_TEXTURE_ICON( DALI_IMAGE_DIR "icon-change.png" );
  32 const char * const CHANGE_MESH_ICON( DALI_IMAGE_DIR "icon-replace.png" );
  33
  34 const char* MESH_FILES[] =
  35 {
  36  DALI_MODEL_DIR "surface_pattern_v01.obj",
  37  DALI_MODEL_DIR "surface_pattern_v02.obj"
  38 };
  39 const unsigned int NUM_MESH_FILES( sizeof( MESH_FILES ) / sizeof( MESH_FILES[0] ) );
  40
  41 const char* TEXTURE_IMAGES[]=
  42 {
  43   DALI_IMAGE_DIR "background-1.jpg",
  44   DALI_IMAGE_DIR "background-2.jpg",
  45   DALI_IMAGE_DIR "background-3.jpg",
  46   DALI_IMAGE_DIR "background-4.jpg"
  47 };
  48 const unsigned int NUM_TEXTURE_IMAGES( sizeof( TEXTURE_IMAGES ) / sizeof( TEXTURE_IMAGES[0] ) );
  49
  50 #define MAKE_SHADER(A)#A
  51
  52 struct LightOffsetConstraint
  53 {
  54   LightOffsetConstraint( float radius )
  55   : mRadius( radius )
  56   {
  57   }
  58
  59   Vector2 operator()( const Vector2& current, const PropertyInput& spinAngleProperty)
  60   {
  61     float spinAngle = spinAngleProperty.GetFloat();
  62     return Vector2( cos(spinAngle ), sin( spinAngle ) ) * mRadius;
  63   }
  64
  65   float mRadius;
  66 };
  67
  68 /**
  69  * @brief Load an image, scaled-down to no more than the stage dimensions.
  70  *
  71  * Uses image scaling mode ImageAttributes::ScaleToFill to resize the image at
  72  * load time to cover the entire stage with pixels with no borders,
  73  * and filter mode ImageAttributes::BoxThenLinear to sample the image with
  74  * maximum quality.
  75  */
  76 ResourceImage LoadStageFillingImage( const char * const imagePath )
  77 {
  78   Size stageSize = Stage::GetCurrent().GetSize();
  79   ImageAttributes attributes;
  80   attributes.SetSize( stageSize.x, stageSize.y );
  81   attributes.SetFilterMode( ImageAttributes::BoxThenLinear );
  82   attributes.SetScalingMode( ImageAttributes::ScaleToFill );
  83   return ResourceImage::New( imagePath, attributes );
  84 }
  85
  86 } // namespace
  87
  88 /************************************************************************************************
  89  *** This shader is used when the MeshActor is not touched***
  90  ************************************************************************************************/
  91 class NoEffect : public ShaderEffect
  92 {
  93 public:
  94   /**
  95    * Create an empty handle.
  96    */
  97   NoEffect()
  98   {
  99   }
 100
 101   /**
 102    * Virtual destructor
 103    */
 104   virtual ~NoEffect()
 105   {
 106   }
 107
 108   /**
 109    * Create a NoEffect object.
 110    * @return A handle to a newly allocated NoEffect
 111    */
 112   static NoEffect New()
 113   {
 114     std::string vertexShader = MAKE_SHADER(
 115         precision mediump float;\n
 116         uniform mediump vec4 uTextureRect;\n
 117         void main()\n
 118         {\n
 119           gl_Position = uMvpMatrix * vec4( aPosition.xy, 0.0, 1.0 );\n
 120           vTexCoord = aTexCoord.xy;\n
 121         }\n
 122     );
 123     std::string fragmentShader = MAKE_SHADER(
 124         precision mediump float;\n
 125         void main()\n
 126         {\n
 127           gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
 128         }\n
 129     );
 130     ShaderEffect shaderEffect = ShaderEffect::New( vertexShader, fragmentShader,
 131                                                    GeometryType( GEOMETRY_TYPE_TEXTURED_MESH),
 132                                                    ShaderEffect::GeometryHints( ShaderEffect::HINT_NONE ) );
 133     NoEffect handle( shaderEffect );
 134     return handle;
 135   }
 136
 137 private:
 138   /**
 139    * Helper for New()
 140    */
 141   NoEffect( ShaderEffect handle )
 142   : ShaderEffect( handle )
 143   {
 144   }
 145 };
 146
 147 /************************************************************/
 148 /* Custom refraction effect shader******************************/
 149 /************************************************************/
 150
 151 class RefractionEffect : public ShaderEffect
 152 {
 153 public:
 154
 155   /**
 156    * Create an empty RefractionEffect handle.
 157    */
 158   RefractionEffect()
 159   {
 160   }
 161
 162   /**
 163    * Virtual destructor
 164    */
 165   virtual ~RefractionEffect()
 166   {
 167   }
 168
 169   /**
 170    * Create a RefractionEffect object.
 171    * @return A handle to a newly allocated RefractionEffect
 172    */
 173   static RefractionEffect New()
 174   {
 175     std::string vertexShader = MAKE_SHADER(
 176       precision mediump float;\n
 177       varying mediump vec2 vTextureOffset;\n
 178       void main()\n
 179       {\n
 180         gl_Position = uMvpMatrix * vec4( aPosition.xy, 0.0, 1.0 );\n
 181         vTexCoord = aTexCoord.xy;\n
 182
 183         vNormal = aNormal;\n
 184         vVertex = vec4( aPosition, 1.0 );\n
 185         float length = max(0.01, length(aNormal.xy)) * 40.0;\n
 186         vTextureOffset = aNormal.xy / length;\n
 187       }\n
 188     );
 189
 190     std::string fragmentShader = MAKE_SHADER(
 191       precision mediump float;\n
 192       uniform mediump float uEffectStrength;\n
 193       uniform mediump vec3 uLightPosition;\n
 194       uniform mediump vec2 uLightXYOffset;\n
 195       uniform mediump vec2 uLightSpinOffset;\n
 196       uniform mediump float uLightIntensity;\n
 197       varying mediump vec2 vTextureOffset;\n
 198
 199       vec3 rgb2hsl(vec3 rgb)\n
 200       {\n
 201         float epsilon = 1.0e-10;\n
 202         vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n
 203         vec4 P = mix(vec4(rgb.bg, K.wz), vec4(rgb.gb, K.xy), step(rgb.b, rgb.g));\n
 204         vec4 Q = mix(vec4(P.xyw, rgb.r), vec4(rgb.r, P.yzx), step(P.x, rgb.r));\n
 205         \n
 206         // RGB -> HCV
 207         float value = Q.x;\n
 208         float chroma = Q.x - min(Q.w, Q.y);\n
 209         float hue = abs(Q.z + (Q.w-Q.y) / (6.0*chroma+epsilon));\n
 210         // HCV -> HSL
 211         float lightness = value - chroma*0.5;\n
 212         return vec3( hue, chroma/max( 1.0-abs(lightness*2.0-1.0), 1.0e-1 ), lightness );\n
 213       }\n
 214
 215       vec3 hsl2rgb( vec3 hsl )
 216       {
 217         // pure hue->RGB
 218         vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n
 219         vec3 p = abs(fract(hsl.xxx + K.xyz) * 6.0 - K.www);\n
 220         vec3 RGB = clamp(p - K.xxx, 0.0, 1.0);\n
 221         \n
 222         float chroma = ( 1.0 - abs( hsl.z*2.0-1.0 ) ) * hsl.y;\n
 223         return ( RGB - 0.5 ) * chroma + hsl.z;
 224       }
 225
 226       void main()\n
 227       {\n
 228         vec3 normal = normalize( vNormal);\n
 229
 230         vec3 lightPosition = uLightPosition + vec3(uLightXYOffset+uLightSpinOffset, 0.0);\n
 231         mediump vec3 vecToLight = normalize( (lightPosition - vVertex.xyz) * 0.01 );\n
 232         mediump float spotEffect = pow( max(0.05, vecToLight.z ) - 0.05, 8.0);\n
 233
 234         spotEffect = spotEffect * uEffectStrength;\n
 235         mediump float lightDiffuse = ( ( dot( vecToLight, normal )-0.75 ) *uLightIntensity  ) * spotEffect;\n
 236
 237         lowp vec4 color = texture2D( sTexture, vTexCoord + vTextureOffset * spotEffect );\n
 238         vec3 lightedColor =  hsl2rgb( rgb2hsl(color.rgb) + vec3(0.0,0.0,lightDiffuse) );\n
 239
 240         gl_FragColor = vec4( lightedColor, color.a ) * uColor;\n
 241       }\n
 242     );
 243
 244     ShaderEffect shaderEffect = ShaderEffect::New( vertexShader, fragmentShader,
 245                                                    GeometryType( GEOMETRY_TYPE_TEXTURED_MESH),
 246                                                    ShaderEffect::GeometryHints( ShaderEffect::HINT_BLENDING ) );
 247     RefractionEffect handle( shaderEffect );
 248
 249     Vector2 stageSize = Stage::GetCurrent().GetSize();
 250     handle.SetLightPosition( Vector2(stageSize.x, 0.f) );
 251     handle.SetUniform( "uLightXYOffset",  Vector2::ZERO );
 252     handle.SetUniform( "uLightSpinOffset",  Vector2::ZERO );
 253     handle.SetUniform( "uEffectStrength", 0.f );
 254     handle.SetUniform( "uLightIntensity",  2.5f );
 255
 256     Dali::Property::Index index = handle.RegisterProperty( "uSpinAngle", 0.f );
 257     Constraint constraint = Constraint::New<Vector2>( handle.GetPropertyIndex("uLightSpinOffset"),
 258                                                       LocalSource(index),
 259                                                       LightOffsetConstraint(stageSize.x*0.1f));
 260     handle.ApplyConstraint( constraint );
 261
 262     return handle;
 263   }
 264
 265   void SetLightPosition( const Vector2& position )
 266   {
 267     Vector2 stageHalfSize = Stage::GetCurrent().GetSize() * 0.5f;
 268     SetUniform( "uLightPosition", Vector3( position.x - stageHalfSize.x, position.y - stageHalfSize.y, stageHalfSize.x ) );
 269   }
 270
 271   void SetLightXYOffset( const Vector2& offset )
 272   {
 273     SetUniform( "uLightXYOffset",  offset );
 274   }
 275
 276   void SetEffectStrength( float strength )
 277   {
 278     SetUniform( "uEffectStrength", strength );
 279   }
 280
 281   void SetLightIntensity( float intensity )
 282   {
 283     SetUniform( "uLightIntensity", intensity );
 284   }
 285
 286 private:
 287   /**
 288    * Helper for New()
 289    */
 290   RefractionEffect( ShaderEffect handle )
 291   : ShaderEffect( handle )
 292   {
 293   }
 294 };
 295
 296 /*************************************************/
 297 /*Demo using RefractionEffect*****************/
 298 /*************************************************/
 299 class RefractionEffectExample : public ConnectionTracker
 300 {
 301 public:
 302   RefractionEffectExample( Application &application )
 303   : mApplication( application ),
 304     mIsDown( false ),
 305     mCurrentTextureId( 1 ),
 306     mCurrentMeshId( 0 )
 307   {
 308     // Connect to the Application's Init signal
 309     application.InitSignal().Connect(this, &RefractionEffectExample::Create);
 310   }
 311
 312   ~RefractionEffectExample()
 313   {
 314   }
 315
 316 private:
 317
 318   // The Init signal is received once (only) during the Application lifetime
 319   void Create(Application& application)
 320   {
 321     Stage stage = Stage::GetCurrent();
 322     mStageHalfSize = stage.GetSize() * 0.5f;
 323
 324     stage.KeyEventSignal().Connect(this, &RefractionEffectExample::OnKeyEvent);
 325
 326     // Creates a default view with a default tool bar.
 327     // The view is added to the stage.
 328     Toolkit::ToolBar toolBar;
 329     Toolkit::View    view;
 330     mContent = DemoHelper::CreateView( application,
 331         view,
 332         toolBar,
 333         "",
 334         TOOLBAR_IMAGE,
 335         APPLICATION_TITLE );
 336
 337     // Add a button to change background. (right of toolbar)
 338     mChangeTextureButton = Toolkit::PushButton::New();
 339     mChangeTextureButton.SetBackgroundImage( ResourceImage::New( CHANGE_TEXTURE_ICON ) );
 340     mChangeTextureButton.ClickedSignal().Connect( this, &RefractionEffectExample::OnChangeTexture );
 341     toolBar.AddControl( mChangeTextureButton,
 342                         DemoHelper::DEFAULT_VIEW_STYLE.mToolBarButtonPercentage,
 343                         Toolkit::Alignment::HorizontalRight,
 344                         DemoHelper::DEFAULT_MODE_SWITCH_PADDING  );
 345     // Add a button to change mesh pattern. ( left of bar )
 346     mChangeMeshButton = Toolkit::PushButton::New();
 347     mChangeMeshButton.SetBackgroundImage( ResourceImage::New( CHANGE_MESH_ICON ) );
 348     mChangeMeshButton.ClickedSignal().Connect( this, &RefractionEffectExample::OnChangeMesh );
 349     toolBar.AddControl( mChangeMeshButton,
 350                         DemoHelper::DEFAULT_VIEW_STYLE.mToolBarButtonPercentage,
 351                         Toolkit::Alignment::HorizontalLeft,
 352                         DemoHelper::DEFAULT_MODE_SWITCH_PADDING  );
 353
 354     // creates the shader effects applied on the mesh actor
 355     mRefractionEffect = RefractionEffect::New(); // used when the finger is touching the screen
 356     mNoEffect = NoEffect::New(); // used in the other situations, basic render shader
 357     // Create the mesh from the obj file and add to stage
 358     mMaterial =  Material::New( "Material" ) ;
 359     mMaterial.SetDiffuseTexture( LoadStageFillingImage( TEXTURE_IMAGES[mCurrentTextureId] ) );
 360     CreateSurface( MESH_FILES[mCurrentMeshId] );
 361
 362     // Connect the callback to the touch signal on the mesh actor
 363     mContent.TouchedSignal().Connect( this, &RefractionEffectExample::OnTouch );
 364
 365     // the animation which spin the light around the finger touch position
 366     mLightPosition = Vector2( mStageHalfSize.x*2.f, 0.f);
 367     mLightAnimation = Animation::New(2.f);
 368     mLightAnimation.AnimateTo( Property( mRefractionEffect, "uSpinAngle" ), Math::PI*2.f );
 369     mLightAnimation.SetLooping( true );
 370     mLightAnimation.Pause();
 371   }
 372
 373   /**
 374    * Create a mesh actor with different geometry to replace the current one
 375    */
 376   bool OnChangeMesh( Toolkit::Button button  )
 377   {
 378     if( mMeshActor )
 379     {
 380       UnparentAndReset( mMeshActor );
 381     }
 382
 383     mCurrentMeshId = ( mCurrentMeshId + 1 ) % NUM_MESH_FILES;
 384     CreateSurface( MESH_FILES[mCurrentMeshId] );
 385
 386     return true;
 387   }
 388
 389   bool OnChangeTexture( Toolkit::Button button )
 390   {
 391     mCurrentTextureId = ( mCurrentTextureId + 1 ) % NUM_TEXTURE_IMAGES;
 392     mMaterial.SetDiffuseTexture( LoadStageFillingImage( TEXTURE_IMAGES[mCurrentTextureId] ) );
 393
 394     return true;
 395   }
 396
 397   bool OnTouch( Actor actor , const TouchEvent& event )
 398   {
 399     const TouchPoint &point = event.GetPoint(0);
 400
 401     switch(point.state)
 402     {
 403       case TouchPoint::Down:
 404       {
 405         mIsDown = true;
 406         mDownPosition = point.screen;
 407
 408         mLightAnimation.Play();
 409
 410         if( mStrenghAnimation )
 411         {
 412           mStrenghAnimation.Clear();
 413         }
 414
 415         mRefractionEffect.SetLightXYOffset( point.screen - mLightPosition );
 416         mMeshActor.SetShaderEffect( mRefractionEffect );
 417         mStrenghAnimation= Animation::New(0.5f);
 418         mStrenghAnimation.AnimateTo( Property( mRefractionEffect, "uEffectStrength" ), 1.f );
 419         mStrenghAnimation.Play();
 420
 421         break;
 422       }
 423       case TouchPoint::Motion:
 424       {
 425         if(mIsDown)
 426         {
 427           // make the light position following the finger movement
 428           mRefractionEffect.SetLightXYOffset( point.screen - mLightPosition );
 429         }
 430         break;
 431       }
 432       case TouchPoint::Up:
 433       case TouchPoint::Leave:
 434       case TouchPoint::Interrupted:
 435       {
 436         if(mIsDown)
 437         {
 438           mLightAnimation.Pause();
 439
 440           if( mStrenghAnimation )
 441           {
 442             mStrenghAnimation.Clear();
 443           }
 444           mStrenghAnimation = Animation::New(0.5f);
 445           mStrenghAnimation.AnimateTo( Property( mRefractionEffect, "uEffectStrength" ), 0.f );
 446           mStrenghAnimation.FinishedSignal().Connect( this, &RefractionEffectExample::OnTouchFinished );
 447           mStrenghAnimation.Play();
 448         }
 449
 450         mIsDown = false;
 451         break;
 452       }
 453       case TouchPoint::Stationary:
 454       case TouchPoint::Last:
 455       default:
 456       {
 457         break;
 458       }
 459     }
 460     return true;
 461   }
 462
 463   void OnTouchFinished( Animation& source )
 464   {
 465     mMeshActor.SetShaderEffect( mNoEffect );
 466     mRefractionEffect.SetLightXYOffset( Vector2::ZERO );
 467   }
 468
 469   void CreateSurface( const std::string& objFileName )
 470   {
 471     MeshData::VertexContainer    vertices;
 472     MeshData::FaceIndices        faces;
 473     MeshData                     meshData;
 474
 475     std::vector<float> boundingBox;
 476     std::vector<Vector3> vertexPositions;
 477     std::vector<int> faceIndices;
 478     // read the vertice and faces from the .obj file, and record the bounding box
 479     ReadObjFile( objFileName, boundingBox, vertexPositions, faceIndices );
 480
 481     std::vector<Vector2> textureCoordinates;
 482     // align the mesh, scale it to fit the screen size, and calculate the texture coordinate for each vertex
 483     ShapeResizeAndTexureCoordinateCalculation( boundingBox, vertexPositions, textureCoordinates );
 484
 485     // re-organize the mesh, the vertices are duplicated, each vertex only belongs to one triangle.
 486     // Without sharing vertex between triangle, so we can manipulate the texture offset on each triangle conveniently.
 487     for( std::size_t i=0; i<faceIndices.size(); i=i+3 )
 488     {
 489       Vector3 edge1 = vertexPositions[ faceIndices[i+2] ] - vertexPositions[ faceIndices[i] ];
 490       Vector3 edge2 = vertexPositions[ faceIndices[i+1] ] - vertexPositions[ faceIndices[i] ];
 491       Vector3 normal = edge1.Cross(edge2);
 492       normal.Normalize();
 493
 494       if( normal.z > 0 )
 495       {
 496         faces.push_back( i );
 497         faces.push_back( i+1 );
 498         faces.push_back( i+2 );
 499       }
 500       else
 501       {
 502         normal *= -1.f;
 503         faces.push_back( i );
 504         faces.push_back( i+2 );
 505         faces.push_back( i+1 );
 506       }
 507
 508       vertices.push_back( MeshData::Vertex( vertexPositions[ faceIndices[i] ], textureCoordinates[ faceIndices[i] ], normal ) );
 509       vertices.push_back( MeshData::Vertex( vertexPositions[ faceIndices[i+1] ], textureCoordinates[ faceIndices[i+1] ], normal ) );
 510       vertices.push_back( MeshData::Vertex( vertexPositions[ faceIndices[i+2] ], textureCoordinates[ faceIndices[i+2] ], normal ) );
 511
 512     }
 513
 514     // Now ready to construct the mesh actor
 515     meshData.SetMaterial( mMaterial );
 516     meshData.SetVertices( vertices );
 517     meshData.SetFaceIndices( faces );
 518     meshData.SetHasTextureCoords(true);
 519     meshData.SetHasNormals(true);
 520     mMeshActor = MeshActor::New( Mesh::New( meshData ) );
 521     mMeshActor.SetParentOrigin(ParentOrigin::CENTER);
 522     mMeshActor.SetShaderEffect( mNoEffect );
 523     mContent.Add( mMeshActor );
 524   }
 525
 526   void ReadObjFile( const std::string& objFileName,
 527       std::vector<float>& boundingBox,
 528       std::vector<Vector3>& vertexPositions,
 529       std::vector<int>& faceIndices)
 530   {
 531     std::ifstream ifs( objFileName.c_str(), std::ios::in );
 532
 533     boundingBox.resize( 6 );
 534     boundingBox[0]=boundingBox[2]=boundingBox[4] = std::numeric_limits<float>::max();
 535     boundingBox[1]=boundingBox[3]=boundingBox[5] = -std::numeric_limits<float>::max();
 536
 537     std::string line;
 538     while( std::getline( ifs, line ) )
 539     {
 540       if( line[0] == 'v' && std::isspace(line[1]))  // vertex
 541       {
 542         std::istringstream iss(line.substr(2), std::istringstream::in);
 543         unsigned int i = 0;
 544         Vector3 vertex;
 545         while( iss >> vertex[i++] && i < 3);
 546         if( vertex.x < boundingBox[0] )  boundingBox[0] = vertex.x;
 547         if( vertex.x > boundingBox[1] )  boundingBox[1] = vertex.x;
 548         if( vertex.y < boundingBox[2] )  boundingBox[2] = vertex.y;
 549         if( vertex.y > boundingBox[3] )  boundingBox[3] = vertex.y;
 550         if( vertex.z < boundingBox[4] )  boundingBox[4] = vertex.z;
 551         if( vertex.z > boundingBox[5] )  boundingBox[5] = vertex.z;
 552         vertexPositions.push_back( vertex );
 553       }
 554       else if( line[0] == 'f' ) //face
 555       {
 556         unsigned int numOfInt = 3;
 557         while( true )
 558         {
 559           std::size_t found  = line.find('/');
 560           if( found == std::string::npos )
 561           {
 562             break;
 563           }
 564           line[found] = ' ';
 565           numOfInt++;
 566         }
 567
 568         std::istringstream iss(line.substr(2), std::istringstream::in);
 569         int indices[ numOfInt ];
 570         unsigned int i=0;
 571         while( iss >> indices[i++] && i < numOfInt);
 572         unsigned int step = (i+1) / 3;
 573         faceIndices.push_back( indices[0]-1 );
 574         faceIndices.push_back( indices[step]-1 );
 575         faceIndices.push_back( indices[2*step]-1 );
 576       }
 577     }
 578
 579     ifs.close();
 580   }
 581
 582   void ShapeResizeAndTexureCoordinateCalculation( const std::vector<float>& boundingBox,
 583       std::vector<Vector3>& vertexPositions,
 584       std::vector<Vector2>& textureCoordinates)
 585   {
 586     Vector3 bBoxSize( boundingBox[1] - boundingBox[0], boundingBox[3] - boundingBox[2], boundingBox[5] - boundingBox[4]);
 587     Vector3 bBoxMinCorner( boundingBox[0], boundingBox[2], boundingBox[4] );
 588
 589     Vector2 stageSize = Stage::GetCurrent().GetSize();
 590     Vector3 scale( stageSize.x / bBoxSize.x, stageSize.y / bBoxSize.y, 1.f );
 591     scale.z = (scale.x + scale.y)/2.f;
 592
 593     for( std::vector<Vector3>::iterator iter = vertexPositions.begin(); iter != vertexPositions.end(); iter++ )
 594     {
 595       Vector3 newPosition(  (*iter) - bBoxMinCorner ) ;
 596
 597       Vector2 textureCoord( newPosition.x / bBoxSize.x, newPosition.y / bBoxSize.y );
 598       textureCoordinates.push_back( textureCoord );
 599
 600       newPosition -= bBoxSize * 0.5f;
 601       (*iter) = newPosition * scale;
 602     }
 603   }
 604
 605   /**
 606    * Main key event handler
 607    */
 608   void OnKeyEvent(const KeyEvent& event)
 609   {
 610     if(event.state == KeyEvent::Down)
 611     {
 612       if( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
 613       {
 614         mApplication.Quit();
 615       }
 616     }
 617   }
 618
 619 private:
 620
 621   Application&   mApplication;
 622   Layer          mContent;
 623
 624   bool           mIsDown;
 625   Vector2        mDownPosition;
 626   Vector2        mLightPosition;
 627   Vector2        mStageHalfSize;
 628
 629   Material       mMaterial;
 630   MeshActor      mMeshActor;
 631
 632   RefractionEffect  mRefractionEffect;
 633   NoEffect          mNoEffect;
 634   Animation         mLightAnimation;
 635   Animation         mStrenghAnimation;
 636
 637   Toolkit::PushButton        mChangeTextureButton;
 638   Toolkit::PushButton        mChangeMeshButton;
 639   unsigned int               mCurrentTextureId;
 640   unsigned int               mCurrentMeshId;
 641 };
 642
 643 /*****************************************************************************/
 644
 645 static void
 646 RunTest(Application& app)
 647 {
 648   RefractionEffectExample theApp(app);
 649   app.MainLoop();
 650 }
 651
 652 /*****************************************************************************/
 653
 654 int
 655 main(int argc, char **argv)
 656 {
 657   Application app = Application::New(&argc, &argv);
 658
 659   RunTest(app);
 660
 661   return 0;
 662 }