X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-demo.git;a=blobdiff_plain;f=examples%2Frenderer-stencil%2Frenderer-stencil-example.cpp;h=f324ea7b92460f205f8efa30ad73f5f35906c370;hp=86e006bf1380f86a16a0c2a6a2437af9f78be40a;hb=1b19fd140ff139b5854a1a62447faf31b175d8f6;hpb=b26d446b0cb6a316abc3a79d4fc70d0ae1b7994c diff --git a/examples/renderer-stencil/renderer-stencil-example.cpp b/examples/renderer-stencil/renderer-stencil-example.cpp index 86e006b..f324ea7 100644 --- a/examples/renderer-stencil/renderer-stencil-example.cpp +++ b/examples/renderer-stencil/renderer-stencil-example.cpp @@ -20,43 +20,42 @@ // INTERNAL INCLUDES #include "renderer-stencil-shaders.h" -#include "shared/view.h" #include "shared/utility.h" +#include "shared/view.h" using namespace Dali; namespace { - // Constants: // Application constants: -const char * const APPLICATION_TITLE( "Renderer Stencil API Demo" ); -const char * const BACKGROUND_IMAGE( DEMO_IMAGE_DIR "background-gradient.jpg" ); +const char* const APPLICATION_TITLE("Renderer Stencil API Demo"); +const char* const BACKGROUND_IMAGE(DEMO_IMAGE_DIR "background-gradient.jpg"); // Texture filenames: -const char * const CUBE_TEXTURE( DEMO_IMAGE_DIR "people-medium-1.jpg" ); -const char * const FLOOR_TEXTURE( DEMO_IMAGE_DIR "wood.png" ); +const char* const CUBE_TEXTURE(DEMO_IMAGE_DIR "people-medium-1.jpg"); +const char* const FLOOR_TEXTURE(DEMO_IMAGE_DIR "wood.png"); // Scale dimensions: These values are relative to the window size. EG. width = 0.32f * windowSize. -const float CUBE_WIDTH_SCALE( 0.32f ); ///< The width (and height + depth) of the main and reflection cubes. -const Vector2 FLOOR_DIMENSION_SCALE( 0.67f, 0.017f ); ///< The width and height of the floor object. +const float CUBE_WIDTH_SCALE(0.32f); ///< The width (and height + depth) of the main and reflection cubes. +const Vector2 FLOOR_DIMENSION_SCALE(0.67f, 0.017f); ///< The width and height of the floor object. // Configurable animation characteristics: -const float ANIMATION_ROTATION_DURATION( 10.0f ); ///< Time in seconds to rotate the scene 360 degrees around Y. -const float ANIMATION_BOUNCE_TOTAL_TIME( 1.6f ); ///< Time in seconds to perform 1 full bounce animation cycle. -const float ANIMATION_BOUNCE_DEFORMATION_TIME( 0.4f ); ///< Time in seconds that the cube deformation animation will occur for (on contact with the floor). -const float ANIMATION_BOUNCE_DEFORMATION_PERCENT( 20.0f ); ///< Percentage (of the cube's size) to deform the cube by (on contact with floor). -const float ANIMATION_BOUNCE_HEIGHT_PERCENT( 40.0f ); ///< Percentage (of the cube's size) to bounce up in to the air by. +const float ANIMATION_ROTATION_DURATION(10.0f); ///< Time in seconds to rotate the scene 360 degrees around Y. +const float ANIMATION_BOUNCE_TOTAL_TIME(1.6f); ///< Time in seconds to perform 1 full bounce animation cycle. +const float ANIMATION_BOUNCE_DEFORMATION_TIME(0.4f); ///< Time in seconds that the cube deformation animation will occur for (on contact with the floor). +const float ANIMATION_BOUNCE_DEFORMATION_PERCENT(20.0f); ///< Percentage (of the cube's size) to deform the cube by (on contact with floor). +const float ANIMATION_BOUNCE_HEIGHT_PERCENT(40.0f); ///< Percentage (of the cube's size) to bounce up in to the air by. // Base colors for the objects: -const Vector4 TEXT_COLOR( 1.0f, 1.0f, 1.0f, 1.0f ); ///< White. -const Vector4 CUBE_COLOR( 1.0f, 1.0f, 1.0f, 1.0f ); ///< White. -const Vector4 FLOOR_COLOR( 1.0f, 1.0f, 1.0f, 1.0f ); ///< White. -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. +const Vector4 TEXT_COLOR(1.0f, 1.0f, 1.0f, 1.0f); ///< White. +const Vector4 CUBE_COLOR(1.0f, 1.0f, 1.0f, 1.0f); ///< White. +const Vector4 FLOOR_COLOR(1.0f, 1.0f, 1.0f, 1.0f); ///< White. +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. // We need to control the draw order as we are controlling both the stencil and depth buffer per renderer. -const int DEPTH_INDEX_GRANULARITY( 10000 ); ///< This value is the gap in depth-index in-between each renderer. +const int DEPTH_INDEX_GRANULARITY(10000); ///< This value is the gap in depth-index in-between each renderer. } // Anonymous namespace @@ -66,16 +65,15 @@ const int DEPTH_INDEX_GRANULARITY( 10000 ); ///< This value is th class RendererStencilExample : public ConnectionTracker { public: - /** * @brief Constructor. * @param[in] application The DALi application object */ - RendererStencilExample( Application& application ) - : mApplication( application ) + RendererStencilExample(Application& application) + : mApplication(application) { // Connect to the Application's Init signal. - mApplication.InitSignal().Connect( this, &RendererStencilExample::Create ); + mApplication.InitSignal().Connect(this, &RendererStencilExample::Create); } /** @@ -86,7 +84,6 @@ public: } private: - /** * @brief Enum to facilitate more readable use of the cube array. */ @@ -111,157 +108,150 @@ private: * This is called via the Init signal which is received once (only) during the Application lifetime. * @param[in] application The DALi application object */ - void Create( Application& application ) + void Create(Application& application) { Window window = application.GetWindow(); // Use a gradient visual to render the background gradient. Toolkit::Control background = Dali::Toolkit::Control::New(); - background.SetProperty( Actor::Property::ANCHOR_POINT, Dali::AnchorPoint::CENTER ); - background.SetProperty( Actor::Property::PARENT_ORIGIN, Dali::ParentOrigin::CENTER ); - background.SetResizePolicy( Dali::ResizePolicy::FILL_TO_PARENT, Dali::Dimension::ALL_DIMENSIONS ); + background.SetProperty(Actor::Property::ANCHOR_POINT, Dali::AnchorPoint::CENTER); + background.SetProperty(Actor::Property::PARENT_ORIGIN, Dali::ParentOrigin::CENTER); + background.SetResizePolicy(Dali::ResizePolicy::FILL_TO_PARENT, Dali::Dimension::ALL_DIMENSIONS); // Set up the background gradient. Property::Array stopOffsets; - stopOffsets.PushBack( 0.0f ); - stopOffsets.PushBack( 1.0f ); + stopOffsets.PushBack(0.0f); + stopOffsets.PushBack(1.0f); Property::Array stopColors; - stopColors.PushBack( Vector4( 0.17f, 0.24f, 0.35f, 1.0f ) ); // Dark, medium saturated blue ( top of screen) - stopColors.PushBack( Vector4( 0.45f, 0.70f, 0.80f, 1.0f ) ); // Medium bright, pastel blue (bottom of screen) + stopColors.PushBack(Vector4(0.17f, 0.24f, 0.35f, 1.0f)); // Dark, medium saturated blue ( top of screen) + stopColors.PushBack(Vector4(0.45f, 0.70f, 0.80f, 1.0f)); // Medium bright, pastel blue (bottom of screen) const float percentageWindowHeight = window.GetSize().GetHeight() * 0.7f; - background.SetProperty( Toolkit::Control::Property::BACKGROUND, Dali::Property::Map() - .Add( Toolkit::Visual::Property::TYPE, Dali::Toolkit::Visual::GRADIENT ) - .Add( Toolkit::GradientVisual::Property::STOP_OFFSET, stopOffsets ) - .Add( Toolkit::GradientVisual::Property::STOP_COLOR, stopColors ) - .Add( Toolkit::GradientVisual::Property::START_POSITION, Vector2( 0.0f, -percentageWindowHeight ) ) - .Add( Toolkit::GradientVisual::Property::END_POSITION, Vector2( 0.0f, percentageWindowHeight ) ) - .Add( Toolkit::GradientVisual::Property::UNITS, Toolkit::GradientVisual::Units::USER_SPACE ) ); + background.SetProperty(Toolkit::Control::Property::BACKGROUND, Dali::Property::Map().Add(Toolkit::Visual::Property::TYPE, Dali::Toolkit::Visual::GRADIENT).Add(Toolkit::GradientVisual::Property::STOP_OFFSET, stopOffsets).Add(Toolkit::GradientVisual::Property::STOP_COLOR, stopColors).Add(Toolkit::GradientVisual::Property::START_POSITION, Vector2(0.0f, -percentageWindowHeight)).Add(Toolkit::GradientVisual::Property::END_POSITION, Vector2(0.0f, percentageWindowHeight)).Add(Toolkit::GradientVisual::Property::UNITS, Toolkit::GradientVisual::Units::USER_SPACE)); - window.Add( background ); + window.Add(background); // Create a TextLabel for the application title. - Toolkit::TextLabel label = Toolkit::TextLabel::New( APPLICATION_TITLE ); - label.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER ); + Toolkit::TextLabel label = Toolkit::TextLabel::New(APPLICATION_TITLE); + label.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER); // Set the parent origin to a small percentage below the top (so the demo will scale for different resolutions). - label.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( 0.5f, 0.03f, 0.5f ) ); - label.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" ); - label.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" ); - label.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, TEXT_COLOR ); - window.Add( label ); + label.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5f, 0.03f, 0.5f)); + label.SetProperty(Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER"); + label.SetProperty(Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER"); + label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, TEXT_COLOR); + window.Add(label); // Layer to hold the 3D scene. Layer layer = Layer::New(); - layer.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER ); + layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); // Set the parent origin to a small percentage below the center (so the demo will scale for different resolutions). - layer.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( 0.5f, 0.58f, 0.5f ) ); - layer.SetProperty( Layer::Property::BEHAVIOR, Layer::LAYER_UI ); - layer.SetProperty( Layer::Property::DEPTH_TEST, true ); - window.Add( layer ); + layer.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5f, 0.58f, 0.5f)); + layer.SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_UI); + layer.SetProperty(Layer::Property::DEPTH_TEST, true); + window.Add(layer); // Main cube: // Make the demo scalable with different resolutions by basing // the cube size on a percentage of the window size. Vector2 windowSize = window.GetSize(); - float scaleSize( std::min( windowSize.width, windowSize.height ) ); - float cubeWidth( scaleSize * CUBE_WIDTH_SCALE ); - Vector3 cubeSize( cubeWidth, cubeWidth, cubeWidth ); + float scaleSize(std::min(windowSize.width, windowSize.height)); + float cubeWidth(scaleSize * CUBE_WIDTH_SCALE); + Vector3 cubeSize(cubeWidth, cubeWidth, cubeWidth); // Create the geometry for the cube, and the texture. - Geometry cubeGeometry = CreateCubeVertices( Vector3::ONE, false ); - TextureSet cubeTextureSet = CreateTextureSet( CUBE_TEXTURE ); + Geometry cubeGeometry = CreateCubeVertices(Vector3::ONE, false); + TextureSet cubeTextureSet = CreateTextureSet(CUBE_TEXTURE); // Create the cube object and add it. // Note: The cube is anchored around its base for animation purposes, so the position can be zero. - mCubes[ MAIN_CUBE ] = CreateMainCubeObject( cubeGeometry, cubeSize, cubeTextureSet ); - layer.Add( mCubes[ MAIN_CUBE ] ); + mCubes[MAIN_CUBE] = CreateMainCubeObject(cubeGeometry, cubeSize, cubeTextureSet); + layer.Add(mCubes[MAIN_CUBE]); // Floor: - float floorWidth( scaleSize * FLOOR_DIMENSION_SCALE.x ); - Vector3 floorSize( floorWidth, scaleSize * FLOOR_DIMENSION_SCALE.y, floorWidth ); + float floorWidth(scaleSize * FLOOR_DIMENSION_SCALE.x); + Vector3 floorSize(floorWidth, scaleSize * FLOOR_DIMENSION_SCALE.y, floorWidth); // Create the floor object using the cube geometry with a new size, and add it. - Actor floorObject( CreateFloorObject( cubeGeometry, floorSize ) ); - layer.Add( floorObject ); + Actor floorObject(CreateFloorObject(cubeGeometry, floorSize)); + layer.Add(floorObject); // Stencil: - Vector3 planeSize( floorWidth, floorWidth, 0.0f ); + Vector3 planeSize(floorWidth, floorWidth, 0.0f); // Create the stencil plane object, and add it. - Actor stencilPlaneObject( CreateStencilPlaneObject( planeSize ) ); - layer.Add( stencilPlaneObject ); + Actor stencilPlaneObject(CreateStencilPlaneObject(planeSize)); + layer.Add(stencilPlaneObject); // Reflection cube: // Create the reflection cube object and add it. // Note: The cube is anchored around its base for animation purposes, so the position can be zero. - mCubes[ REFLECTION_CUBE ] = CreateReflectionCubeObject( cubeSize, cubeTextureSet ); - layer.Add( mCubes[ REFLECTION_CUBE ] ); + mCubes[REFLECTION_CUBE] = CreateReflectionCubeObject(cubeSize, cubeTextureSet); + layer.Add(mCubes[REFLECTION_CUBE]); // Rotate the layer so we can see some of the top of the cube for a more 3D effect. - layer.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( -24.0f ), Degree( 0.0f ), Degree( 0.0f ) ) ); + layer.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(-24.0f), Degree(0.0f), Degree(0.0f))); // Set up the rotation on the Y axis. - mRotationAnimation = Animation::New( ANIMATION_ROTATION_DURATION ); + mRotationAnimation = Animation::New(ANIMATION_ROTATION_DURATION); float fullRotation = 360.0f; - mRotationAnimation.AnimateBy( Property( mCubes[ MAIN_CUBE ], Actor::Property::ORIENTATION ), - Quaternion( Degree( 0.0f ), Degree( fullRotation ), Degree( 0.0f ) ) ); - mRotationAnimation.AnimateBy( Property( floorObject, Actor::Property::ORIENTATION ), - Quaternion( Degree( 0.0f ), Degree( fullRotation ), Degree( 0.0f ) ) ); + mRotationAnimation.AnimateBy(Property(mCubes[MAIN_CUBE], Actor::Property::ORIENTATION), + Quaternion(Degree(0.0f), Degree(fullRotation), Degree(0.0f))); + mRotationAnimation.AnimateBy(Property(floorObject, Actor::Property::ORIENTATION), + Quaternion(Degree(0.0f), Degree(fullRotation), Degree(0.0f))); // Note the stencil is pre-rotated by 90 degrees on X, so we rotate relatively on its Z axis for an equivalent Y rotation. - mRotationAnimation.AnimateBy( Property( stencilPlaneObject, Actor::Property::ORIENTATION ), - Quaternion( Degree( 0.0f ), Degree( 0.0f ), Degree( fullRotation ) ) ); - mRotationAnimation.AnimateBy( Property( mCubes[ REFLECTION_CUBE ], Actor::Property::ORIENTATION ), - Quaternion( Degree( 0.0f ), Degree( fullRotation ), Degree( 0.0f ) ) ); - mRotationAnimation.SetLooping( true ); + mRotationAnimation.AnimateBy(Property(stencilPlaneObject, Actor::Property::ORIENTATION), + Quaternion(Degree(0.0f), Degree(0.0f), Degree(fullRotation))); + mRotationAnimation.AnimateBy(Property(mCubes[REFLECTION_CUBE], Actor::Property::ORIENTATION), + Quaternion(Degree(0.0f), Degree(fullRotation), Degree(0.0f))); + mRotationAnimation.SetLooping(true); // Set up the cube bouncing animation. - float totalTime = ANIMATION_BOUNCE_TOTAL_TIME; + float totalTime = ANIMATION_BOUNCE_TOTAL_TIME; float deformationTime = ANIMATION_BOUNCE_DEFORMATION_TIME; // Percentage based amounts allows the bounce and deformation to scale for different resolution screens. float deformationAmount = ANIMATION_BOUNCE_DEFORMATION_PERCENT / 100.0f; - float heightChange = ( cubeSize.y * ANIMATION_BOUNCE_HEIGHT_PERCENT ) / 100.0f; + float heightChange = (cubeSize.y * ANIMATION_BOUNCE_HEIGHT_PERCENT) / 100.0f; // Animation pre-calculations: - float halfTime = totalTime / 2.0f; + float halfTime = totalTime / 2.0f; float halfDeformationTime = deformationTime / 2.0f; // First position the cubes at the top of the animation cycle. - mCubes[ MAIN_CUBE ].SetProperty( Actor::Property::POSITION_Y, -heightChange ); - mCubes[ REFLECTION_CUBE ].SetProperty( Actor::Property::POSITION_Y, heightChange ); + mCubes[MAIN_CUBE].SetProperty(Actor::Property::POSITION_Y, -heightChange); + mCubes[REFLECTION_CUBE].SetProperty(Actor::Property::POSITION_Y, heightChange); - mBounceAnimation = Animation::New( totalTime ); + mBounceAnimation = Animation::New(totalTime); // The animations for the main and reflected cubes are almost identical, so we combine the code to do both. - for( int cube = 0; cube < 2; ++cube ) + for(int cube = 0; cube < 2; ++cube) { // If iterating on the reflection cube, adjust the heightChange variable so the below code can be reused. - if( cube == 1 ) + if(cube == 1) { heightChange = -heightChange; } // 1st TimePeriod: Start moving down with increasing speed, until it is time to distort the cube due to impact. - mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::POSITION_Y ), heightChange, AlphaFunction::EASE_IN_SQUARE, TimePeriod( 0.0f, halfTime - halfDeformationTime ) ); + mBounceAnimation.AnimateBy(Property(mCubes[cube], Actor::Property::POSITION_Y), heightChange, AlphaFunction::EASE_IN_SQUARE, TimePeriod(0.0f, halfTime - halfDeformationTime)); // 2nd TimePeriod: The cube is touching the floor, start deforming it - then un-deform it again. - mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::SCALE_X ), deformationAmount, AlphaFunction::BOUNCE, TimePeriod( halfTime - halfDeformationTime, deformationTime ) ); - mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::SCALE_Z ), deformationAmount, AlphaFunction::BOUNCE, TimePeriod( halfTime - halfDeformationTime, deformationTime ) ); - mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::SCALE_Y ), -deformationAmount, AlphaFunction::BOUNCE, TimePeriod( halfTime - halfDeformationTime, deformationTime ) ); + mBounceAnimation.AnimateBy(Property(mCubes[cube], Actor::Property::SCALE_X), deformationAmount, AlphaFunction::BOUNCE, TimePeriod(halfTime - halfDeformationTime, deformationTime)); + mBounceAnimation.AnimateBy(Property(mCubes[cube], Actor::Property::SCALE_Z), deformationAmount, AlphaFunction::BOUNCE, TimePeriod(halfTime - halfDeformationTime, deformationTime)); + mBounceAnimation.AnimateBy(Property(mCubes[cube], Actor::Property::SCALE_Y), -deformationAmount, AlphaFunction::BOUNCE, TimePeriod(halfTime - halfDeformationTime, deformationTime)); // 3rd TimePeriod: Start moving up with decreasing speed, until at the apex of the animation. - mBounceAnimation.AnimateBy( Property( mCubes[ cube ], Actor::Property::POSITION_Y ), -heightChange, AlphaFunction::EASE_OUT_SQUARE, TimePeriod( halfTime + halfDeformationTime, halfTime - halfDeformationTime ) ); + mBounceAnimation.AnimateBy(Property(mCubes[cube], Actor::Property::POSITION_Y), -heightChange, AlphaFunction::EASE_OUT_SQUARE, TimePeriod(halfTime + halfDeformationTime, halfTime - halfDeformationTime)); } - mBounceAnimation.SetLooping( true ); + mBounceAnimation.SetLooping(true); // Start the animations. mRotationAnimation.Play(); mBounceAnimation.Play(); // Respond to a click anywhere on the window - window.GetRootLayer().TouchedSignal().Connect( this, &RendererStencilExample::OnTouch ); + window.GetRootLayer().TouchedSignal().Connect(this, &RendererStencilExample::OnTouch); // Connect signals to allow Back and Escape to exit. - window.KeyEventSignal().Connect( this, &RendererStencilExample::OnKeyEvent ); + window.KeyEventSignal().Connect(this, &RendererStencilExample::OnKeyEvent); } private: - // Methods to setup each component of the 3D scene: /** @@ -273,32 +263,32 @@ private: * @param[in] textureSet A pre-existing TextureSet with a texture set up, to be applied to the cube * @return An actor set-up containing the main cube object */ - Actor CreateMainCubeObject( Geometry& geometry, Vector3 size, TextureSet& textureSet ) + Actor CreateMainCubeObject(Geometry& geometry, Vector3 size, TextureSet& textureSet) { Toolkit::Control container = Toolkit::Control::New(); - container.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER ); - container.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_CENTER ); - container.SetProperty( Actor::Property::SIZE, Vector2( size ) ); - container.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS ); + container.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER); + container.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_CENTER); + container.SetProperty(Actor::Property::SIZE, Vector2(size)); + container.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); // Create a renderer from the geometry and add the texture. - Renderer renderer = CreateRenderer( geometry, size, true, CUBE_COLOR ); - renderer.SetTextures( textureSet ); + Renderer renderer = CreateRenderer(geometry, size, true, CUBE_COLOR); + renderer.SetTextures(textureSet); // Setup the renderer properties: // We are writing to the color buffer & culling back faces (no stencil is used for the main cube). - renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR ); - renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK ); + renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR); + renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK); // We do need to write to the depth buffer as other objects need to appear underneath this cube. - renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON ); + renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON); // We do not need to test the depth buffer as we are culling the back faces. - renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::OFF ); + renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::OFF); // This object must be rendered 1st. - renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 0 * DEPTH_INDEX_GRANULARITY ); + renderer.SetProperty(Renderer::Property::DEPTH_INDEX, 0 * DEPTH_INDEX_GRANULARITY); - container.AddRenderer( renderer ); + container.AddRenderer(renderer); return container; } @@ -310,33 +300,33 @@ private: * @param[in] size The desired floor size * @return An actor set-up containing the floor object */ - Actor CreateFloorObject( Geometry& geometry, Vector3 size ) + Actor CreateFloorObject(Geometry& geometry, Vector3 size) { Toolkit::Control container = Toolkit::Control::New(); - container.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER ); - container.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER ); - container.SetProperty( Actor::Property::SIZE, Vector2( size ) ); - container.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS ); + container.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER); + container.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER); + container.SetProperty(Actor::Property::SIZE, Vector2(size)); + container.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); // Create a renderer from the geometry and add the texture. - TextureSet planeTextureSet = CreateTextureSet( FLOOR_TEXTURE ); - Renderer renderer = CreateRenderer( geometry, size, true, FLOOR_COLOR ); - renderer.SetTextures( planeTextureSet ); + TextureSet planeTextureSet = CreateTextureSet(FLOOR_TEXTURE); + Renderer renderer = CreateRenderer(geometry, size, true, FLOOR_COLOR); + renderer.SetTextures(planeTextureSet); // Setup the renderer properties: // We are writing to the color buffer & culling back faces as we are NOT doing depth write (no stencil is used for the floor). - renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR ); - renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK ); + renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR); + renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK); // We do not write to the depth buffer as its not needed. - renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF ); + renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF); // We do need to test the depth buffer as we need the floor to be underneath the cube. - renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON ); + renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON); // This object must be rendered 2nd. - renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 1 * DEPTH_INDEX_GRANULARITY ); + renderer.SetProperty(Renderer::Property::DEPTH_INDEX, 1 * DEPTH_INDEX_GRANULARITY); - container.AddRenderer( renderer ); + container.AddRenderer(renderer); return container; } @@ -348,43 +338,43 @@ private: * @param[in] size The desired plane size * @return An actor set-up containing the stencil-plane object */ - Actor CreateStencilPlaneObject( Vector3 size ) + Actor CreateStencilPlaneObject(Vector3 size) { Toolkit::Control container = Toolkit::Control::New(); - container.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER ); - container.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER ); - container.SetProperty( Actor::Property::SIZE, Vector2( size ) ); - container.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS ); + container.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + container.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + container.SetProperty(Actor::Property::SIZE, Vector2(size)); + container.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); // We rotate the plane as the geometry is created flat in X & Y. We want it to span X & Z axis. - container.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( -90.0f ), Degree( 0.0f ), Degree( 0.0f ) ) ); + container.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(-90.0f), Degree(0.0f), Degree(0.0f))); // Create geometry for a flat plane. - Geometry planeGeometry = CreatePlaneVertices( Vector2::ONE ); + Geometry planeGeometry = CreatePlaneVertices(Vector2::ONE); // Create a renderer from the geometry. - Renderer renderer = CreateRenderer( planeGeometry, size, false, Vector4::ONE ); + Renderer renderer = CreateRenderer(planeGeometry, size, false, Vector4::ONE); // Setup the renderer properties: // The stencil plane is only for stencilling. - renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL ); + renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::STENCIL); - renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS ); - renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE, 1 ); - renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_MASK, 0xFF ); - renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP ); - renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::KEEP ); - renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::REPLACE ); - renderer.SetProperty( Renderer::Property::STENCIL_MASK, 0xFF ); + renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS); + renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE, 1); + renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION_MASK, 0xFF); + renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP); + renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::KEEP); + renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::REPLACE); + renderer.SetProperty(Renderer::Property::STENCIL_MASK, 0xFF); // We don't want to write to the depth buffer, as this would block the reflection being drawn. - renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF ); + renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF); // We test the depth buffer as we want the stencil to only exist underneath the cube. - renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON ); + renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON); // This object must be rendered 3rd. - renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 2 * DEPTH_INDEX_GRANULARITY ); + renderer.SetProperty(Renderer::Property::DEPTH_INDEX, 2 * DEPTH_INDEX_GRANULARITY); - container.AddRenderer( renderer ); + container.AddRenderer(renderer); return container; } @@ -397,50 +387,50 @@ private: * @param[in] textureSet A pre-existing TextureSet with a texture set up, to be applied to the cube * @return An actor set-up containing the reflection cube object */ - Actor CreateReflectionCubeObject( Vector3 size, TextureSet& textureSet ) + Actor CreateReflectionCubeObject(Vector3 size, TextureSet& textureSet) { Toolkit::Control container = Toolkit::Control::New(); - container.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER ); - container.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER ); - container.SetProperty( Actor::Property::SIZE, Vector2( size ) ); - container.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS ); + container.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER); + container.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER); + container.SetProperty(Actor::Property::SIZE, Vector2(size)); + container.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); // Create the cube geometry of unity size. // The "true" specifies we want the texture UVs flipped vertically as this is the reflection cube. - Geometry reflectedCubeGeometry = CreateCubeVertices( Vector3::ONE, true ); + Geometry reflectedCubeGeometry = CreateCubeVertices(Vector3::ONE, true); // Create a renderer from the geometry and add the texture. - Renderer renderer = CreateRenderer( reflectedCubeGeometry, size, true, REFLECTION_COLOR ); - renderer.SetTextures( textureSet ); + Renderer renderer = CreateRenderer(reflectedCubeGeometry, size, true, REFLECTION_COLOR); + renderer.SetTextures(textureSet); // Setup the renderer properties: // Write to color buffer so reflection is visible. // Also enable the stencil buffer, as we will be testing against it to only draw to areas within the stencil. - renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR_STENCIL ); + renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR_STENCIL); // We cull to skip drawing the back faces. - renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK ); + renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK); // We use blending to blend the reflection with the floor texture. - renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON ); - renderer.SetProperty( Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::ADD ); - renderer.SetProperty( Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::ADD ); - renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE ); + renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON); + renderer.SetProperty(Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::ADD); + renderer.SetProperty(Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::ADD); + renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE); // Enable stencil. Here we only draw to areas within the stencil. - renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, StencilFunction::EQUAL ); - renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE, 1 ); - renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_MASK, 0xff ); + renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION, StencilFunction::EQUAL); + renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE, 1); + renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION_MASK, 0xff); // Don't write to the stencil. - renderer.SetProperty( Renderer::Property::STENCIL_MASK, 0x00 ); + renderer.SetProperty(Renderer::Property::STENCIL_MASK, 0x00); // We don't need to write to the depth buffer, as we are culling. - renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF ); + renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF); // We need to test the depth buffer as we need the reflection to be underneath the cube. - renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON ); + renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON); // This object must be rendered last. - renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 3 * DEPTH_INDEX_GRANULARITY ); + renderer.SetProperty(Renderer::Property::DEPTH_INDEX, 3 * DEPTH_INDEX_GRANULARITY); - container.AddRenderer( renderer ); + container.AddRenderer(renderer); return container; } @@ -452,22 +442,22 @@ private: * @param[in] indices The object indices * @return A geometry object */ - Geometry CreateTexturedGeometry( Vector& vertices, Vector& indices ) + Geometry CreateTexturedGeometry(Vector& vertices, Vector& indices) { // Vertices Property::Map vertexFormat; vertexFormat[POSITION] = Property::VECTOR3; - vertexFormat[NORMAL] = Property::VECTOR3; - vertexFormat[TEXTURE] = Property::VECTOR2; + vertexFormat[NORMAL] = Property::VECTOR3; + vertexFormat[TEXTURE] = Property::VECTOR2; - VertexBuffer surfaceVertices = VertexBuffer::New( vertexFormat ); - surfaceVertices.SetData( &vertices[0u], vertices.Size() ); + VertexBuffer surfaceVertices = VertexBuffer::New(vertexFormat); + surfaceVertices.SetData(&vertices[0u], vertices.Size()); Geometry geometry = Geometry::New(); - geometry.AddVertexBuffer( surfaceVertices ); + geometry.AddVertexBuffer(surfaceVertices); // Indices for triangle formulation - geometry.SetIndexBuffer( &indices[0u], indices.Size() ); + geometry.SetIndexBuffer(&indices[0u], indices.Size()); return geometry; } @@ -479,28 +469,28 @@ private: * @param[in] color The base color for the renderer * @return A renderer object */ - Renderer CreateRenderer( Geometry geometry, Vector3 dimensions, bool textured, Vector4 color ) + Renderer CreateRenderer(Geometry geometry, Vector3 dimensions, bool textured, Vector4 color) { - Window window = mApplication.GetWindow(); + Window window = mApplication.GetWindow(); Vector2 windowSize = window.GetSize(); - Shader shader; + Shader shader; - if( textured ) + if(textured) { - shader = Shader::New( VERTEX_SHADER_TEXTURED, FRAGMENT_SHADER_TEXTURED ); + shader = Shader::New(VERTEX_SHADER_TEXTURED, FRAGMENT_SHADER_TEXTURED); } else { - shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ); + shader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER); } // Here we modify the light position based on half the window size as a pre-calculation step. // This avoids the work having to be done in the shader. - shader.RegisterProperty( LIGHT_POSITION_UNIFORM_NAME, Vector3( -windowSize.width / 2.0f, -windowSize.width / 2.0f, 1000.0f ) ); - shader.RegisterProperty( COLOR_UNIFORM_NAME, color ); - shader.RegisterProperty( OBJECT_DIMENSIONS_UNIFORM_NAME, dimensions ); + shader.RegisterProperty(LIGHT_POSITION_UNIFORM_NAME, Vector3(-windowSize.width / 2.0f, -windowSize.width / 2.0f, 1000.0f)); + shader.RegisterProperty(COLOR_UNIFORM_NAME, color); + shader.RegisterProperty(OBJECT_DIMENSIONS_UNIFORM_NAME, dimensions); - return Renderer::New( geometry, shader ); + return Renderer::New(geometry, shader); } /** @@ -508,16 +498,16 @@ private: * @param[in] url An image URL * @return A TextureSet object */ - TextureSet CreateTextureSet( const char* url ) + TextureSet CreateTextureSet(const char* url) { TextureSet textureSet = TextureSet::New(); - if( textureSet ) + if(textureSet) { - Texture texture = DemoHelper::LoadTexture( url ); - if( texture ) + Texture texture = DemoHelper::LoadTexture(url); + if(texture) { - textureSet.SetTexture( 0u, texture ); + textureSet.SetTexture(0u, texture); } } @@ -532,29 +522,29 @@ private: * @param[in] dimensions The desired plane dimensions * @return A Geometry object */ - Geometry CreatePlaneVertices( Vector2 dimensions ) + Geometry CreatePlaneVertices(Vector2 dimensions) { Vector vertices; Vector indices; - vertices.Resize( 4u ); - indices.Resize( 6u ); + vertices.Resize(4u); + indices.Resize(6u); float scaledX = 0.5f * dimensions.x; float scaledY = 0.5f * dimensions.y; - vertices[0].position = Vector3( -scaledX, -scaledY, 0.0f ); - vertices[0].textureCoord = Vector2( 0.0, 0.0f ); - vertices[1].position = Vector3( scaledX, -scaledY, 0.0f ); - vertices[1].textureCoord = Vector2( 1.0, 0.0f ); - vertices[2].position = Vector3( scaledX, scaledY, 0.0f ); - vertices[2].textureCoord = Vector2( 1.0, 1.0f ); - vertices[3].position = Vector3( -scaledX, scaledY, 0.0f ); - vertices[3].textureCoord = Vector2( 0.0, 1.0f ); + vertices[0].position = Vector3(-scaledX, -scaledY, 0.0f); + vertices[0].textureCoord = Vector2(0.0, 0.0f); + vertices[1].position = Vector3(scaledX, -scaledY, 0.0f); + vertices[1].textureCoord = Vector2(1.0, 0.0f); + vertices[2].position = Vector3(scaledX, scaledY, 0.0f); + vertices[2].textureCoord = Vector2(1.0, 1.0f); + vertices[3].position = Vector3(-scaledX, scaledY, 0.0f); + vertices[3].textureCoord = Vector2(0.0, 1.0f); // All vertices have the same normal. - for( int i = 0; i < 4; ++i ) + for(int i = 0; i < 4; ++i) { - vertices[i].normal = Vector3( 0.0f, 0.0f, -1.0f ); + vertices[i].normal = Vector3(0.0f, 0.0f, -1.0f); } indices[0] = 0; @@ -565,7 +555,7 @@ private: indices[5] = 0; // Use the helper method to create the geometry object. - return CreateTexturedGeometry( vertices, indices ); + return CreateTexturedGeometry(vertices, indices); } /** @@ -574,55 +564,55 @@ private: * @param[in] reflectVerticalUVs Set to True to force the UVs to be vertically flipped * @return A Geometry object */ - Geometry CreateCubeVertices( Vector3 dimensions, bool reflectVerticalUVs ) + Geometry CreateCubeVertices(Vector3 dimensions, bool reflectVerticalUVs) { Vector vertices; Vector indices; - int vertexIndex = 0u; // Tracks progress through vertices. - float scaledX = 0.5f * dimensions.x; - float scaledY = 0.5f * dimensions.y; - float scaledZ = 0.5f * dimensions.z; - float verticalTextureCoord = reflectVerticalUVs ? 0.0f : 1.0f; - - vertices.Resize( 4u * 6u ); // 4 vertices x 6 faces - - Vector positions; // Stores vertex positions, which are shared between vertexes at the same position but with a different normal. - positions.Resize( 8u ); - Vector normals; // Stores normals, which are shared between vertexes of the same face. - normals.Resize( 6u ); - - positions[0] = Vector3( -scaledX, scaledY, -scaledZ ); - positions[1] = Vector3( scaledX, scaledY, -scaledZ ); - positions[2] = Vector3( scaledX, scaledY, scaledZ ); - positions[3] = Vector3( -scaledX, scaledY, scaledZ ); - positions[4] = Vector3( -scaledX, -scaledY, -scaledZ ); - positions[5] = Vector3( scaledX, -scaledY, -scaledZ ); - positions[6] = Vector3( scaledX, -scaledY, scaledZ ); - positions[7] = Vector3( -scaledX, -scaledY, scaledZ ); - - normals[0] = Vector3( 0, 1, 0 ); - normals[1] = Vector3( 0, 0, -1 ); - normals[2] = Vector3( 1, 0, 0 ); - normals[3] = Vector3( 0, 0, 1 ); - normals[4] = Vector3( -1, 0, 0 ); - normals[5] = Vector3( 0, -1, 0 ); + int vertexIndex = 0u; // Tracks progress through vertices. + float scaledX = 0.5f * dimensions.x; + float scaledY = 0.5f * dimensions.y; + float scaledZ = 0.5f * dimensions.z; + float verticalTextureCoord = reflectVerticalUVs ? 0.0f : 1.0f; + + vertices.Resize(4u * 6u); // 4 vertices x 6 faces + + Vector positions; // Stores vertex positions, which are shared between vertexes at the same position but with a different normal. + positions.Resize(8u); + Vector normals; // Stores normals, which are shared between vertexes of the same face. + normals.Resize(6u); + + positions[0] = Vector3(-scaledX, scaledY, -scaledZ); + positions[1] = Vector3(scaledX, scaledY, -scaledZ); + positions[2] = Vector3(scaledX, scaledY, scaledZ); + positions[3] = Vector3(-scaledX, scaledY, scaledZ); + positions[4] = Vector3(-scaledX, -scaledY, -scaledZ); + positions[5] = Vector3(scaledX, -scaledY, -scaledZ); + positions[6] = Vector3(scaledX, -scaledY, scaledZ); + positions[7] = Vector3(-scaledX, -scaledY, scaledZ); + + normals[0] = Vector3(0, 1, 0); + normals[1] = Vector3(0, 0, -1); + normals[2] = Vector3(1, 0, 0); + normals[3] = Vector3(0, 0, 1); + normals[4] = Vector3(-1, 0, 0); + normals[5] = Vector3(0, -1, 0); // Top face, upward normals. - for( int i = 0; i < 4; ++i, ++vertexIndex ) + for(int i = 0; i < 4; ++i, ++vertexIndex) { vertices[vertexIndex].position = positions[i]; - vertices[vertexIndex].normal = normals[0]; + vertices[vertexIndex].normal = normals[0]; // The below logic forms the correct U/V pairs for a quad when "i" goes from 0 to 3. - vertices[vertexIndex].textureCoord = Vector2( ( i == 1 || i == 2 ) ? 1.0f : 0.0f, ( i == 2 || i == 3 ) ? 1.0f : 0.0f ); + vertices[vertexIndex].textureCoord = Vector2((i == 1 || i == 2) ? 1.0f : 0.0f, (i == 2 || i == 3) ? 1.0f : 0.0f); } // Top face, outward normals. - for( int i = 0; i < 4; ++i, vertexIndex += 2 ) + for(int i = 0; i < 4; ++i, vertexIndex += 2) { vertices[vertexIndex].position = positions[i]; - vertices[vertexIndex].normal = normals[i + 1]; + vertices[vertexIndex].normal = normals[i + 1]; - if( i == 3 ) + if(i == 3) { // End, so loop around. vertices[vertexIndex + 1].position = positions[0]; @@ -633,20 +623,20 @@ private: } vertices[vertexIndex + 1].normal = normals[i + 1]; - vertices[vertexIndex].textureCoord = Vector2( 0.0f, verticalTextureCoord ); - vertices[vertexIndex+1].textureCoord = Vector2( 1.0f, verticalTextureCoord ); + vertices[vertexIndex].textureCoord = Vector2(0.0f, verticalTextureCoord); + vertices[vertexIndex + 1].textureCoord = Vector2(1.0f, verticalTextureCoord); } // Flip the vertical texture coord for the UV values of the bottom points. verticalTextureCoord = 1.0f - verticalTextureCoord; // Bottom face, outward normals. - for( int i = 0; i < 4; ++i, vertexIndex += 2 ) + for(int i = 0; i < 4; ++i, vertexIndex += 2) { vertices[vertexIndex].position = positions[i + 4]; - vertices[vertexIndex].normal = normals[i + 1]; + vertices[vertexIndex].normal = normals[i + 1]; - if( i == 3 ) + if(i == 3) { // End, so loop around. vertices[vertexIndex + 1].position = positions[4]; @@ -657,26 +647,26 @@ private: } vertices[vertexIndex + 1].normal = normals[i + 1]; - vertices[vertexIndex].textureCoord = Vector2( 0.0f, verticalTextureCoord ); - vertices[vertexIndex+1].textureCoord = Vector2( 1.0f, verticalTextureCoord ); + vertices[vertexIndex].textureCoord = Vector2(0.0f, verticalTextureCoord); + vertices[vertexIndex + 1].textureCoord = Vector2(1.0f, verticalTextureCoord); } // Bottom face, downward normals. - for( int i = 0; i < 4; ++i, ++vertexIndex ) + for(int i = 0; i < 4; ++i, ++vertexIndex) { // Reverse positions for bottom face to keep triangles clockwise (for culling). - vertices[vertexIndex].position = positions[ 7 - i ]; - vertices[vertexIndex].normal = normals[5]; + vertices[vertexIndex].position = positions[7 - i]; + vertices[vertexIndex].normal = normals[5]; // The below logic forms the correct U/V pairs for a quad when "i" goes from 0 to 3. - vertices[vertexIndex].textureCoord = Vector2( ( i == 1 || i == 2 ) ? 1.0f : 0.0f, ( i == 2 || i == 3 ) ? 1.0f : 0.0f ); + vertices[vertexIndex].textureCoord = Vector2((i == 1 || i == 2) ? 1.0f : 0.0f, (i == 2 || i == 3) ? 1.0f : 0.0f); } // Create cube indices. - int triangleIndex = 0u; //Track progress through indices. - indices.Resize( 3u * 12u ); // 3 points x 12 triangles. + int triangleIndex = 0u; //Track progress through indices. + indices.Resize(3u * 12u); // 3 points x 12 triangles. // Top face. - indices[triangleIndex] = 0; + indices[triangleIndex] = 0; indices[triangleIndex + 1] = 1; indices[triangleIndex + 2] = 2; indices[triangleIndex + 3] = 2; @@ -684,13 +674,13 @@ private: indices[triangleIndex + 5] = 0; triangleIndex += 6; - int topFaceStart = 4u; + int topFaceStart = 4u; int bottomFaceStart = topFaceStart + 8u; // Side faces. - for( int i = 0; i < 8; i += 2, triangleIndex += 6 ) + for(int i = 0; i < 8; i += 2, triangleIndex += 6) { - indices[triangleIndex ] = i + topFaceStart; + indices[triangleIndex] = i + topFaceStart; indices[triangleIndex + 1] = i + bottomFaceStart + 1; indices[triangleIndex + 2] = i + topFaceStart + 1; indices[triangleIndex + 3] = i + topFaceStart; @@ -699,7 +689,7 @@ private: } // Bottom face. - indices[triangleIndex] = 20; + indices[triangleIndex] = 20; indices[triangleIndex + 1] = 21; indices[triangleIndex + 2] = 22; indices[triangleIndex + 3] = 22; @@ -707,7 +697,7 @@ private: indices[triangleIndex + 5] = 20; // Use the helper method to create the geometry object. - return CreateTexturedGeometry( vertices, indices ); + return CreateTexturedGeometry(vertices, indices); } // Signal handlers: @@ -718,7 +708,7 @@ private: * @param[in] touch The touch information * @return True if the event has been handled */ - bool OnTouch( Actor actor, const TouchEvent& touch ) + bool OnTouch(Actor actor, const TouchEvent& touch) { // Quit the application. mApplication.Quit(); @@ -729,11 +719,11 @@ private: * @brief OnKeyEvent signal handler. * @param[in] event The key event information */ - void OnKeyEvent( const KeyEvent& event ) + void OnKeyEvent(const KeyEvent& event) { - if( event.GetState() == KeyEvent::DOWN ) + if(event.GetState() == KeyEvent::DOWN) { - if ( IsKey( event, Dali::DALI_KEY_ESCAPE ) || IsKey( event, Dali::DALI_KEY_BACK ) ) + if(IsKey(event, Dali::DALI_KEY_ESCAPE) || IsKey(event, Dali::DALI_KEY_BACK)) { mApplication.Quit(); } @@ -741,21 +731,20 @@ private: } private: - // Member variables: - Application& mApplication; ///< The DALi application object - Toolkit::Control mView; ///< The view used to show the background + Application& mApplication; ///< The DALi application object + Toolkit::Control mView; ///< The view used to show the background - Animation mRotationAnimation; ///< The animation to spin the cube & floor - Animation mBounceAnimation; ///< The animation to bounce the cube - Actor mCubes[2]; ///< The cube object containers + Animation mRotationAnimation; ///< The animation to spin the cube & floor + Animation mBounceAnimation; ///< The animation to bounce the cube + Actor mCubes[2]; ///< The cube object containers }; -int DALI_EXPORT_API main( int argc, char **argv ) +int DALI_EXPORT_API main(int argc, char** argv) { - Application application = Application::New( &argc, &argv ); - RendererStencilExample example( application ); + Application application = Application::New(&argc, &argv); + RendererStencilExample example(application); application.MainLoop(); return 0; }