X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-Renderer.cpp;h=222885ab12b2b492214aedccd15c550ed2e021f5;hb=e97ce3673ceda34d252bb13a320a7947a552c1ac;hp=ce5dd3fe570a6bbef5854b02f53289cf3d371892;hpb=0ded984694c9954fba82b058adb9f9b8deb901a3;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/automated-tests/src/dali/utc-Dali-Renderer.cpp b/automated-tests/src/dali/utc-Dali-Renderer.cpp index ce5dd3f..222885a 100644 --- a/automated-tests/src/dali/utc-Dali-Renderer.cpp +++ b/automated-tests/src/dali/utc-Dali-Renderer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * Copyright (c) 2019 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,12 +16,18 @@ */ // EXTERNAL INCLUDES +#include +#include + #include #include +#include #include +#include // INTERNAL INCLUDES #include +#include #include using namespace Dali; @@ -34,8 +40,38 @@ const BlendFactor::Type DEFAULT_BLEND_FACTOR_DEST_RGB( BlendFactor::ONE_MINU const BlendFactor::Type DEFAULT_BLEND_FACTOR_SRC_ALPHA( BlendFactor::ONE ); const BlendFactor::Type DEFAULT_BLEND_FACTOR_DEST_ALPHA( BlendFactor::ONE_MINUS_SRC_ALPHA ); -const BlendEquation::Type DEFAULT_BLEND_EQUATION_RGB( BlendEquation::ADD ); -const BlendEquation::Type DEFAULT_BLEND_EQUATION_ALPHA( BlendEquation::ADD ); +const BlendEquation::Type DEFAULT_BLEND_EQUATION_RGB( BlendEquation::ADD ); +const BlendEquation::Type DEFAULT_BLEND_EQUATION_ALPHA( BlendEquation::ADD ); + +/** + * @brief Get GL stencil test enumeration value as a string. + * @return The string representation of the value of GL_STENCIL_TEST + */ +std::string GetStencilTestString(void) +{ + std::stringstream stream; + stream << GL_STENCIL_TEST; + return stream.str(); +} + +/** + * @brief Get GL depth test enumeration value as a string. + * @return The string representation of the value of GL_DEPTH_TEST + */ +std::string GetDepthTestString(void) +{ + std::stringstream stream; + stream << GL_DEPTH_TEST; + return stream.str(); +} + +void ResetDebugAndFlush( TestApplication& application, TraceCallStack& glEnableDisableStack, TraceCallStack& glStencilFunctionStack ) +{ + glEnableDisableStack.Reset(); + glStencilFunctionStack.Reset(); + application.SendNotification(); + application.Render(); +} void TestConstraintNoBlue( Vector4& current, const PropertyInputContainer& inputs ) { @@ -54,7 +90,6 @@ void renderer_test_cleanup(void) test_return_value = TET_PASS; } - int UtcDaliRendererNew01(void) { TestApplication application; @@ -129,6 +164,85 @@ int UtcDaliRendererDownCast02(void) END_TEST; } +// using a template to auto deduce the parameter types +template< typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8> +void TEST_RENDERER_PROPERTY( P1 renderer, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION ) +{ + DALI_TEST_EQUALS( renderer.GetPropertyName( enumName ), stringName, LOCATION ); + DALI_TEST_EQUALS( renderer.GetPropertyIndex( stringName ), static_cast(enumName), LOCATION ); + DALI_TEST_EQUALS( renderer.GetPropertyType( enumName ), type, LOCATION ); + DALI_TEST_EQUALS( renderer.IsPropertyWritable( enumName ), isWriteable, LOCATION ); + DALI_TEST_EQUALS( renderer.IsPropertyAnimatable( enumName ), isAnimateable, LOCATION ); + DALI_TEST_EQUALS( renderer.IsPropertyAConstraintInput( enumName ), isConstraintInput, LOCATION ); +} + +int UtcDaliRendererDefaultProperties(void) +{ + TestApplication application; +/* from renderer-impl.cpp + DALI_PROPERTY( "depthIndex", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_INDEX ) + DALI_PROPERTY( "faceCullingMode", INTEGER, true, false, false, Dali::Renderer::Property::FACE_CULLING_MODE ) + DALI_PROPERTY( "blendMode", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_MODE ) + DALI_PROPERTY( "blendEquationRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_EQUATION_RGB ) + DALI_PROPERTY( "blendEquationAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_EQUATION_ALPHA ) + DALI_PROPERTY( "blendFactorSrcRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB ) + DALI_PROPERTY( "blendFactorDestRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB ) + DALI_PROPERTY( "blendFactorSrcAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA ) + DALI_PROPERTY( "blendFactorDestAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA ) + DALI_PROPERTY( "blendColor", VECTOR4, true, false, false, Dali::Renderer::Property::BLEND_COLOR ) + DALI_PROPERTY( "blendPreMultipliedAlpha", BOOLEAN, true, false, false, Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA ) + DALI_PROPERTY( "indexRangeFirst", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_FIRST ) + DALI_PROPERTY( "indexRangeCount", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_COUNT ) + DALI_PROPERTY( "depthWriteMode", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_WRITE_MODE ) + DALI_PROPERTY( "depthFunction", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_FUNCTION ) + DALI_PROPERTY( "depthTestMode", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_TEST_MODE ) + DALI_PROPERTY( "renderMode", INTEGER, true, false, false, Dali::Renderer::Property::RENDER_MODE ) + DALI_PROPERTY( "stencilFunction", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_FUNCTION ) + DALI_PROPERTY( "stencilFunctionMask", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_FUNCTION_MASK ) + DALI_PROPERTY( "stencilFunctionReference", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE ) + DALI_PROPERTY( "stencilMask", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_MASK ) + DALI_PROPERTY( "stencilOperationOnFail", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL ) + DALI_PROPERTY( "stencilOperationOnZFail", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL ) + DALI_PROPERTY( "stencilOperationOnZPass", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS ) + DALI_PROPERTY( "opacity", FLOAT, true, true, true, Dali::DevelRenderer::Property::OPACITY ) + DALI_PROPERTY( "renderingBehavior", INTEGER, true, false, false, Dali::DevelRenderer::Property::RENDERING_BEHAVIOR ) +*/ + + Geometry geometry = CreateQuadGeometry(); + Shader shader = CreateShader(); + Renderer renderer = Renderer::New(geometry, shader); + DALI_TEST_EQUALS( renderer.GetPropertyCount(), 26, TEST_LOCATION ); + + TEST_RENDERER_PROPERTY( renderer, "depthIndex", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_INDEX, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "faceCullingMode", Property::INTEGER, true, false, false, Renderer::Property::FACE_CULLING_MODE, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "blendMode", Property::INTEGER, true, false, false, Renderer::Property::BLEND_MODE, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "blendEquationRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_EQUATION_RGB, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "blendEquationAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_EQUATION_ALPHA, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "blendFactorSrcRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_SRC_RGB, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "blendFactorDestRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_DEST_RGB, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "blendFactorSrcAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "blendFactorDestAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "blendColor", Property::VECTOR4, true, false, false, Renderer::Property::BLEND_COLOR, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "blendPreMultipliedAlpha", Property::BOOLEAN, true, false, false, Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "indexRangeFirst", Property::INTEGER, true, false, false, Renderer::Property::INDEX_RANGE_FIRST, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "indexRangeCount", Property::INTEGER, true, false, false, Renderer::Property::INDEX_RANGE_COUNT, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "depthWriteMode", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_WRITE_MODE, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "depthFunction", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_FUNCTION, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "depthTestMode", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_TEST_MODE, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "renderMode", Property::INTEGER, true, false, false, Renderer::Property::RENDER_MODE, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "stencilFunction", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "stencilFunctionMask", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION_MASK, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "stencilFunctionReference",Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION_REFERENCE, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "stencilMask", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_MASK, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "stencilOperationOnFail", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_FAIL, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "stencilOperationOnZFail", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "stencilOperationOnZPass", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "opacity", Property::FLOAT, true, true, true, DevelRenderer::Property::OPACITY, TEST_LOCATION ); + TEST_RENDERER_PROPERTY( renderer, "renderingBehavior", Property::INTEGER, true, false, false, DevelRenderer::Property::RENDERING_BEHAVIOR, TEST_LOCATION ); + + END_TEST; +} + int UtcDaliRendererSetGetGeometry(void) { TestApplication application; @@ -225,15 +339,21 @@ int UtcDaliRendererSetGetDepthIndex(void) renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 1 ); + DALI_TEST_EQUALS( renderer.GetProperty(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty(Renderer::Property::DEPTH_INDEX), 0, TEST_LOCATION ); + application.SendNotification(); application.Render(0); - DALI_TEST_EQUALS( renderer.GetProperty(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION ); renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 10 ); + DALI_TEST_EQUALS( renderer.GetProperty(Renderer::Property::DEPTH_INDEX), 10, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION ); + application.SendNotification(); application.Render(0); - DALI_TEST_EQUALS( renderer.GetProperty(Renderer::Property::DEPTH_INDEX), 10, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty(Renderer::Property::DEPTH_INDEX), 10, TEST_LOCATION ); END_TEST; } @@ -334,7 +454,7 @@ int UtcDaliRendererBlendOptions01(void) Actor actor = Actor::New(); // set a transparent actor color so that blending is enabled - actor.SetOpacity( 0.5f ); + actor.SetProperty( DevelActor::Property::OPACITY, 0.5f ); actor.AddRenderer(renderer); actor.SetSize(400, 400); Stage::GetCurrent().Add(actor); @@ -379,7 +499,7 @@ int UtcDaliRendererBlendOptions02(void) Renderer renderer = Renderer::New( geometry, shader ); Actor actor = Actor::New(); - actor.SetOpacity( 0.5f ); // enable blending + actor.SetProperty( DevelActor::Property::OPACITY, 0.5f ); // enable blending actor.AddRenderer(renderer); actor.SetSize(400, 400); Stage::GetCurrent().Add(actor); @@ -450,7 +570,7 @@ int UtcDaliRendererBlendOptions04(void) Renderer renderer = Renderer::New( geometry, shader ); Actor actor = Actor::New(); - actor.SetOpacity( 0.1f ); + actor.SetProperty( DevelActor::Property::OPACITY, 0.1f ); actor.AddRenderer(renderer); actor.SetSize(400, 400); Stage::GetCurrent().Add(actor); @@ -495,7 +615,7 @@ int UtcDaliRendererSetBlendMode01(void) Renderer renderer = Renderer::New( geometry, shader ); Actor actor = Actor::New(); - actor.SetOpacity( 0.98f ); + actor.SetProperty( DevelActor::Property::OPACITY, 0.98f ); actor.AddRenderer(renderer); actor.SetSize(400, 400); Stage::GetCurrent().Add(actor); @@ -516,6 +636,41 @@ int UtcDaliRendererSetBlendMode01(void) END_TEST; } +int UtcDaliRendererSetBlendMode01b(void) +{ + TestApplication application; + + tet_infoline("Test setting the blend mode to on with an transparent color renders with blending enabled"); + + Geometry geometry = CreateQuadGeometry(); + Shader shader = CreateShader(); + Renderer renderer = Renderer::New( geometry, shader ); + + Actor actor = Actor::New(); + actor.SetProperty( DevelActor::Property::OPACITY, 0.0f ); + actor.AddRenderer(renderer); + actor.SetSize(400, 400); + Stage::GetCurrent().Add(actor); + + renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON); + + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + glAbstraction.EnableEnableDisableCallTrace(true); + glAbstraction.EnableDrawCallTrace( true ); + + application.SendNotification(); + application.Render(); + + TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace(); + std::ostringstream blendStr; + blendStr << GL_BLEND; + DALI_TEST_CHECK( !glEnableStack.FindMethod( "Enable" ) ); + + DALI_TEST_CHECK( !glAbstraction.GetDrawTrace().FindMethod( "DrawElements" ) ); + + END_TEST; +} + int UtcDaliRendererSetBlendMode02(void) { TestApplication application; @@ -527,7 +682,7 @@ int UtcDaliRendererSetBlendMode02(void) Renderer renderer = Renderer::New( geometry, shader ); Actor actor = Actor::New(); - actor.SetOpacity( 0.15f ); + actor.SetProperty( DevelActor::Property::OPACITY, 0.15f ); actor.AddRenderer(renderer); actor.SetSize(400, 400); Stage::GetCurrent().Add(actor); @@ -559,7 +714,7 @@ int UtcDaliRendererSetBlendMode03(void) Renderer renderer = Renderer::New( geometry, shader ); Actor actor = Actor::New(); - actor.SetOpacity( 0.75f ); + actor.SetProperty( DevelActor::Property::OPACITY, 0.75f ); actor.AddRenderer(renderer); actor.SetSize(400, 400); Stage::GetCurrent().Add(actor); @@ -624,7 +779,7 @@ int UtcDaliRendererSetBlendMode04b(void) Actor actor = Actor::New(); actor.AddRenderer(renderer); actor.SetSize(400, 400); - actor.SetColor( Vector4(1.0f, 0.0f, 1.0f, 0.5f) ); + actor.SetProperty( Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 0.5f) ); Stage::GetCurrent().Add(actor); renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::AUTO); @@ -656,7 +811,7 @@ int UtcDaliRendererSetBlendMode04c(void) Actor actor = Actor::New(); actor.AddRenderer(renderer); actor.SetSize(400, 400); - actor.SetColor( Color::MAGENTA ); + actor.SetProperty( Actor::Property::COLOR, Color::MAGENTA ); Stage::GetCurrent().Add(actor); renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::AUTO); @@ -716,7 +871,7 @@ int UtcDaliRendererSetBlendMode06(void) tet_infoline("Test setting the blend mode to auto with an opaque color and an image without an alpha channel and a shader with the hint OUTPUT_IS_TRANSPARENT renders with blending enabled"); Geometry geometry = CreateQuadGeometry(); - Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_TRANSPARENT ); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::Hint::OUTPUT_IS_TRANSPARENT ); Renderer renderer = Renderer::New( geometry, shader ); @@ -822,13 +977,23 @@ int UtcDaliRendererSetBlendColor(void) TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); renderer.SetProperty( Renderer::Property::BLEND_COLOR, Color::TRANSPARENT ); + application.SendNotification(); application.Render(); + + DALI_TEST_EQUALS( renderer.GetProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION ); DALI_TEST_EQUALS( glAbstraction.GetLastBlendColor(), Color::TRANSPARENT, TEST_LOCATION ); renderer.SetProperty( Renderer::Property::BLEND_COLOR, Color::MAGENTA ); + + DALI_TEST_EQUALS( renderer.GetProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION ); + application.SendNotification(); application.Render(); + + DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION ); DALI_TEST_EQUALS( glAbstraction.GetLastBlendColor(), Color::MAGENTA, TEST_LOCATION ); Vector4 color( 0.1f, 0.2f, 0.3f, 0.4f ); @@ -879,7 +1044,7 @@ int UtcDaliRendererPreMultipledAlpha(void) Actor actor = Actor::New(); actor.AddRenderer(renderer); actor.SetSize(400, 400); - actor.SetColor( Vector4(1.0f, 0.0f, 1.0f, 0.5f) ); + actor.SetProperty( Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 0.5f) ); Stage::GetCurrent().Add(actor); Property::Value value = renderer.GetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA ); @@ -905,7 +1070,8 @@ int UtcDaliRendererPreMultipledAlpha(void) DALI_TEST_CHECK( gl.GetUniformValue( "uColor", actualValue ) ); DALI_TEST_EQUALS( actualValue, Vector4(1.0f, 0.0f, 1.0f, 0.5f), TEST_LOCATION ); - renderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true); + // Enable pre-multiplied alpha + renderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true ); application.SendNotification(); application.Render(); @@ -914,6 +1080,10 @@ int UtcDaliRendererPreMultipledAlpha(void) DALI_TEST_CHECK( value.Get( preMultipliedAlpha ) ); DALI_TEST_CHECK( preMultipliedAlpha ); + value = renderer.GetCurrentProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA ); + DALI_TEST_CHECK( value.Get( preMultipliedAlpha ) ); + DALI_TEST_CHECK( preMultipliedAlpha ); + srcFactorRgb = renderer.GetProperty( Renderer::Property::BLEND_FACTOR_SRC_RGB ); destFactorRgb = renderer.GetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB ); srcFactorAlpha = renderer.GetProperty( Renderer::Property::BLEND_FACTOR_SRC_ALPHA ); @@ -922,11 +1092,38 @@ int UtcDaliRendererPreMultipledAlpha(void) DALI_TEST_EQUALS( (int)BlendFactor::ONE, srcFactorRgb, TEST_LOCATION ); DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb, TEST_LOCATION ); DALI_TEST_EQUALS( (int)BlendFactor::ONE, srcFactorAlpha, TEST_LOCATION ); - DALI_TEST_EQUALS( (int)BlendFactor::ONE, destFactorAlpha, TEST_LOCATION ); + DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION ); DALI_TEST_CHECK( gl.GetUniformValue( "uColor", actualValue ) ); DALI_TEST_EQUALS( actualValue, Vector4(0.5f, 0.0f, 0.5f, 0.5f), TEST_LOCATION ); + // Disable pre-multiplied alpha again + renderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, false ); + + application.SendNotification(); + application.Render(); + + value = renderer.GetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA ); + DALI_TEST_CHECK( value.Get( preMultipliedAlpha ) ); + DALI_TEST_CHECK( !preMultipliedAlpha ); + + value = renderer.GetCurrentProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA ); + DALI_TEST_CHECK( value.Get( preMultipliedAlpha ) ); + DALI_TEST_CHECK( !preMultipliedAlpha ); + + srcFactorRgb = renderer.GetProperty( Renderer::Property::BLEND_FACTOR_SRC_RGB ); + destFactorRgb = renderer.GetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB ); + srcFactorAlpha = renderer.GetProperty( Renderer::Property::BLEND_FACTOR_SRC_ALPHA ); + destFactorAlpha = renderer.GetProperty( Renderer::Property::BLEND_FACTOR_DEST_ALPHA ); + + DALI_TEST_EQUALS( (int)BlendFactor::SRC_ALPHA, srcFactorRgb, TEST_LOCATION ); + DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb, TEST_LOCATION ); + DALI_TEST_EQUALS( (int)BlendFactor::ONE, srcFactorAlpha, TEST_LOCATION ); + DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION ); + + DALI_TEST_CHECK( gl.GetUniformValue( "uColor", actualValue ) ); + DALI_TEST_EQUALS( actualValue, Vector4( 1.0f, 0.0f, 1.0f, 0.5f ), TEST_LOCATION ); + END_TEST; } @@ -959,15 +1156,15 @@ int UtcDaliRendererConstraint01(void) application.Render(0); // Expect no blue component in either buffer - yellow - DALI_TEST_EQUALS( renderer.GetProperty(colorIndex), Color::YELLOW, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::YELLOW, TEST_LOCATION ); application.Render(0); - DALI_TEST_EQUALS( renderer.GetProperty(colorIndex), Color::YELLOW, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::YELLOW, TEST_LOCATION ); renderer.RemoveConstraints(); renderer.SetProperty(colorIndex, Color::WHITE ); application.SendNotification(); application.Render(0); - DALI_TEST_EQUALS( renderer.GetProperty(colorIndex), Color::WHITE, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::WHITE, TEST_LOCATION ); END_TEST; } @@ -1026,8 +1223,6 @@ int UtcDaliRendererConstraint02(void) END_TEST; } - - int UtcDaliRendererAnimatedProperty01(void) { TestApplication application; @@ -1060,11 +1255,11 @@ int UtcDaliRendererAnimatedProperty01(void) application.SendNotification(); application.Render(500); - DALI_TEST_EQUALS( renderer.GetProperty(colorIndex), Color::WHITE * 0.5f, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::WHITE * 0.5f, TEST_LOCATION ); application.Render(500); - DALI_TEST_EQUALS( renderer.GetProperty(colorIndex), Color::TRANSPARENT, TEST_LOCATION ); + DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::TRANSPARENT, TEST_LOCATION ); END_TEST; } @@ -1371,6 +1566,32 @@ int UtcDaliRendererUniformMapMultipleUniforms02(void) } +Renderer CreateRenderer( Actor actor, Geometry geometry, Shader shader, int depthIndex ) +{ + Image image0 = BufferImage::New( 64, 64, Pixel::RGB888 ); + TextureSet textureSet0 = CreateTextureSet( image0 ); + Renderer renderer0 = Renderer::New( geometry, shader ); + renderer0.SetTextures( textureSet0 ); + renderer0.SetProperty( Renderer::Property::DEPTH_INDEX, depthIndex ); + actor.AddRenderer(renderer0); + return renderer0; +} + + +Actor CreateActor( Actor parent, int siblingOrder, const char* location ) +{ + Actor actor = Actor::New(); + actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER); + actor.SetProperty( Actor::Property::PARENT_ORIGIN,AnchorPoint::CENTER); + actor.SetPosition(0.0f,0.0f); + actor.SetSize(100, 100); + parent.Add(actor); + actor.SetProperty( Dali::DevelActor::Property::SIBLING_ORDER, siblingOrder ); + DALI_TEST_EQUALS( actor.GetProperty( Dali::DevelActor::Property::SIBLING_ORDER), siblingOrder, TEST_INNER_LOCATION(location) ); + + return actor; +} + int UtcDaliRendererRenderOrder2DLayer(void) { TestApplication application; @@ -1379,59 +1600,20 @@ int UtcDaliRendererRenderOrder2DLayer(void) Shader shader = Shader::New("VertexSource", "FragmentSource"); Geometry geometry = CreateQuadGeometry(); - Actor actor0 = Actor::New(); - actor0.SetAnchorPoint(AnchorPoint::CENTER); - actor0.SetParentOrigin(AnchorPoint::CENTER); - actor0.SetPosition(0.0f,0.0f); - Image image0 = BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet0 = CreateTextureSet( image0 ); - Renderer renderer0 = Renderer::New( geometry, shader ); - renderer0.SetTextures( textureSet0 ); - actor0.AddRenderer(renderer0); - actor0.SetSize(1, 1); - Stage::GetCurrent().Add(actor0); - application.SendNotification(); - application.Render(0); + Actor root = Stage::GetCurrent().GetRootLayer(); - Actor actor1 = Actor::New(); - actor1.SetAnchorPoint(AnchorPoint::CENTER); - actor1.SetParentOrigin(AnchorPoint::CENTER); - actor1.SetPosition(0.0f,0.0f); - Image image1= BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet1 = CreateTextureSet( image1 ); - Renderer renderer1 = Renderer::New( geometry, shader ); - renderer1.SetTextures( textureSet1 ); - actor1.AddRenderer(renderer1); - actor1.SetSize(1, 1); - Stage::GetCurrent().Add(actor1); - application.SendNotification(); - application.Render(0); + Actor actor0 = CreateActor( root, 0, TEST_LOCATION ); + Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 0 ); - Actor actor2 = Actor::New(); - actor2.SetAnchorPoint(AnchorPoint::CENTER); - actor2.SetParentOrigin(AnchorPoint::CENTER); - actor2.SetPosition(0.0f,0.0f); - Image image2= BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet2 = CreateTextureSet( image2 ); - Renderer renderer2 = Renderer::New( geometry, shader ); - renderer2.SetTextures( textureSet2 ); - actor2.AddRenderer(renderer2); - actor2.SetSize(1, 1); - Stage::GetCurrent().Add(actor2); - application.SendNotification(); - application.Render(0); + Actor actor1 = CreateActor( root, 0, TEST_LOCATION ); + Renderer renderer1 = CreateRenderer( actor1, geometry, shader, 0 ); + + Actor actor2 = CreateActor( root, 0, TEST_LOCATION ); + Renderer renderer2 = CreateRenderer( actor2, geometry, shader, 0 ); + + Actor actor3 = CreateActor( root, 0, TEST_LOCATION ); + Renderer renderer3 = CreateRenderer( actor3, geometry, shader, 0 ); - Actor actor3 = Actor::New(); - actor3.SetAnchorPoint(AnchorPoint::CENTER); - actor3.SetParentOrigin(AnchorPoint::CENTER); - actor3.SetPosition(0.0f,0.0f); - Image image3 = BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet3 = CreateTextureSet( image3 ); - Renderer renderer3 = Renderer::New( geometry, shader ); - renderer3.SetTextures( textureSet3 ); - actor3.AddRenderer(renderer3); - actor3.SetSize(1, 1); - Stage::GetCurrent().Add(actor3); application.SendNotification(); application.Render(0); @@ -1510,81 +1692,20 @@ int UtcDaliRendererRenderOrder2DLayerMultipleRenderers(void) Shader shader = Shader::New("VertexSource", "FragmentSource"); Geometry geometry = CreateQuadGeometry(); - Actor actor0 = Actor::New(); - actor0.SetAnchorPoint(AnchorPoint::CENTER); - actor0.SetParentOrigin(AnchorPoint::CENTER); - actor0.SetPosition(0.0f,0.0f); - actor0.SetSize(1, 1); - Stage::GetCurrent().Add(actor0); - - Actor actor1 = Actor::New(); - actor1.SetAnchorPoint(AnchorPoint::CENTER); - actor1.SetParentOrigin(AnchorPoint::CENTER); - actor1.SetPosition(0.0f,0.0f); - actor1.SetSize(1, 1); - actor0.Add(actor1); - - //Renderer0 - Image image0 = BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet0 = CreateTextureSet( image0 ); - Renderer renderer0 = Renderer::New( geometry, shader ); - renderer0.SetTextures( textureSet0 ); - renderer0.SetProperty( Renderer::Property::DEPTH_INDEX, 2 ); - actor0.AddRenderer(renderer0); - application.SendNotification(); - application.Render(0); - - //Renderer1 - Image image1= BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet1 = CreateTextureSet( image1 ); - Renderer renderer1 = Renderer::New( geometry, shader ); - renderer1.SetTextures( textureSet1 ); - renderer1.SetProperty( Renderer::Property::DEPTH_INDEX, 0 ); - actor0.AddRenderer(renderer1); - application.SendNotification(); - application.Render(0); - - //Renderer2 - Image image2= BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet2 = CreateTextureSet( image2 ); - Renderer renderer2 = Renderer::New( geometry, shader ); - renderer2.SetTextures( textureSet2 ); - renderer2.SetProperty( Renderer::Property::DEPTH_INDEX, 1 ); - actor0.AddRenderer(renderer2); - application.SendNotification(); - application.Render(0); - - //Renderer3 - Image image3 = BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet3 = CreateTextureSet( image3 ); - Renderer renderer3 = Renderer::New( geometry, shader ); - renderer3.SetTextures( textureSet3 ); - renderer3.SetProperty( Renderer::Property::DEPTH_INDEX, 1 ); - actor1.AddRenderer(renderer3); - application.SendNotification(); - application.Render(0); + Actor root = Stage::GetCurrent().GetRootLayer(); - //Renderer4 - Image image4= BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet4 = CreateTextureSet( image4 ); - Renderer renderer4 = Renderer::New( geometry, shader ); - renderer4.SetTextures( textureSet4 ); - renderer4.SetProperty( Renderer::Property::DEPTH_INDEX, 0 ); - actor1.AddRenderer(renderer4); - application.SendNotification(); - application.Render(0); + Actor actor0 = CreateActor( root, 0, TEST_LOCATION ); + Actor actor1 = CreateActor( actor0, 0, TEST_LOCATION ); + Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 2 ); + Renderer renderer1 = CreateRenderer( actor0, geometry, shader, 0 ); + Renderer renderer2 = CreateRenderer( actor0, geometry, shader, 1 ); + Renderer renderer3 = CreateRenderer( actor1, geometry, shader, 1 ); + Renderer renderer4 = CreateRenderer( actor1, geometry, shader, 0 ); + Renderer renderer5 = CreateRenderer( actor1, geometry, shader, -1 ); - //Renderer5 - Image image5= BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet5 = CreateTextureSet( image5 ); - Renderer renderer5 = Renderer::New( geometry, shader ); - renderer5.SetTextures( textureSet5 ); - renderer5.SetProperty( Renderer::Property::DEPTH_INDEX, -1 ); - actor1.AddRenderer(renderer5); application.SendNotification(); application.Render(0); - TestGlAbstraction& gl = application.GetGlAbstraction(); gl.EnableTextureCallTrace(true); application.SendNotification(); @@ -1604,7 +1725,7 @@ int UtcDaliRendererRenderOrder2DLayerMultipleRenderers(void) //Check that renderer0 has been rendered after renderer2 DALI_TEST_GREATER( textureBindIndex[4], textureBindIndex[5], TEST_LOCATION ); - //Check that renderer0 has been rendered after renderer2 + //Check that renderer5 has been rendered after renderer2 DALI_TEST_GREATER( textureBindIndex[5], textureBindIndex[0], TEST_LOCATION ); //Check that renderer0 has been rendered after renderer2 @@ -1616,87 +1737,118 @@ int UtcDaliRendererRenderOrder2DLayerMultipleRenderers(void) END_TEST; } -int UtcDaliRendererRenderOrder2DLayerOverlay(void) + +int UtcDaliRendererRenderOrder2DLayerSiblingOrder(void) { TestApplication application; - tet_infoline("Test the rendering order in a 2D layer is correct for overlays"); + tet_infoline("Test the rendering order in a 2D layer is correct using sibling order"); + + /* + * Creates the following hierarchy: + * + * Layer + * / \ + * / \ + * / \ + * / \ + * / \ + * actor0 (SIBLING_ORDER:1) actor1 (SIBLING_ORDER:0) + * / | \ / | \ + * / | \ / | \ + * / | \ / | \ + * renderer0 renderer1 actor2 renderer2 renderer3 renderer4 + * DI:2 DI:0 | DI:0 DI:1 DI:2 + * | + * renderer5 + * DI:-1 + * + * actor0 has sibling order 1 + * actor1 has sibling order 0 + * actor2 has sibling order 0 + * + * renderer0 has depth index 2 + * renderer1 has depth index 0 + * + * renderer2 has depth index 0 + * renderer3 has depth index 1 + * renderer4 has depth index 2 + * + * renderer5 has depth index -1 + * + * Expected rendering order: renderer2 - renderer3 - renderer4 - renderer1 - renderer0 - renderer5 + */ Shader shader = Shader::New("VertexSource", "FragmentSource"); Geometry geometry = CreateQuadGeometry(); + Actor root = Stage::GetCurrent().GetRootLayer(); + Actor actor0 = CreateActor( root, 1, TEST_LOCATION ); + Actor actor1 = CreateActor( root, 0, TEST_LOCATION ); + Actor actor2 = CreateActor( actor0, 0, TEST_LOCATION ); - Actor actor0 = Actor::New(); - actor0.SetAnchorPoint(AnchorPoint::CENTER); - actor0.SetParentOrigin(AnchorPoint::CENTER); - Image image0 = BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet0 = CreateTextureSet( image0 ); - Renderer renderer0 = Renderer::New( geometry, shader ); - renderer0.SetTextures( textureSet0 ); - actor0.AddRenderer(renderer0); - actor0.SetPosition(0.0f,0.0f); - actor0.SetSize(100, 100); - Stage::GetCurrent().Add(actor0); - actor0.SetDrawMode( DrawMode::OVERLAY_2D ); - application.SendNotification(); - application.Render(0); + Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 2 ); + Renderer renderer1 = CreateRenderer( actor0, geometry, shader, 0 ); + Renderer renderer2 = CreateRenderer( actor1, geometry, shader, 0 ); + Renderer renderer3 = CreateRenderer( actor1, geometry, shader, 1 ); + Renderer renderer4 = CreateRenderer( actor1, geometry, shader, 2 ); + Renderer renderer5 = CreateRenderer( actor2, geometry, shader, -1 ); - Actor actor1 = Actor::New(); - actor1.SetAnchorPoint(AnchorPoint::CENTER); - actor1.SetParentOrigin(AnchorPoint::CENTER); - Image image1= BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet1 = CreateTextureSet( image1 ); - Renderer renderer1 = Renderer::New( geometry, shader ); - renderer1.SetTextures( textureSet1 ); - actor1.SetPosition(0.0f,0.0f); - actor1.AddRenderer(renderer1); - actor1.SetSize(100, 100); - Stage::GetCurrent().Add(actor1); - actor1.SetDrawMode( DrawMode::OVERLAY_2D ); application.SendNotification(); - application.Render(0); + application.Render(); - Actor actor2 = Actor::New(); - actor2.SetAnchorPoint(AnchorPoint::CENTER); - actor2.SetParentOrigin(AnchorPoint::CENTER); - Image image2= BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet2 = CreateTextureSet( image2 ); - Renderer renderer2 = Renderer::New( geometry, shader ); - renderer2.SetTextures( textureSet2 ); - actor2.AddRenderer(renderer2); - actor2.SetPosition(0.0f,0.0f); - actor2.SetSize(100, 100); - Stage::GetCurrent().Add(actor2); + TestGlAbstraction& gl = application.GetGlAbstraction(); + gl.EnableTextureCallTrace(true); application.SendNotification(); application.Render(0); - Actor actor3 = Actor::New(); - actor3.SetAnchorPoint(AnchorPoint::CENTER); - actor3.SetParentOrigin(AnchorPoint::CENTER); - Image image3 = BufferImage::New( 64, 64, Pixel::RGB888 ); - TextureSet textureSet3 = CreateTextureSet( image3 ); - Renderer renderer3 = Renderer::New( geometry, shader ); - renderer3.SetTextures( textureSet3 ); - actor3.SetPosition(0.0f,0.0f); - actor3.AddRenderer(renderer3); - actor3.SetSize(100, 100); - Stage::GetCurrent().Add(actor3); - actor3.SetDrawMode( DrawMode::OVERLAY_2D ); - application.SendNotification(); - application.Render(0); + int textureBindIndex[6]; + for( unsigned int i(0); i<6; ++i ) + { + std::stringstream params; + params << GL_TEXTURE_2D<<", "< +void CheckEnumerationProperty( TestApplication& application, Renderer& renderer, Property::Index propertyIndex, T initialValue, T firstCheckEnumeration, T secondCheckEnumeration, std::string secondCheckString ) +{ + application.SendNotification(); + application.Render(); + + DALI_TEST_CHECK( renderer.GetProperty( propertyIndex ) == static_cast( initialValue ) ); + DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) == static_cast( initialValue ) ); + renderer.SetProperty( propertyIndex, firstCheckEnumeration ); + DALI_TEST_CHECK( renderer.GetProperty( propertyIndex ) == static_cast( firstCheckEnumeration ) ); + DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) != static_cast( firstCheckEnumeration ) ); + + application.SendNotification(); + application.Render(); + + DALI_TEST_CHECK( renderer.GetProperty( propertyIndex ) == static_cast( firstCheckEnumeration ) ); + DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) == static_cast( firstCheckEnumeration ) ); + + renderer.SetProperty( propertyIndex, secondCheckString ); + DALI_TEST_CHECK( renderer.GetProperty( propertyIndex ) == static_cast( secondCheckEnumeration ) ); + DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) != static_cast( secondCheckEnumeration ) ); + + application.SendNotification(); + application.Render(); + + DALI_TEST_CHECK( renderer.GetProperty( propertyIndex ) == static_cast( secondCheckEnumeration ) ); + DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) == static_cast( secondCheckEnumeration ) ); +} + +int UtcDaliRendererEnumProperties(void) +{ + TestApplication application; + tet_infoline( "Test Renderer enumeration properties can be set with both integer and string values" ); + + Geometry geometry = CreateQuadGeometry(); + Shader shader = CreateShader(); + Renderer renderer = Renderer::New( geometry, shader ); + + Actor actor = Actor::New(); + actor.AddRenderer(renderer); + actor.SetSize(400, 400); + Stage::GetCurrent().Add(actor); + + /* + * Here we use a templatized function to perform several checks on each enumeration property. + * @see CheckEnumerationProperty for details of the checks performed. + */ + + CheckEnumerationProperty< FaceCullingMode::Type >( application, renderer, Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::NONE, FaceCullingMode::FRONT, FaceCullingMode::BACK, "BACK" ); + CheckEnumerationProperty< BlendMode::Type >( application, renderer, Renderer::Property::BLEND_MODE, BlendMode::AUTO, BlendMode::OFF, BlendMode::ON, "ON" ); + CheckEnumerationProperty< BlendEquation::Type >( application, renderer, Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT" ); + CheckEnumerationProperty< BlendEquation::Type >( application, renderer, Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT" ); + CheckEnumerationProperty< BlendFactor::Type >( application, renderer, Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" ); + CheckEnumerationProperty< BlendFactor::Type >( application, renderer, Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" ); + CheckEnumerationProperty< BlendFactor::Type >( application, renderer, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::SRC_COLOR, "SRC_COLOR" ); + CheckEnumerationProperty< BlendFactor::Type >( application, renderer, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" ); + CheckEnumerationProperty< DepthWriteMode::Type >( application, renderer, Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO, DepthWriteMode::OFF, DepthWriteMode::ON, "ON" ); + CheckEnumerationProperty< DepthFunction::Type >( application, renderer, Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS, DepthFunction::ALWAYS, DepthFunction::GREATER, "GREATER" ); + CheckEnumerationProperty< DepthTestMode::Type >( application, renderer, Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO, DepthTestMode::OFF, DepthTestMode::ON, "ON" ); + CheckEnumerationProperty< StencilFunction::Type >( application, renderer, Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS, StencilFunction::LESS, StencilFunction::EQUAL, "EQUAL" ); + CheckEnumerationProperty< RenderMode::Type >( application, renderer, Renderer::Property::RENDER_MODE, RenderMode::AUTO, RenderMode::NONE, RenderMode::STENCIL, "STENCIL" ); + CheckEnumerationProperty< StencilOperation::Type >( application, renderer, Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" ); + CheckEnumerationProperty< StencilOperation::Type >( application, renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" ); + CheckEnumerationProperty< StencilOperation::Type >( application, renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" ); + + END_TEST; +} + +Renderer RendererTestFixture( TestApplication& application ) +{ + Geometry geometry = CreateQuadGeometry(); + Shader shader = CreateShader(); + Renderer renderer = Renderer::New( geometry, shader ); + + Actor actor = Actor::New(); + actor.AddRenderer( renderer ); + actor.SetSize( 400.0f, 400.0f ); + Stage stage = Stage::GetCurrent(); + stage.GetRootLayer().SetBehavior( Layer::LAYER_3D ); + stage.Add( actor ); + + return renderer; +} + +int UtcDaliRendererSetDepthTestMode(void) +{ + TestApplication application; + tet_infoline("Test setting the DepthTestMode"); + + Renderer renderer = RendererTestFixture( application ); + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + glAbstraction.EnableEnableDisableCallTrace( true ); + TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace(); + + glEnableDisableStack.Reset(); + application.SendNotification(); + application.Render(); + + // Check depth-test is enabled by default. + DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) ); + DALI_TEST_CHECK( !glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) ); + + // Turn off depth-testing. We want to check if the depth buffer has been disabled, so we need to turn off depth-write as well for this case. + renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::OFF ); + renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF ); + + glEnableDisableStack.Reset(); + application.SendNotification(); + application.Render(); + + // Check the depth buffer was disabled. + DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) ); + + // Turn on automatic mode depth-testing. + // Layer behavior is currently set to LAYER_3D so AUTO should enable depth-testing. + renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO ); + + glEnableDisableStack.Reset(); + application.SendNotification(); + application.Render(); + + // Check depth-test is now enabled. + DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) ); + DALI_TEST_CHECK( !glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) ); + + // Change the layer behavior to LAYER_UI. + // Note this will also disable depth testing for the layer by default, we test this first. + Stage::GetCurrent().GetRootLayer().SetBehavior( Layer::LAYER_UI ); + + glEnableDisableStack.Reset(); + application.SendNotification(); + application.Render(); + + // Check depth-test is disabled. + DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) ); + + // Turn the layer depth-test flag back on, and confirm that depth testing is now on. + Stage::GetCurrent().GetRootLayer().SetDepthTestDisabled( false ); + + glEnableDisableStack.Reset(); + application.SendNotification(); + application.Render(); + + // Check depth-test is *still* disabled. + DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) ); + + END_TEST; +} + +int UtcDaliRendererSetDepthWriteMode(void) +{ + TestApplication application; + tet_infoline("Test setting the DepthWriteMode"); + + Renderer renderer = RendererTestFixture( application ); + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + + application.SendNotification(); + application.Render(); + + // Check the default depth-write status first. + DALI_TEST_CHECK( glAbstraction.GetLastDepthMask() ); + + // Turn off depth-writing. + renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF ); + + application.SendNotification(); + application.Render(); + + // Check depth-write is now disabled. + DALI_TEST_CHECK( !glAbstraction.GetLastDepthMask() ); + + // Test the AUTO mode for depth-writing. + // As our renderer is opaque, depth-testing should be enabled. + renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO ); + + application.SendNotification(); + application.Render(); + + // Check depth-write is now enabled. + DALI_TEST_CHECK( glAbstraction.GetLastDepthMask() ); + + // Now make the renderer be treated as translucent by enabling blending. + // The AUTO depth-write mode should turn depth-write off in this scenario. + renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON ); + + application.SendNotification(); + application.Render(); + + // Check depth-write is now disabled. + DALI_TEST_CHECK( !glAbstraction.GetLastDepthMask() ); + + END_TEST; +} + +int UtcDaliRendererCheckStencilDefaults(void) +{ + TestApplication application; + tet_infoline("Test the stencil defaults"); + + Renderer renderer = RendererTestFixture( application ); + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + glAbstraction.EnableEnableDisableCallTrace( true ); + glAbstraction.EnableStencilFunctionCallTrace( true ); + TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace(); + TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace(); + + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + // Check the defaults: + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION ).Get() ), static_cast( StencilFunction::ALWAYS ), TEST_LOCATION ); + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION_MASK ).Get() ), 0xFF, TEST_LOCATION ); + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE ).Get() ), 0x00, TEST_LOCATION ); + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_MASK ).Get() ), 0xFF, TEST_LOCATION ); + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL ).Get() ), static_cast( StencilOperation::KEEP ), TEST_LOCATION ); + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL ).Get() ), static_cast( StencilOperation::KEEP ), TEST_LOCATION ); + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS ).Get() ), static_cast( StencilOperation::KEEP ), TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliRendererSetRenderModeToUseStencilBuffer(void) +{ + TestApplication application; + tet_infoline("Test setting the RenderMode to use the stencil buffer"); + + Renderer renderer = RendererTestFixture( application ); + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + glAbstraction.EnableEnableDisableCallTrace( true ); + glAbstraction.EnableStencilFunctionCallTrace( true ); + TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace(); + TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace(); + + // Set the StencilFunction to something other than the default, to confirm it is set as a property, + // but NO GL call has been made while the RenderMode is set to not use the stencil buffer. + renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::NONE ); + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, StencilFunction::NEVER ); + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION ).Get() ), static_cast( StencilFunction::NEVER ), TEST_LOCATION ); + + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + std::string methodString( "StencilFunc" ); + DALI_TEST_CHECK( !glStencilFunctionStack.FindMethod( methodString ) ); + + // Test the other RenderModes that will not enable the stencil buffer. + renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::AUTO ); + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + DALI_TEST_CHECK( !glStencilFunctionStack.FindMethod( methodString ) ); + + renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR ); + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + DALI_TEST_CHECK( !glStencilFunctionStack.FindMethod( methodString ) ); + + // Now set the RenderMode to modes that will use the stencil buffer, and check the StencilFunction has changed. + renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL ); + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetStencilTestString() ) ); + DALI_TEST_CHECK( glStencilFunctionStack.FindMethod( methodString ) ); + + // Test the COLOR_STENCIL RenderMode as it also enables the stencil buffer. + // First set a mode to turn off the stencil buffer, so the enable is required. + renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR ); + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR_STENCIL ); + // Set a different stencil function as the last one is cached. + renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS ); + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetStencilTestString() ) ); + DALI_TEST_CHECK( glStencilFunctionStack.FindMethod( methodString ) ); + + END_TEST; +} + +// Helper function for the SetRenderModeToUseColorBuffer test. +void CheckRenderModeColorMask( TestApplication& application, Renderer& renderer, RenderMode::Type renderMode, bool expectedValue ) +{ + // Set the RenderMode property to a value that should not allow color buffer writes. + renderer.SetProperty( Renderer::Property::RENDER_MODE, renderMode ); + application.SendNotification(); + application.Render(); + + // Check if ColorMask has been called, and that the values are correct. + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + const TestGlAbstraction::ColorMaskParams& colorMaskParams( glAbstraction.GetColorMaskParams() ); + + DALI_TEST_EQUALS( colorMaskParams.red, expectedValue, TEST_LOCATION ); + DALI_TEST_EQUALS( colorMaskParams.green, expectedValue, TEST_LOCATION ); + DALI_TEST_EQUALS( colorMaskParams.blue, expectedValue, TEST_LOCATION ); + DALI_TEST_EQUALS( colorMaskParams.alpha, expectedValue, TEST_LOCATION ); +} + +int UtcDaliRendererSetRenderModeToUseColorBuffer(void) +{ + TestApplication application; + tet_infoline("Test setting the RenderMode to use the color buffer"); + + Renderer renderer = RendererTestFixture( application ); + + // Set the RenderMode property to a value that should not allow color buffer writes. + // Then check if ColorMask has been called, and that the values are correct. + CheckRenderModeColorMask( application, renderer, RenderMode::AUTO, true ); + CheckRenderModeColorMask( application, renderer, RenderMode::NONE, false ); + CheckRenderModeColorMask( application, renderer, RenderMode::COLOR, true ); + CheckRenderModeColorMask( application, renderer, RenderMode::STENCIL, false ); + CheckRenderModeColorMask( application, renderer, RenderMode::COLOR_STENCIL, true ); + + END_TEST; +} + +int UtcDaliRendererSetStencilFunction(void) +{ + TestApplication application; + tet_infoline("Test setting the StencilFunction"); + + Renderer renderer = RendererTestFixture( application ); + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + glAbstraction.EnableEnableDisableCallTrace( true ); + glAbstraction.EnableStencilFunctionCallTrace( true ); + TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace(); + TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace(); + + // RenderMode must use the stencil for StencilFunction to operate. + renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL ); + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + /* + * Lookup table for testing StencilFunction. + * Note: This MUST be in the same order as the Dali::StencilFunction enum. + */ + const int StencilFunctionLookupTable[] = { + GL_NEVER, + GL_LESS, + GL_EQUAL, + GL_LEQUAL, + GL_GREATER, + GL_NOTEQUAL, + GL_GEQUAL, + GL_ALWAYS + }; const int StencilFunctionLookupTableCount = sizeof( StencilFunctionLookupTable ) / sizeof( StencilFunctionLookupTable[0] ); + + /* + * Loop through all types of StencilFunction, checking: + * - The value is cached (set in event thread side) + * - Causes "glStencilFunc" to be called + * - Checks the correct parameters to "glStencilFunc" were used + */ + std::string nonChangingParameters = "0, 255"; + std::string methodString( "StencilFunc" ); + for( int i = 0; i < StencilFunctionLookupTableCount; ++i ) + { + // Set the property. + renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, static_cast( i ) ); + + // Check GetProperty returns the same value. + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION ).Get() ), i, TEST_LOCATION ); + + // Reset the trace debug. + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + // Check the function is called and the parameters are correct. + std::stringstream parameterStream; + parameterStream << StencilFunctionLookupTable[ i ] << ", " << nonChangingParameters; + + DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterStream.str() ) ); + } + + // Change the Function Reference only and check the behavior is correct: + // 170 is 0xaa in hex / 10101010 in binary (every other bit set). + int testValueReference = 170; + renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE, testValueReference ); + + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE ).Get() ), testValueReference, TEST_LOCATION ); + + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + DALI_TEST_EQUALS( static_cast( renderer.GetCurrentProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE ).Get() ), testValueReference, TEST_LOCATION ); + + std::stringstream parameterStream; + parameterStream << StencilFunctionLookupTable[ StencilOperation::DECREMENT_WRAP ] << ", " << testValueReference << ", 255"; + + DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterStream.str() ) ); + + + // Change the Function Mask only and check the behavior is correct: + // 85 is 0x55 in hex / 01010101 in binary (every other bit set). + int testValueMask = 85; + renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_MASK, testValueMask ); + + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION_MASK ).Get() ), testValueMask, TEST_LOCATION ); + + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + DALI_TEST_EQUALS( static_cast( renderer.GetCurrentProperty( Renderer::Property::STENCIL_FUNCTION_MASK ).Get() ), testValueMask, TEST_LOCATION ); + + // Clear the stringstream. + parameterStream.str( std::string() ); + parameterStream << StencilFunctionLookupTable[ StencilOperation::DECREMENT_WRAP ] << ", " << testValueReference << ", " << testValueMask; + + DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterStream.str() ) ); + + END_TEST; +} + +int UtcDaliRendererSetStencilOperation(void) +{ + TestApplication application; + tet_infoline("Test setting the StencilOperation"); + + Renderer renderer = RendererTestFixture( application ); + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + glAbstraction.EnableEnableDisableCallTrace( true ); + glAbstraction.EnableStencilFunctionCallTrace( true ); + TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace(); + TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace(); + + // RenderMode must use the stencil for StencilOperation to operate. + renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL ); + + /* + * Lookup table for testing StencilOperation. + * Note: This MUST be in the same order as the Dali::StencilOperation enum. + */ + const int StencilOperationLookupTable[] = { + GL_ZERO, + GL_KEEP, + GL_REPLACE, + GL_INCR, + GL_DECR, + GL_INVERT, + GL_INCR_WRAP, + GL_DECR_WRAP + }; const int StencilOperationLookupTableCount = sizeof( StencilOperationLookupTable ) / sizeof( StencilOperationLookupTable[0] ); + + // Set all 3 StencilOperation properties to a default. + renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP ); + renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::ZERO ); + renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::ZERO ); + + // Set our expected parameter list to the equivalent result. + int parameters[] = { StencilOperationLookupTable[ StencilOperation::ZERO ], StencilOperationLookupTable[ StencilOperation::ZERO ], StencilOperationLookupTable[ StencilOperation::ZERO ] }; + + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + /* + * Loop through all types of StencilOperation, checking: + * - The value is cached (set in event thread side) + * - Causes "glStencilFunc" to be called + * - Checks the correct parameters to "glStencilFunc" were used + * - Checks the above for all 3 parameter placements of StencilOperation ( OnFail, OnZFail, OnPass ) + */ + std::string methodString( "StencilOp" ); + + for( int i = 0; i < StencilOperationLookupTableCount; ++i ) + { + for( int j = 0; j < StencilOperationLookupTableCount; ++j ) + { + for( int k = 0; k < StencilOperationLookupTableCount; ++k ) + { + // Set the property (outer loop causes all 3 different properties to be set separately). + renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL, static_cast( i ) ); + renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, static_cast( j ) ); + renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, static_cast( k ) ); + + // Check GetProperty returns the same value. + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL ).Get() ), i, TEST_LOCATION ); + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL ).Get() ), j, TEST_LOCATION ); + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS ).Get() ), k, TEST_LOCATION ); + + // Reset the trace debug. + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + // Check the function is called and the parameters are correct. + // Set the expected parameter value at its correct index (only) + parameters[ 0u ] = StencilOperationLookupTable[ i ]; + parameters[ 1u ] = StencilOperationLookupTable[ j ]; + parameters[ 2u ] = StencilOperationLookupTable[ k ]; + + // Build the parameter list. + std::stringstream parameterStream; + for( int parameterBuild = 0; parameterBuild < 3; ++parameterBuild ) + { + parameterStream << parameters[ parameterBuild ]; + // Comma-separate the parameters. + if( parameterBuild < 2 ) + { + parameterStream << ", "; + } + } + + // Check the function was called and the parameters were correct. + DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterStream.str() ) ); + } + } + } + + END_TEST; +} + +int UtcDaliRendererSetStencilMask(void) +{ + TestApplication application; + tet_infoline("Test setting the StencilMask"); + + Renderer renderer = RendererTestFixture( application ); + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + glAbstraction.EnableEnableDisableCallTrace( true ); + glAbstraction.EnableStencilFunctionCallTrace( true ); + TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace(); + TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace(); + + // RenderMode must use the stencil for StencilMask to operate. + renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL ); + + // Set the StencilMask property to a value. + renderer.SetProperty( Renderer::Property::STENCIL_MASK, 0x00 ); + + // Check GetProperty returns the same value. + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_MASK ).Get() ), 0x00, TEST_LOCATION ); + + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + DALI_TEST_EQUALS( static_cast( renderer.GetCurrentProperty( Renderer::Property::STENCIL_MASK ).Get() ), 0x00, TEST_LOCATION ); + + std::string methodString( "StencilMask" ); + std::string parameterString = "0"; + + // Check the function was called and the parameters were correct. + DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterString ) ); + + // Set the StencilMask property to another value to ensure it has changed. + renderer.SetProperty( Renderer::Property::STENCIL_MASK, 0xFF ); + + // Check GetProperty returns the same value. + DALI_TEST_EQUALS( static_cast( renderer.GetProperty( Renderer::Property::STENCIL_MASK ).Get() ), 0xFF, TEST_LOCATION ); + + ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack ); + + DALI_TEST_EQUALS( static_cast( renderer.GetCurrentProperty( Renderer::Property::STENCIL_MASK ).Get() ), 0xFF, TEST_LOCATION ); + + parameterString = "255"; + + // Check the function was called and the parameters were correct. + DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterString ) ); + + END_TEST; +} + +int UtcDaliRendererWrongNumberOfTextures(void) +{ + TestApplication application; + tet_infoline("Test renderer does render even if number of textures is different than active samplers in the shader"); + + //Create a TextureSet with 4 textures (One more texture in the texture set than active samplers) + //@note Shaders in the test suit have 3 active samplers. See TestGlAbstraction::GetActiveUniform() + Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 64u, 64u ); + TextureSet textureSet = CreateTextureSet(); + textureSet.SetTexture(0, texture ); + textureSet.SetTexture(1, texture ); + textureSet.SetTexture(2, texture ); + textureSet.SetTexture(3, texture ); + Shader shader = Shader::New("VertexSource", "FragmentSource"); + Geometry geometry = CreateQuadGeometry(); + Renderer renderer = Renderer::New( geometry, shader ); + renderer.SetTextures( textureSet ); + + Actor actor= Actor::New(); + actor.AddRenderer(renderer); + actor.SetPosition(0.0f,0.0f); + actor.SetSize(100, 100); + Stage::GetCurrent().Add(actor); + + TestGlAbstraction& gl = application.GetGlAbstraction(); + TraceCallStack& drawTrace = gl.GetDrawTrace(); + drawTrace.Reset(); + drawTrace.Enable(true); + + application.SendNotification(); + application.Render(0); + + //Test we do the drawcall when TextureSet has more textures than there are active samplers in the shader + DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION ); + + //Create a TextureSet with 1 texture (two more active samplers than texture in the texture set) + //@note Shaders in the test suit have 3 active samplers. See TestGlAbstraction::GetActiveUniform() + textureSet = CreateTextureSet(); + renderer.SetTextures( textureSet ); + textureSet.SetTexture(0, texture ); + drawTrace.Reset(); + application.SendNotification(); + application.Render(0); + + //Test we do the drawcall when TextureSet has less textures than there are active samplers in the shader. + DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliRendererOpacity(void) +{ + TestApplication application; + + tet_infoline( "Test OPACITY property" ); + + Geometry geometry = CreateQuadGeometry(); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); + Renderer renderer = Renderer::New( geometry, shader ); + + Actor actor = Actor::New(); + actor.AddRenderer( renderer ); + actor.SetSize( 400, 400 ); + actor.SetProperty( Actor::Property::COLOR, Vector4( 1.0f, 0.0f, 1.0f, 1.0f ) ); + Stage::GetCurrent().Add( actor ); + + Property::Value value = renderer.GetProperty( DevelRenderer::Property::OPACITY ); + float opacity; + DALI_TEST_CHECK( value.Get( opacity ) ); + DALI_TEST_EQUALS( opacity, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION ); + + application.SendNotification(); + application.Render(); + + Vector4 actualValue; + TestGlAbstraction& gl = application.GetGlAbstraction(); + DALI_TEST_CHECK( gl.GetUniformValue< Vector4 >( "uColor", actualValue ) ); + DALI_TEST_EQUALS( actualValue.a, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION ); + + renderer.SetProperty( DevelRenderer::Property::OPACITY, 0.5f ); + + application.SendNotification(); + application.Render(); + + value = renderer.GetProperty( DevelRenderer::Property::OPACITY ); + DALI_TEST_CHECK( value.Get( opacity ) ); + DALI_TEST_EQUALS( opacity, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION ); + + value = renderer.GetCurrentProperty( DevelRenderer::Property::OPACITY ); + DALI_TEST_CHECK( value.Get( opacity ) ); + DALI_TEST_EQUALS( opacity, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION ); + + DALI_TEST_CHECK( gl.GetUniformValue< Vector4 >( "uColor", actualValue ) ); + DALI_TEST_EQUALS( actualValue.a, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliRendererOpacityAnimation(void) +{ + TestApplication application; + + tet_infoline( "Test OPACITY property animation" ); + + Geometry geometry = CreateQuadGeometry(); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); + Renderer renderer = Renderer::New( geometry, shader ); + + Actor actor = Actor::New(); + actor.AddRenderer( renderer ); + actor.SetSize( 400, 400 ); + actor.SetProperty( Actor::Property::COLOR, Vector4( 1.0f, 0.0f, 1.0f, 1.0f ) ); + Stage::GetCurrent().Add( actor ); + + application.SendNotification(); + application.Render(0); + + Property::Value value = renderer.GetProperty( DevelRenderer::Property::OPACITY ); + float opacity; + DALI_TEST_CHECK( value.Get( opacity ) ); + DALI_TEST_EQUALS( opacity, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION ); + + Animation animation = Animation::New( 1.0f ); + animation.AnimateTo( Property( renderer, DevelRenderer::Property::OPACITY ), 0.0f ); + animation.Play(); + + application.SendNotification(); + application.Render( 1000 ); + + value = renderer.GetProperty( DevelRenderer::Property::OPACITY ); + DALI_TEST_CHECK( value.Get( opacity ) ); + DALI_TEST_EQUALS( opacity, 0.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION ); + + // Need to clear the animation before setting the property as the animation value is baked and will override any previous setters + animation.Clear(); + renderer.SetProperty( DevelRenderer::Property::OPACITY, 0.1f ); + + animation.AnimateBy( Property( renderer, DevelRenderer::Property::OPACITY ), 0.5f ); + animation.Play(); + + application.SendNotification(); + application.Render( 1000 ); + + value = renderer.GetProperty( DevelRenderer::Property::OPACITY ); + DALI_TEST_CHECK( value.Get( opacity ) ); + DALI_TEST_EQUALS( opacity, 0.6f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION ); + DALI_TEST_EQUALS( opacity, renderer.GetCurrentProperty( DevelRenderer::Property::OPACITY ).Get< float >(), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliRendererInvalidProperty(void) +{ + TestApplication application; + + tet_infoline( "Test invalid property" ); + + Geometry geometry = CreateQuadGeometry(); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); + Renderer renderer = Renderer::New( geometry, shader ); + + Actor actor = Actor::New(); + actor.AddRenderer( renderer ); + actor.SetSize( 400, 400 ); + Stage::GetCurrent().Add( actor ); + + application.SendNotification(); + application.Render(0); + + Property::Value value = renderer.GetProperty( Renderer::Property::DEPTH_INDEX + 100 ); + DALI_TEST_CHECK( value.GetType() == Property::Type::NONE ); + + value = renderer.GetCurrentProperty( Renderer::Property::DEPTH_INDEX + 100 ); + DALI_TEST_CHECK( value.GetType() == Property::Type::NONE ); + + END_TEST; +} + +int UtcDaliRendererRenderingBehavior(void) +{ + TestApplication application; + + tet_infoline( "Test RENDERING_BEHAVIOR property" ); + + Geometry geometry = CreateQuadGeometry(); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); + Renderer renderer = Renderer::New( geometry, shader ); + + Actor actor = Actor::New(); + actor.AddRenderer( renderer ); + actor.SetSize( 400, 400 ); + actor.SetProperty( Actor::Property::COLOR, Vector4( 1.0f, 0.0f, 1.0f, 1.0f ) ); + Stage::GetCurrent().Add( actor ); + + Property::Value value = renderer.GetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR ); + int renderingBehavior; + DALI_TEST_CHECK( value.Get( renderingBehavior ) ); + DALI_TEST_EQUALS( static_cast< DevelRenderer::Rendering::Type >( renderingBehavior ), DevelRenderer::Rendering::IF_REQUIRED, TEST_LOCATION ); + + application.SendNotification(); + application.Render(); + + uint32_t updateStatus = application.GetUpdateStatus(); + + DALI_TEST_CHECK( !( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING ) ); + + renderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY ); + + value = renderer.GetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR ); + DALI_TEST_CHECK( value.Get( renderingBehavior ) ); + DALI_TEST_EQUALS( static_cast< DevelRenderer::Rendering::Type >( renderingBehavior ), DevelRenderer::Rendering::CONTINUOUSLY, TEST_LOCATION ); + + // Render and check the update status + application.SendNotification(); + application.Render(); + + updateStatus = application.GetUpdateStatus(); + + DALI_TEST_CHECK( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING ); + + value = renderer.GetCurrentProperty( DevelRenderer::Property::RENDERING_BEHAVIOR ); + DALI_TEST_CHECK( value.Get( renderingBehavior ) ); + DALI_TEST_EQUALS( static_cast< DevelRenderer::Rendering::Type >( renderingBehavior ), DevelRenderer::Rendering::CONTINUOUSLY, TEST_LOCATION ); + + // Render again and check the update status + application.SendNotification(); + application.Render(); + + updateStatus = application.GetUpdateStatus(); + + DALI_TEST_CHECK( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING ); + + // Change rendering behavior + renderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED ); + + // Render and check the update status + application.SendNotification(); + application.Render(); + + updateStatus = application.GetUpdateStatus(); + + DALI_TEST_CHECK( !( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING ) ); + + END_TEST; +} + +int UtcDaliRendererRegenerateUniformMap(void) +{ + TestApplication application; + + tet_infoline( "Test regenerating uniform map when attaching renderer to the node" ); + + Geometry geometry = CreateQuadGeometry(); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); + Renderer renderer = Renderer::New( geometry, shader ); + + Actor actor = Actor::New(); + actor.AddRenderer( renderer ); + actor.SetSize( 400, 400 ); + actor.SetProperty( Actor::Property::COLOR, Vector4( 1.0f, 0.0f, 1.0f, 1.0f ) ); + Stage::GetCurrent().Add( actor ); + + application.SendNotification(); + application.Render(); + + actor.RemoveRenderer( renderer ); + shader = Shader::New( "vertexSrc", "fragmentSrc" ); + shader.RegisterProperty( "opacity", 0.5f ); + renderer.SetShader( shader ); + + Stage::GetCurrent().KeepRendering( 1.0f ); + + // Update for several frames + application.SendNotification(); + application.Render(); + application.SendNotification(); + application.Render(); + application.SendNotification(); + application.Render(); + application.SendNotification(); + application.Render(); + + // Add Renderer + actor.AddRenderer( renderer ); + application.SendNotification(); + application.Render(); + + // Nothing to test here, the test must not crash + auto updateStatus = application.GetUpdateStatus(); + DALI_TEST_CHECK( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING ); + + END_TEST; +}