examples/renderer-stencil/renderer-stencil-example.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 // EXTERNAL INCLUDES
  19 #include <dali-toolkit/dali-toolkit.h>
  20 #include <dali/devel-api/adaptor-framework/bitmap-loader.h>
  21
  22 // INTERNAL INCLUDES
  23 #include "renderer-stencil-shaders.h"
  24 #include "shared/view.h"
  25 #include "shared/utility.h"
  26
  27 using namespace Dali;
  28
  29 namespace
  30 {
  31
  32 // Constants:
  33
  34 // Application constants:
  35 const char * const APPLICATION_TITLE( "Renderer Stencil API Demo" );
  36 const char * const BACKGROUND_IMAGE( DEMO_IMAGE_DIR "background-gradient.jpg" );
  37
  38 // Texture filenames:
  39 const char * const CUBE_TEXTURE( DEMO_IMAGE_DIR "people-medium-1.jpg" );
  40 const char * const FLOOR_TEXTURE( DEMO_IMAGE_DIR "wood.png" );
  41
  42 // Scale dimensions: These values are relative to the stage size. EG. width = 0.32f * stageSize.
  43 const float   CUBE_WIDTH_SCALE( 0.32f );                   ///< The width (and height + depth) of the main and reflection cubes.
  44 const Vector2 FLOOR_DIMENSION_SCALE( 0.67f, 0.017f );      ///< The width and height of the floor object.
  45
  46 // Configurable animation characteristics:
  47 const float ANIMATION_ROTATION_DURATION( 10.0f );          ///< Time in seconds to rotate the scene 360 degrees around Y.
  48 const float ANIMATION_BOUNCE_TOTAL_TIME( 1.6f );           ///< Time in seconds to perform 1 full bounce animation cycle.
  49 const float ANIMATION_BOUNCE_DEFORMATION_TIME( 0.4f );     ///< Time in seconds that the cube deformation animation will occur for (on contact with the floor).
  50 const float ANIMATION_BOUNCE_DEFORMATION_PERCENT( 20.0f ); ///< Percentage (of the cube's size) to deform the cube by (on contact with floor).
  51 const float ANIMATION_BOUNCE_HEIGHT_PERCENT( 40.0f );      ///< Percentage (of the cube's size) to bounce up in to the air by.
  52
  53 // Base colors for the objects:
  54 const Vector4 TEXT_COLOR( 1.0f, 1.0f, 1.0f, 1.0f );        ///< White.
  55 const Vector4 CUBE_COLOR( 1.0f, 1.0f, 1.0f, 1.0f );        ///< White.
  56 const Vector4 FLOOR_COLOR( 1.0f, 1.0f, 1.0f, 1.0f );       ///< White.
  57 const Vector4 REFLECTION_COLOR( 0.6f, 0.6f, 0.6f, 0.6f );  ///< Note that alpha is not 1.0f, to make the blend more photo-realistic.
  58
  59 // We need to control the draw order as we are controlling both the stencil and depth buffer per renderer.
  60 const int DEPTH_INDEX_GRANULARITY( 10000 );                ///< This value is the gap in depth-index in-between each renderer.
  61
  62 } // Anonymous namespace
  63
  64 /**
  65  * @brief This example shows how to manipulate stencil and depth buffer properties within the Renderer API.
  66  */
  67 class RendererStencilExample : public ConnectionTracker
  68 {
  69 public:
  70
  71   /**
  72    * @brief Constructor.
  73    * @param[in] application The DALi application object
  74    */
  75   RendererStencilExample( Application& application )
  76   : mApplication( application )
  77   {
  78     // Connect to the Application's Init signal.
  79     mApplication.InitSignal().Connect( this, &RendererStencilExample::Create );
  80   }
  81
  82   /**
  83    * @brief Destructor (non-virtual).
  84    */
  85   ~RendererStencilExample()
  86   {
  87   }
  88
  89 private:
  90
  91   /**
  92    * @brief Enum to facilitate more readable use of the cube array.
  93    */
  94   enum CubeType
  95   {
  96     MAIN_CUBE,      ///< The main cube that bounces above the floor object.
  97     REFLECTION_CUBE ///< The reflected cube object.
  98   };
  99
 100   /**
 101    * @brief Struct to store the position, normal and texture coordinates of a single vertex.
 102    */
 103   struct TexturedVertex
 104   {
 105     Vector3 position;
 106     Vector3 normal;
 107     Vector2 textureCoord;
 108   };
 109
 110   /**
 111    * @brief This is the main scene setup method for this demo.
 112    * This is called via the Init signal which is received once (only) during the Application lifetime.
 113    * @param[in] application The DALi application object
 114    */
 115   void Create( Application& application )
 116   {
 117     Stage stage = Stage::GetCurrent();
 118
 119     // Hide the indicator bar
 120     application.GetWindow().ShowIndicator( Dali::Window::INVISIBLE );
 121
 122     // Creates the background image.
 123     Toolkit::Control background = Dali::Toolkit::Control::New();
 124     background.SetAnchorPoint( Dali::AnchorPoint::CENTER );
 125     background.SetParentOrigin( Dali::ParentOrigin::CENTER );
 126     background.SetResizePolicy( Dali::ResizePolicy::FILL_TO_PARENT, Dali::Dimension::ALL_DIMENSIONS );
 127     Dali::Property::Map map;
 128     map["rendererType"] = "IMAGE";
 129     map["url"] = BACKGROUND_IMAGE;
 130     background.SetProperty( Dali::Toolkit::Control::Property::BACKGROUND, map );
 131     stage.Add( background );
 132
 133     // Create a TextLabel for the application title.
 134     Toolkit::TextLabel label = Toolkit::TextLabel::New( APPLICATION_TITLE );
 135     label.SetAnchorPoint( AnchorPoint::TOP_CENTER );
 136     // Set the parent origin to a small percentage below the top (so the demo will scale for different resolutions).
 137     label.SetParentOrigin( Vector3( 0.5f, 0.03f, 0.5f ) );
 138     label.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
 139     label.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
 140     label.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, TEXT_COLOR );
 141     stage.Add( label );
 142
 143     // Layer to hold the 3D scene.
 144     Layer layer = Layer::New();
 145     layer.SetAnchorPoint( AnchorPoint::CENTER );
 146     // Set the parent origin to a small percentage below the center (so the demo will scale for different resolutions).
 147     layer.SetParentOrigin( Vector3( 0.5f, 0.58f, 0.5f ) );
 148     layer.SetBehavior( Layer::LAYER_2D );
 149     layer.SetDepthTestDisabled( false );
 150     stage.Add( layer );
 151
 152     // Main cube:
 153     // Make the demo scalable with different resolutions by basing
 154     // the cube size on a percentage of the stage size.
 155     float scaleSize( std::min( stage.GetSize().width, stage.GetSize().height ) );
 156     float cubeWidth( scaleSize * CUBE_WIDTH_SCALE );
 157     Vector3 cubeSize( cubeWidth, cubeWidth, cubeWidth );
 158     // Create the geometry for the cube, and the texture.
 159     Geometry cubeGeometry = CreateCubeVertices( Vector3::ONE, false );
 160     TextureSet cubeTextureSet = CreateTextureSet( CUBE_TEXTURE );
 161     // Create the cube object and add it.
 162     // Note: The cube is anchored around its base for animation purposes, so the position can be zero.
 163     mCubes[ MAIN_CUBE ] = CreateMainCubeObject( cubeGeometry, cubeSize, cubeTextureSet );
 164     layer.Add( mCubes[ MAIN_CUBE ] );
 165
 166     // Floor:
 167     float floorWidth( scaleSize * FLOOR_DIMENSION_SCALE.x );
 168     Vector3 floorSize( floorWidth, scaleSize * FLOOR_DIMENSION_SCALE.y, floorWidth );
 169     // Create the floor object using the cube geometry with a new size, and add it.
 170     Actor floorObject( CreateFloorObject( cubeGeometry, floorSize ) );
 171     layer.Add( floorObject );
 172
 173     // Stencil:
 174     Vector3 planeSize( floorWidth, floorWidth, 0.0f );
 175     // Create the stencil plane object, and add it.
 176     Actor stencilPlaneObject( CreateStencilPlaneObject( planeSize ) );
 177     layer.Add( stencilPlaneObject );
 178
 179     // Reflection cube:
 180     // Create the reflection cube object and add it.
 181     // Note: The cube is anchored around its base for animation purposes, so the position can be zero.
 182     mCubes[ REFLECTION_CUBE ] = CreateReflectionCubeObject( cubeSize, cubeTextureSet );
 183     layer.Add( mCubes[ REFLECTION_CUBE ] );
 184
 185     // Rotate the layer so we can see some of the top of the cube for a more 3D effect.
 186     layer.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( -24.0f ), Degree( 0.0f ), Degree( 0.0f ) ) );
 187
 188     // Set up the rotation on the Y axis.
 189     mRotationAnimation = Animation::New( ANIMATION_ROTATION_DURATION );
 190     float fullRotation = 360.0f;
 191     mRotationAnimation.AnimateBy( Property( mCubes[ MAIN_CUBE ], Actor::Property::ORIENTATION ),
 192                                  Quaternion( Degree( 0.0f ), Degree( fullRotation ), Degree( 0.0f ) ) );
 193     mRotationAnimation.AnimateBy( Property( floorObject, Actor::Property::ORIENTATION ),
 194                                  Quaternion( Degree( 0.0f ), Degree( fullRotation ), Degree( 0.0f ) ) );
 195     // Note the stencil is pre-rotated by 90 degrees on X, so we rotate relatively on its Z axis for an equivalent Y rotation.
 196     mRotationAnimation.AnimateBy( Property( stencilPlaneObject, Actor::Property::ORIENTATION ),
 197                                  Quaternion( Degree( 0.0f ), Degree( 0.0f ), Degree( fullRotation ) ) );
 198     mRotationAnimation.AnimateBy( Property( mCubes[ REFLECTION_CUBE ], Actor::Property::ORIENTATION ),
 199                                  Quaternion( Degree( 0.0f ), Degree( fullRotation ), Degree( 0.0f ) ) );
 200     mRotationAnimation.SetLooping( true );
 201
 202     // Set up the cube bouncing animation.
 203     float totalTime = ANIMATION_BOUNCE_TOTAL_TIME;
 204     float deformationTime = ANIMATION_BOUNCE_DEFORMATION_TIME;
 205     // Percentage based amounts allows the bounce and deformation to scale for different resolution screens.
 206     float deformationAmount = ANIMATION_BOUNCE_DEFORMATION_PERCENT / 100.0f;
 207     float heightChange = ( cubeSize.y * ANIMATION_BOUNCE_HEIGHT_PERCENT ) / 100.0f;
 208
 209     // Animation pre-calculations:
 210     float halfTime = totalTime / 2.0f;
 211     float halfDeformationTime = deformationTime / 2.0f;
 212
 213     // First position the cubes at the top of the animation cycle.
 214     mCubes[ MAIN_CUBE ].SetProperty(       Actor::Property::POSITION_Y, -heightChange );
 215     mCubes[ REFLECTION_CUBE ].SetProperty( Actor::Property::POSITION_Y,  heightChange );
 216
 217     mBounceAnimation = Animation::New( totalTime );
 218
 219     // The animations for the main and reflected cubes are almost identical, so we combine the code to do both.
 220     for( int cube = 0; cube < 2; ++cube )
 221     {
 222       // If iterating on the reflection cube, adjust the heightChange variable so the below code can be reused.
 223       if( cube == 1 )
 224       {
 225         heightChange = -heightChange;
 226       }
 227
 228       // 1st TimePeriod: Start moving down with increasing speed, until it is time to distort the cube due to impact.
 229       mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::POSITION_Y ),  heightChange, AlphaFunction::EASE_IN_SQUARE, TimePeriod( 0.0f, halfTime - halfDeformationTime ) );
 230
 231       // 2nd TimePeriod: The cube is touching the floor, start deforming it - then un-deform it again.
 232       mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::SCALE_X ),  deformationAmount, AlphaFunction::BOUNCE, TimePeriod( halfTime - halfDeformationTime, deformationTime ) );
 233       mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::SCALE_Z ),  deformationAmount, AlphaFunction::BOUNCE, TimePeriod( halfTime - halfDeformationTime, deformationTime ) );
 234       mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::SCALE_Y ), -deformationAmount, AlphaFunction::BOUNCE, TimePeriod( halfTime - halfDeformationTime, deformationTime ) );
 235
 236       // 3rd TimePeriod: Start moving up with decreasing speed, until at the apex of the animation.
 237       mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::POSITION_Y ), -heightChange, AlphaFunction::EASE_OUT_SQUARE, TimePeriod( halfTime + halfDeformationTime, halfTime - halfDeformationTime ) );
 238     }
 239
 240     mBounceAnimation.SetLooping( true );
 241
 242     // Start the animations.
 243     mRotationAnimation.Play();
 244     mBounceAnimation.Play();
 245
 246     // Respond to a click anywhere on the stage
 247     stage.GetRootLayer().TouchSignal().Connect( this, &RendererStencilExample::OnTouch );
 248     // Connect signals to allow Back and Escape to exit.
 249     stage.KeyEventSignal().Connect( this, &RendererStencilExample::OnKeyEvent );
 250   }
 251
 252 private:
 253
 254   // Methods to setup each component of the 3D scene:
 255
 256   /**
 257    * @brief Creates the Main cube object.
 258    * This creates the renderer from existing geometry (as the cubes geometry is shared).
 259    * The texture is set and all relevant renderer properties are set-up.
 260    * @param[in] geometry Pre-calculated cube geometry
 261    * @param[in] size The desired cube size
 262    * @param[in] textureSet A pre-existing TextureSet with a texture set up, to be applied to the cube
 263    * @return An actor set-up containing the main cube object
 264    */
 265   Actor CreateMainCubeObject( Geometry& geometry, Vector3 size, TextureSet& textureSet )
 266   {
 267     Toolkit::Control container = Toolkit::Control::New();
 268     container.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
 269     container.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
 270     container.SetSize( size );
 271     container.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
 272
 273     // Create a renderer from the geometry and add the texture.
 274     Renderer renderer = CreateRenderer( geometry, size, true, CUBE_COLOR );
 275     renderer.SetTextures( textureSet );
 276
 277     // Setup the renderer properties:
 278     // We are writing to the color buffer & culling back faces.
 279     renderer.SetProperty( Renderer::Property::WRITE_TO_COLOR_BUFFER, true );
 280     renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK );
 281
 282     // No stencil is used for the main cube.
 283     renderer.SetProperty( Renderer::Property::STENCIL_MODE, StencilMode::OFF );
 284
 285     // We do need to write to the depth buffer as other objects need to appear underneath this cube.
 286     renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON );
 287     // We do not need to test the depth buffer as we are culling the back faces.
 288     renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::OFF );
 289
 290     // This object must be rendered 1st.
 291     renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 0 * DEPTH_INDEX_GRANULARITY );
 292
 293     container.AddRenderer( renderer );
 294     return container;
 295   }
 296
 297   /**
 298    * @brief Creates the Floor object.
 299    * This creates the renderer from existing geometry (as the cube geometry can be re-used).
 300    * The texture is created and set and all relevant renderer properties are set-up.
 301    * @param[in] geometry Pre-calculated cube geometry
 302    * @param[in] size The desired floor size
 303    * @return An actor set-up containing the floor object
 304    */
 305   Actor CreateFloorObject( Geometry& geometry, Vector3 size )
 306   {
 307     Toolkit::Control container = Toolkit::Control::New();
 308     container.SetAnchorPoint( AnchorPoint::TOP_CENTER );
 309     container.SetParentOrigin( ParentOrigin::TOP_CENTER );
 310     container.SetSize( size );
 311     container.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
 312
 313     // Create a renderer from the geometry and add the texture.
 314     TextureSet planeTextureSet = CreateTextureSet( FLOOR_TEXTURE );
 315     Renderer renderer = CreateRenderer( geometry, size, true, FLOOR_COLOR );
 316     renderer.SetTextures( planeTextureSet );
 317
 318     // Setup the renderer properties:
 319     // We are writing to the color buffer & culling back faces (as we are NOT doing depth write).
 320     renderer.SetProperty( Renderer::Property::WRITE_TO_COLOR_BUFFER, true );
 321     renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK );
 322
 323     // No stencil is used for the floor.
 324     renderer.SetProperty( Renderer::Property::STENCIL_MODE, StencilMode::OFF );
 325
 326     // We do not write to the depth buffer as its not needed.
 327     renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF );
 328     // We do need to test the depth buffer as we need the floor to be underneath the cube.
 329     renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON );
 330
 331     // This object must be rendered 2nd.
 332     renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 1 * DEPTH_INDEX_GRANULARITY );
 333
 334     container.AddRenderer( renderer );
 335     return container;
 336   }
 337
 338   /**
 339    * @brief Creates the Stencil-Plane object.
 340    * This is places on the floor object to allow the reflection to be drawn on to the floor.
 341    * This creates the geometry and renderer.
 342    * All relevant renderer properties are set-up.
 343    * @param[in] size The desired plane size
 344    * @return An actor set-up containing the stencil-plane object
 345    */
 346   Actor CreateStencilPlaneObject( Vector3 size )
 347   {
 348     Toolkit::Control container = Toolkit::Control::New();
 349     container.SetAnchorPoint( AnchorPoint::CENTER );
 350     container.SetParentOrigin( ParentOrigin::CENTER );
 351     container.SetSize( size );
 352     container.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
 353
 354     // We rotate the plane as the geometry is created flat in X & Y. We want it to span X & Z axis.
 355     container.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( -90.0f ), Degree( 0.0f ), Degree( 0.0f ) ) );
 356
 357     // Create geometry for a flat plane.
 358     Geometry planeGeometry = CreatePlaneVertices( Vector2::ONE );
 359     // Create a renderer from the geometry.
 360     Renderer renderer = CreateRenderer( planeGeometry, size, false, Vector4::ONE );
 361
 362     // Setup the renderer properties:
 363     // The stencil plane is only for stencilling, so disable writing to color buffer.
 364     renderer.SetProperty( Renderer::Property::WRITE_TO_COLOR_BUFFER, false );
 365
 366     // Enable stencil. Draw to the stencil buffer (only).
 367     renderer.SetProperty( Renderer::Property::STENCIL_MODE, StencilMode::ON );
 368     renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS );
 369     renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE, 1 );
 370     renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_MASK, 0xFF );
 371     renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP );
 372     renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::KEEP );
 373     renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::REPLACE );
 374     renderer.SetProperty( Renderer::Property::STENCIL_MASK, 0xFF );
 375
 376     // We don't want to write to the depth buffer, as this would block the reflection being drawn.
 377     renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF );
 378     // We test the depth buffer as we want the stencil to only exist underneath the cube.
 379     renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON );
 380
 381     // This object must be rendered 3rd.
 382     renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 2 * DEPTH_INDEX_GRANULARITY );
 383
 384     container.AddRenderer( renderer );
 385     return container;
 386   }
 387
 388   /**
 389    * @brief Creates the Reflection cube object.
 390    * This creates new geometry (as the texture UVs are different to the main cube).
 391    * The renderer is then created.
 392    * The texture is set and all relevant renderer properties are set-up.
 393    * @param[in] size The desired cube size
 394    * @param[in] textureSet A pre-existing TextureSet with a texture set up, to be applied to the cube
 395    * @return An actor set-up containing the reflection cube object
 396    */
 397   Actor CreateReflectionCubeObject( Vector3 size, TextureSet& textureSet )
 398   {
 399     Toolkit::Control container = Toolkit::Control::New();
 400     container.SetAnchorPoint( AnchorPoint::TOP_CENTER );
 401     container.SetParentOrigin( ParentOrigin::TOP_CENTER );
 402     container.SetSize( size );
 403     container.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
 404
 405     // Create the cube geometry of unity size.
 406     // The "true" specifies we want the texture UVs flipped vertically as this is the reflection cube.
 407     Geometry reflectedCubeGeometry = CreateCubeVertices( Vector3::ONE, true );
 408     // Create a renderer from the geometry and add the texture.
 409     Renderer renderer = CreateRenderer( reflectedCubeGeometry, size, true, REFLECTION_COLOR );
 410     renderer.SetTextures( textureSet );
 411
 412     // Setup the renderer properties:
 413     // Write to color buffer so reflection is visible
 414     renderer.SetProperty( Renderer::Property::WRITE_TO_COLOR_BUFFER, true );
 415     // We cull to skip drawing the back faces.
 416     renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK );
 417
 418     // We use blending to blend the reflection with the floor texture.
 419     renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
 420     renderer.SetProperty( Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::ADD );
 421     renderer.SetProperty( Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::ADD );
 422     renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE );
 423
 424     // Enable stencil. Here we only draw to areas within the stencil.
 425     renderer.SetProperty( Renderer::Property::STENCIL_MODE, StencilMode::ON );
 426     renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, StencilFunction::EQUAL );
 427     renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE, 1 );
 428     renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_MASK, 0xff );
 429     // Don't write to the stencil.
 430     renderer.SetProperty( Renderer::Property::STENCIL_MASK, 0x00 );
 431
 432     // We don't need to write to the depth buffer, as we are culling.
 433     renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF );
 434     // We need to test the depth buffer as we need the reflection to be underneath the cube.
 435     renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON );
 436
 437     // This object must be rendered last.
 438     renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 3 * DEPTH_INDEX_GRANULARITY );
 439
 440     container.AddRenderer( renderer );
 441     return container;
 442   }
 443
 444   // Methods:
 445
 446   /**
 447    * @brief Creates a geometry object from vertices and indices.
 448    * @param[in] vertices The object vertices
 449    * @param[in] indices The object indices
 450    * @return A geometry object
 451    */
 452   Geometry CreateTexturedGeometry( Vector<TexturedVertex>& vertices, Vector<unsigned short>& indices )
 453   {
 454     // Vertices
 455     Property::Map vertexFormat;
 456     vertexFormat[POSITION] = Property::VECTOR3;
 457     vertexFormat[NORMAL] =   Property::VECTOR3;
 458     vertexFormat[TEXTURE] =  Property::VECTOR2;
 459
 460     PropertyBuffer surfaceVertices = PropertyBuffer::New( vertexFormat );
 461     surfaceVertices.SetData( &vertices[0u], vertices.Size() );
 462
 463     Geometry geometry = Geometry::New();
 464     geometry.AddVertexBuffer( surfaceVertices );
 465
 466     // Indices for triangle formulation
 467     geometry.SetIndexBuffer( &indices[0u], indices.Size() );
 468     return geometry;
 469   }
 470
 471   /**
 472    * @brief Creates a renderer from a geometry object.
 473    * @param[in] geometry The geometry to use
 474    * @param[in] dimensions The dimensions (will be passed in to the shader)
 475    * @param[in] textured Set to true to use the texture versions of the shaders
 476    * @param[in] color The base color for the renderer
 477    * @return A renderer object
 478    */
 479   Renderer CreateRenderer( Geometry geometry, Vector3 dimensions, bool textured, Vector4 color )
 480   {
 481     Stage stage = Stage::GetCurrent();
 482     Shader shader;
 483
 484     if( textured )
 485     {
 486       shader = Shader::New( VERTEX_SHADER_TEXTURED, FRAGMENT_SHADER_TEXTURED );
 487     }
 488     else
 489     {
 490       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
 491     }
 492
 493     // Here we modify the light position based on half the stage size as a pre-calculation step.
 494     // This avoids the work having to be done in the shader.
 495     shader.RegisterProperty( LIGHT_POSITION_UNIFORM_NAME, Vector3( -stage.GetSize().width / 2.0f, -stage.GetSize().width / 2.0f, 1000.0f ) );
 496     shader.RegisterProperty( COLOR_UNIFORM_NAME, color );
 497     shader.RegisterProperty( OBJECT_DIMENSIONS_UNIFORM_NAME, dimensions );
 498
 499     return Renderer::New( geometry, shader );
 500   }
 501
 502   /**
 503    * @brief Helper method to create a TextureSet from an image URL.
 504    * @param[in] url An image URL
 505    * @return A TextureSet object
 506    */
 507   TextureSet CreateTextureSet( const char* url )
 508   {
 509     TextureSet textureSet = TextureSet::New();
 510
 511     if( textureSet )
 512     {
 513       Texture texture = DemoHelper::LoadTexture( url );
 514       if( texture )
 515       {
 516         textureSet.SetTexture( 0u, texture );
 517       }
 518     }
 519
 520     return textureSet;
 521   }
 522
 523   // Geometry Creation:
 524
 525   /**
 526    * @brief Creates a geometry object for a flat plane.
 527    * The plane is oriented in X & Y axis (Z is 0).
 528    * @param[in] dimensions The desired plane dimensions
 529    * @return A Geometry object
 530    */
 531   Geometry CreatePlaneVertices( Vector2 dimensions )
 532   {
 533     Vector<TexturedVertex> vertices;
 534     Vector<unsigned short> indices;
 535     vertices.Resize( 4u );
 536     indices.Resize( 6u );
 537
 538     float scaledX = 0.5f * dimensions.x;
 539     float scaledY = 0.5f * dimensions.y;
 540
 541     vertices[0].position     = Vector3( -scaledX, -scaledY, 0.0f );
 542     vertices[0].textureCoord = Vector2( 0.0, 0.0f );
 543     vertices[1].position     = Vector3(  scaledX, -scaledY, 0.0f );
 544     vertices[1].textureCoord = Vector2( 1.0, 0.0f );
 545     vertices[2].position     = Vector3(  scaledX,  scaledY, 0.0f );
 546     vertices[2].textureCoord = Vector2( 1.0, 1.0f );
 547     vertices[3].position     = Vector3( -scaledX,  scaledY, 0.0f );
 548     vertices[3].textureCoord = Vector2( 0.0, 1.0f );
 549
 550     // All vertices have the same normal.
 551     for( int i = 0; i < 4; ++i )
 552     {
 553       vertices[i].normal = Vector3( 0.0f, 0.0f, -1.0f );
 554     }
 555
 556     indices[0] = 0;
 557     indices[1] = 1;
 558     indices[2] = 2;
 559     indices[3] = 2;
 560     indices[4] = 3;
 561     indices[5] = 0;
 562
 563     // Use the helper method to create the geometry object.
 564     return CreateTexturedGeometry( vertices, indices );
 565   }
 566
 567   /**
 568    * @brief Creates a geometry object for a cube (or cuboid).
 569    * @param[in] dimensions The desired cube dimensions
 570    * @param[in] reflectVerticalUVs Set to True to force the UVs to be vertically flipped
 571    * @return A Geometry object
 572    */
 573   Geometry CreateCubeVertices( Vector3 dimensions, bool reflectVerticalUVs )
 574   {
 575     Vector<TexturedVertex> vertices;
 576     Vector<unsigned short> indices;
 577     int vertexIndex = 0u; // Tracks progress through vertices.
 578     float scaledX = 0.5f * dimensions.x;
 579     float scaledY = 0.5f * dimensions.y;
 580     float scaledZ = 0.5f * dimensions.z;
 581     float verticalTextureCoord = reflectVerticalUVs ? 0.0f : 1.0f;
 582
 583     vertices.Resize( 4u * 6u ); // 4 vertices x 6 faces
 584
 585     Vector<Vector3> positions;  // Stores vertex positions, which are shared between vertexes at the same position but with a different normal.
 586     positions.Resize( 8u );
 587     Vector<Vector3> normals;    // Stores normals, which are shared between vertexes of the same face.
 588     normals.Resize( 6u );
 589
 590     positions[0] = Vector3( -scaledX,  scaledY, -scaledZ );
 591     positions[1] = Vector3(  scaledX,  scaledY, -scaledZ );
 592     positions[2] = Vector3(  scaledX,  scaledY,  scaledZ );
 593     positions[3] = Vector3( -scaledX,  scaledY,  scaledZ );
 594     positions[4] = Vector3( -scaledX, -scaledY, -scaledZ );
 595     positions[5] = Vector3(  scaledX, -scaledY, -scaledZ );
 596     positions[6] = Vector3(  scaledX, -scaledY,  scaledZ );
 597     positions[7] = Vector3( -scaledX, -scaledY,  scaledZ );
 598
 599     normals[0] = Vector3(  0,  1,  0 );
 600     normals[1] = Vector3(  0,  0, -1 );
 601     normals[2] = Vector3(  1,  0,  0 );
 602     normals[3] = Vector3(  0,  0,  1 );
 603     normals[4] = Vector3( -1,  0,  0 );
 604     normals[5] = Vector3(  0, -1,  0 );
 605
 606     // Top face, upward normals.
 607     for( int i = 0; i < 4; ++i, ++vertexIndex )
 608     {
 609       vertices[vertexIndex].position = positions[i];
 610       vertices[vertexIndex].normal = normals[0];
 611       // The below logic forms the correct U/V pairs for a quad when "i" goes from 0 to 3.
 612       vertices[vertexIndex].textureCoord = Vector2( ( i == 1 || i == 2 ) ? 1.0f : 0.0f, ( i == 2 || i == 3 ) ? 1.0f : 0.0f );
 613     }
 614
 615     // Top face, outward normals.
 616     for( int i = 0; i < 4; ++i, vertexIndex += 2 )
 617     {
 618       vertices[vertexIndex].position = positions[i];
 619       vertices[vertexIndex].normal = normals[i + 1];
 620
 621       if( i == 3 )
 622       {
 623         // End, so loop around.
 624         vertices[vertexIndex + 1].position = positions[0];
 625       }
 626       else
 627       {
 628         vertices[vertexIndex + 1].position = positions[i + 1];
 629       }
 630       vertices[vertexIndex + 1].normal = normals[i + 1];
 631
 632       vertices[vertexIndex].textureCoord = Vector2( 0.0f, verticalTextureCoord );
 633       vertices[vertexIndex+1].textureCoord = Vector2( 1.0f, verticalTextureCoord );
 634     }
 635
 636     // Flip the vertical texture coord for the UV values of the bottom points.
 637     verticalTextureCoord = 1.0f - verticalTextureCoord;
 638
 639     // Bottom face, outward normals.
 640     for( int i = 0; i < 4; ++i, vertexIndex += 2 )
 641     {
 642       vertices[vertexIndex].position = positions[i + 4];
 643       vertices[vertexIndex].normal = normals[i + 1];
 644
 645       if( i == 3 )
 646       {
 647         // End, so loop around.
 648         vertices[vertexIndex + 1].position = positions[4];
 649       }
 650       else
 651       {
 652         vertices[vertexIndex + 1].position = positions[i + 5];
 653       }
 654       vertices[vertexIndex + 1].normal = normals[i + 1];
 655
 656       vertices[vertexIndex].textureCoord = Vector2( 0.0f, verticalTextureCoord );
 657       vertices[vertexIndex+1].textureCoord = Vector2( 1.0f, verticalTextureCoord );
 658     }
 659
 660     // Bottom face, downward normals.
 661     for( int i = 0; i < 4; ++i, ++vertexIndex )
 662     {
 663       // Reverse positions for bottom face to keep triangles clockwise (for culling).
 664       vertices[vertexIndex].position = positions[ 7 - i ];
 665       vertices[vertexIndex].normal = normals[5];
 666       // The below logic forms the correct U/V pairs for a quad when "i" goes from 0 to 3.
 667       vertices[vertexIndex].textureCoord = Vector2( ( i == 1 || i == 2 ) ? 1.0f : 0.0f, ( i == 2 || i == 3 ) ? 1.0f : 0.0f );
 668     }
 669
 670     // Create cube indices.
 671     int triangleIndex = 0u;     //Track progress through indices.
 672     indices.Resize( 3u * 12u ); // 3 points x 12 triangles.
 673
 674     // Top face.
 675     indices[triangleIndex] =     0;
 676     indices[triangleIndex + 1] = 1;
 677     indices[triangleIndex + 2] = 2;
 678     indices[triangleIndex + 3] = 2;
 679     indices[triangleIndex + 4] = 3;
 680     indices[triangleIndex + 5] = 0;
 681     triangleIndex += 6;
 682
 683     int topFaceStart = 4u;
 684     int bottomFaceStart = topFaceStart + 8u;
 685
 686     // Side faces.
 687     for( int i = 0; i < 8; i += 2, triangleIndex += 6 )
 688     {
 689       indices[triangleIndex    ] = i + topFaceStart;
 690       indices[triangleIndex + 1] = i + bottomFaceStart + 1;
 691       indices[triangleIndex + 2] = i + topFaceStart + 1;
 692       indices[triangleIndex + 3] = i + topFaceStart;
 693       indices[triangleIndex + 4] = i + bottomFaceStart;
 694       indices[triangleIndex + 5] = i + bottomFaceStart + 1;
 695     }
 696
 697     // Bottom face.
 698     indices[triangleIndex] =     20;
 699     indices[triangleIndex + 1] = 21;
 700     indices[triangleIndex + 2] = 22;
 701     indices[triangleIndex + 3] = 22;
 702     indices[triangleIndex + 4] = 23;
 703     indices[triangleIndex + 5] = 20;
 704
 705     // Use the helper method to create the geometry object.
 706     return CreateTexturedGeometry( vertices, indices );
 707   }
 708
 709   // Signal handlers:
 710
 711   /**
 712    * @brief OnTouch signal handler.
 713    * @param[in] actor The actor that has been touched
 714    * @param[in] touch The touch information
 715    * @return True if the event has been handled
 716    */
 717   bool OnTouch( Actor actor, const TouchData& touch )
 718   {
 719     // Quit the application.
 720     mApplication.Quit();
 721     return true;
 722   }
 723
 724   /**
 725    * @brief OnKeyEvent signal handler.
 726    * @param[in] event The key event information
 727    */
 728   void OnKeyEvent( const KeyEvent& event )
 729   {
 730     if( event.state == KeyEvent::Down )
 731     {
 732       if ( IsKey( event, Dali::DALI_KEY_ESCAPE ) || IsKey( event, Dali::DALI_KEY_BACK ) )
 733       {
 734         mApplication.Quit();
 735       }
 736     }
 737   }
 738
 739 private:
 740
 741   // Member variables:
 742
 743   Application&     mApplication;       ///< The DALi application object
 744   Toolkit::Control mView;              ///< The view used to show the background
 745
 746   Animation        mRotationAnimation; ///< The animation to spin the cube & floor
 747   Animation        mBounceAnimation;   ///< The animation to bounce the cube
 748   Actor            mCubes[2];          ///< The cube object containers
 749 };
 750
 751
 752 /**
 753  * @brief Creates an instance of the example object and runs it.
 754  * @param[in] application The DALi application object
 755  */
 756 void RunExample( Application& application )
 757 {
 758   RendererStencilExample example( application );
 759
 760   application.MainLoop();
 761 }
 762
 763 /**
 764  * @brief Entry point for Linux & Tizen applications
 765  * @param[in] argc The executables argument count
 766  * @param[in] argv The executables argument vector
 767  * @return The executables exit code (0)
 768  */
 769 int DALI_EXPORT_API main( int argc, char **argv )
 770 {
 771   Application application = Application::New( &argc, &argv );
 772
 773   RunExample( application );
 774
 775   return 0;
 776 }