From 3b20d8e3e6922ee57cfbd78a86db9ee744cbe32a Mon Sep 17 00:00:00 2001 From: Ferran Sole Date: Tue, 26 Apr 2016 17:08:42 +0100 Subject: [PATCH] Remove API to set if a geometry requires writing to the depth buffer - Removed API to set ( and get ) if a geometry requires writing to the depth buffer when rendering - Added a property in renderer to specify whether the renderer requires writing to the depth buffer. - Clean-up shader hints. Removed hints which were not used (i.e never checked) Change-Id: I4c4b4f17382cefb5b94850c4cc93e64951bf9607 --- .../src/dali-devel/utc-Dali-Geometry.cpp | 34 ------ .../src/dali-devel/utc-Dali-Renderer.cpp | 16 +-- automated-tests/src/dali-devel/utc-Dali-Shader.cpp | 6 +- dali/devel-api/rendering/geometry.cpp | 10 -- dali/devel-api/rendering/geometry.h | 18 --- dali/devel-api/rendering/renderer.h | 17 ++- dali/devel-api/rendering/shader.h | 2 - dali/internal/common/type-abstraction-enums.h | 1 + dali/internal/event/effects/shader-effect-impl.cpp | 5 +- dali/internal/event/rendering/geometry-impl.cpp | 18 +-- dali/internal/event/rendering/geometry-impl.h | 12 -- dali/internal/event/rendering/renderer-impl.cpp | 22 +++- dali/internal/event/rendering/renderer-impl.h | 3 +- dali/internal/event/rendering/shader-impl.cpp | 33 +---- dali/internal/render/common/render-algorithms.cpp | 43 +++++-- dali/internal/render/common/render-manager.cpp | 5 - dali/internal/render/common/render-manager.h | 7 -- dali/internal/render/gl-resources/context.cpp | 4 +- dali/internal/render/gl-resources/context.h | 2 +- dali/internal/render/renderers/render-geometry.cpp | 1 - dali/internal/render/renderers/render-geometry.h | 19 --- dali/internal/render/renderers/render-renderer.cpp | 27 ++--- dali/internal/render/renderers/render-renderer.h | 31 +++-- .../internal/render/shaders/scene-graph-shader.cpp | 4 +- dali/internal/render/shaders/scene-graph-shader.h | 34 ++---- .../update/manager/prepare-render-instructions.cpp | 15 +-- dali/internal/update/manager/update-manager.cpp | 11 -- dali/internal/update/manager/update-manager.h | 18 --- .../update/rendering/scene-graph-renderer.cpp | 134 +++++++++++---------- .../update/rendering/scene-graph-renderer.h | 22 +++- 30 files changed, 226 insertions(+), 348 deletions(-) diff --git a/automated-tests/src/dali-devel/utc-Dali-Geometry.cpp b/automated-tests/src/dali-devel/utc-Dali-Geometry.cpp index 96ad6a6..978e38e 100644 --- a/automated-tests/src/dali-devel/utc-Dali-Geometry.cpp +++ b/automated-tests/src/dali-devel/utc-Dali-Geometry.cpp @@ -557,37 +557,3 @@ int UtcDaliGeometrySetGetGeometryType02(void) END_TEST; } -int UtcDaliGeometrySetGetRequireDepthTesting(void) -{ - TestApplication application; - - tet_infoline("Test SetRequiresDepthTesting, GetRequiresDepthTesting"); - - Shader shader = Shader::New("VertexSource", "FragmentSource"); - Geometry geometry = CreateQuadGeometry(); - Renderer renderer = Renderer::New( geometry, shader ); - - Actor actor = Actor::New(); - actor.AddRenderer(renderer); - actor.SetSize(400, 400); - Stage::GetCurrent().Add(actor); - - DALI_TEST_EQUALS( geometry.GetRequiresDepthTesting(), false, TEST_LOCATION ); - - geometry.SetRequiresDepthTesting(true); - - TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); - glAbstraction.EnableEnableDisableCallTrace(true); - application.SendNotification(); - application.Render(); -// TODO: Not supported yes -// TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace(); -// std::ostringstream out; -// out << GL_DEPTH_TEST; -// DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", out.str().c_str() ) ); - - DALI_TEST_EQUALS( geometry.GetRequiresDepthTesting(), true, TEST_LOCATION ); - - END_TEST; -} - diff --git a/automated-tests/src/dali-devel/utc-Dali-Renderer.cpp b/automated-tests/src/dali-devel/utc-Dali-Renderer.cpp index 6e68fb2..bfd2ab9 100644 --- a/automated-tests/src/dali-devel/utc-Dali-Renderer.cpp +++ b/automated-tests/src/dali-devel/utc-Dali-Renderer.cpp @@ -242,7 +242,7 @@ int UtcDaliRendererSetGetFaceCullingMode(void) // By default, none of the faces should be culled unsigned int cullFace = renderer.GetProperty( Renderer::Property::FACE_CULLING_MODE ); - DALI_TEST_CHECK( static_cast< Dali::Renderer::FaceCullingMode >( cullFace ) == Renderer::NONE ); + DALI_TEST_CHECK( static_cast< Dali::Renderer::FaceCullingMode >( cullFace ) == Renderer::CULL_NONE ); TestGlAbstraction& gl = application.GetGlAbstraction(); TraceCallStack& cullFaceStack = gl.GetCullFaceTrace(); @@ -298,13 +298,13 @@ int UtcDaliRendererSetGetFaceCullingMode(void) { cullFaceStack.Reset(); - renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, Renderer::NONE ); + renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, Renderer::CULL_NONE ); application.SendNotification(); application.Render(); DALI_TEST_EQUALS( cullFaceStack.CountMethod( "CullFace" ), 0, TEST_LOCATION ); cullFace = renderer.GetProperty( Renderer::Property::FACE_CULLING_MODE ); - DALI_TEST_CHECK( static_cast< Dali::Renderer::FaceCullingMode >( cullFace ) == Renderer::NONE ); + DALI_TEST_CHECK( static_cast< Dali::Renderer::FaceCullingMode >( cullFace ) == Renderer::CULL_NONE ); } END_TEST; @@ -733,7 +733,7 @@ int UtcDaliRendererSetBlendMode07(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_OPAQUE renders with blending disabled"); Geometry geometry = CreateQuadGeometry(); - Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE ); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); BufferImage image = BufferImage::New( 50, 50, Pixel::RGB888 ); TextureSet textureSet = CreateTextureSet( image ); @@ -766,7 +766,7 @@ int UtcDaliRendererGetBlendMode(void) tet_infoline("Test GetBlendMode()"); Geometry geometry = CreateQuadGeometry(); - Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE ); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); Renderer renderer = Renderer::New( geometry, shader ); // default value @@ -793,7 +793,7 @@ int UtcDaliRendererSetBlendColor(void) tet_infoline("Test SetBlendColor(color)"); Geometry geometry = CreateQuadGeometry(); - Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE ); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); TextureSet textureSet = TextureSet::New(); BufferImage image = BufferImage::New( 50, 50, Pixel::RGBA8888 ); textureSet.SetImage( 0u, image ); @@ -833,7 +833,7 @@ int UtcDaliRendererGetBlendColor(void) tet_infoline("Test GetBlendColor()"); Geometry geometry = CreateQuadGeometry(); - Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE ); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); Renderer renderer = Renderer::New( geometry, shader ); DALI_TEST_EQUALS( renderer.GetProperty( Renderer::Property::BLENDING_COLOR ), Color::TRANSPARENT, TEST_LOCATION ); @@ -859,7 +859,7 @@ int UtcDaliRendererPreMultipledAlpha(void) tet_infoline("Test BLEND_PRE_MULTIPLIED_ALPHA property"); Geometry geometry = CreateQuadGeometry(); - Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE ); + Shader shader = Shader::New( "vertexSrc", "fragmentSrc" ); Renderer renderer = Renderer::New( geometry, shader ); Actor actor = Actor::New(); diff --git a/automated-tests/src/dali-devel/utc-Dali-Shader.cpp b/automated-tests/src/dali-devel/utc-Dali-Shader.cpp index ce71116..11403d2 100644 --- a/automated-tests/src/dali-devel/utc-Dali-Shader.cpp +++ b/automated-tests/src/dali-devel/utc-Dali-Shader.cpp @@ -309,7 +309,7 @@ int UtcDaliShaderProgramProperty(void) tet_infoline("Test get/set progam property"); Shader shader = Shader::New("", ""); - std::string hintSet = "HINT_REQUIRES_SELF_DEPTH_TEST,HINT_MODIFIES_GEOMETRY"; + std::string hintSet = "HINT_MODIFIES_GEOMETRY"; Property::Map map; map["vertex"] = VertexSource; @@ -332,14 +332,14 @@ int UtcDaliShaderProgramProperty(void) std::string hintGot; - hintSet = "HINT_REQUIRES_SELF_DEPTH_TEST,HINT_OUTPUT_IS_TRANSPARENT,HINT_OUTPUT_IS_OPAQUE,HINT_MODIFIES_GEOMETRY"; + hintSet = "HINT_OUTPUT_IS_TRANSPARENT,HINT_MODIFIES_GEOMETRY"; map["hints"] = hintSet; shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) ); value = shader.GetProperty(Shader::Property::PROGRAM); hintGot = (*value.GetMap())["hints"].Get(); DALI_TEST_CHECK( hintGot == hintSet ); - hintSet = "HINT_REQUIRES_SELF_DEPTH_TEST"; + hintSet = "HINT_OUTPUT_IS_TRANSPARENT"; map["hints"] = hintSet; shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) ); value = shader.GetProperty(Shader::Property::PROGRAM); diff --git a/dali/devel-api/rendering/geometry.cpp b/dali/devel-api/rendering/geometry.cpp index 14b6476..1e504d0 100644 --- a/dali/devel-api/rendering/geometry.cpp +++ b/dali/devel-api/rendering/geometry.cpp @@ -85,16 +85,6 @@ Geometry::GeometryType Geometry::GetGeometryType() const return GetImplementation(*this).GetGeometryType(); } -void Geometry::SetRequiresDepthTesting( bool requiresDepthTest ) -{ - GetImplementation(*this).SetRequiresDepthTesting( requiresDepthTest ); -} - -bool Geometry::GetRequiresDepthTesting() const -{ - return GetImplementation(*this).GetRequiresDepthTesting(); -} - Geometry::Geometry( Internal::Geometry* pointer ) : BaseHandle( pointer ) { diff --git a/dali/devel-api/rendering/geometry.h b/dali/devel-api/rendering/geometry.h index c57595b..9b00dc9 100644 --- a/dali/devel-api/rendering/geometry.h +++ b/dali/devel-api/rendering/geometry.h @@ -146,24 +146,6 @@ public: */ GeometryType GetGeometryType() const; - /** - * @brief Set if the geometry requires depth testing - * - * Should be set to true if this geometry has overlapping triangles in arbitrary order - * - * Calling this function is equivalent to setting the REQUIRES_DEPTH_TESTING property - * - * @param[in] requiresDepthTest Specifies if the geometry requires depth testing - */ - void SetRequiresDepthTesting( bool requiresDepthTest ); - - /** - * @brief Return if the geometry requires depth testing - * - * @return True if the geometry requires depth testing - */ - bool GetRequiresDepthTesting() const; - public: /** * @brief The constructor diff --git a/dali/devel-api/rendering/renderer.h b/dali/devel-api/rendering/renderer.h index 814471b..b5535ed 100644 --- a/dali/devel-api/rendering/renderer.h +++ b/dali/devel-api/rendering/renderer.h @@ -45,13 +45,23 @@ public: */ enum FaceCullingMode { - NONE, ///< None of the faces should be culled + CULL_NONE, ///< None of the faces should be culled CULL_FRONT, ///< Cull front face, back face should never be shown CULL_BACK, ///< Cull back face, back face should never be shown CULL_BACK_AND_FRONT, ///< Cull back and front faces, if the geometry is composed of triangles none of the faces will be shown }; /** + * @brief Depth buffer write modes + */ + enum DepthWriteMode + { + DEPTH_WRITE_OFF, ///< Renderer doesn't write to the depth buffer + DEPTH_WRITE_AUTO, ///< Renderer only writes to the depth buffer if it's opaque + DEPTH_WRITE_ON ///< Renderer writes to the depth buffer + }; + + /** * @brief An enumeration of properties belonging to the Renderer class. */ struct Property @@ -59,7 +69,7 @@ public: enum { DEPTH_INDEX = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "depthIndex", type INTEGER - FACE_CULLING_MODE, ///< name "faceCullingMode", type INTEGER + FACE_CULLING_MODE, ///< name "faceCullingMode", type INTEGER @see FaceCullingMode BLENDING_MODE, ///< name "blendingMode", type INTEGER BLEND_EQUATION_RGB, ///< name "blendEquationRgb", type INTEGER BLEND_EQUATION_ALPHA, ///< name "blendEquationAlpha", type INTEGER @@ -70,7 +80,8 @@ public: BLENDING_COLOR, ///< name "blendingColor", type VECTOR4 BLEND_PRE_MULTIPLIED_ALPHA, ///< name "blendPreMultipledAlpha", type BOOLEAN INDEX_RANGE_FIRST, ///< name "indexRangeFirst", type INTEGER - INDEX_RANGE_COUNT ///< name "indexRangeCount", type INTEGER + INDEX_RANGE_COUNT, ///< name "indexRangeCount", type INTEGER + DEPTH_WRITE_MODE ///< name "depthWriteMode", type INTEGER @see DepthWriteMode }; }; diff --git a/dali/devel-api/rendering/shader.h b/dali/devel-api/rendering/shader.h index 91f3fcf..51179d0 100644 --- a/dali/devel-api/rendering/shader.h +++ b/dali/devel-api/rendering/shader.h @@ -73,9 +73,7 @@ public: enum ShaderHints { HINT_NONE = 0x00, ///< no hints - HINT_REQUIRES_SELF_DEPTH_TEST = 0x01, ///< Expects depth testing enabled HINT_OUTPUT_IS_TRANSPARENT = 0x02, ///< Might generate transparent alpha from opaque inputs - HINT_OUTPUT_IS_OPAQUE = 0x04, ///< Outputs opaque colors even if the inputs are transparent HINT_MODIFIES_GEOMETRY = 0x08, ///< Might change position of vertices, ///< this option disables any culling optimizations }; diff --git a/dali/internal/common/type-abstraction-enums.h b/dali/internal/common/type-abstraction-enums.h index 9bfe7cb..64cedef 100644 --- a/dali/internal/common/type-abstraction-enums.h +++ b/dali/internal/common/type-abstraction-enums.h @@ -33,6 +33,7 @@ namespace Internal template <> struct ParameterType< Dali::Renderer::FaceCullingMode > : public BasicType< Dali::Renderer::FaceCullingMode > {}; template <> struct ParameterType< BlendingMode::Type > : public BasicType< BlendingMode::Type > {}; +template <> struct ParameterType< Dali::Renderer::DepthWriteMode > : public BasicType< Dali::Renderer::DepthWriteMode > {}; } //namespace Internal diff --git a/dali/internal/event/effects/shader-effect-impl.cpp b/dali/internal/event/effects/shader-effect-impl.cpp index a7e6ee0..0a6ae7d 100644 --- a/dali/internal/event/effects/shader-effect-impl.cpp +++ b/dali/internal/event/effects/shader-effect-impl.cpp @@ -140,10 +140,7 @@ std::string GetStringProperty(const std::string& field, const Property::Value& p Dali::Shader::ShaderHints ConvertHints( Dali::ShaderEffect::GeometryHints hints) { int convertedHints = Dali::Shader::HINT_NONE; - if( hints & Dali::ShaderEffect::HINT_DEPTH_BUFFER ) - { - convertedHints |= Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST; - } + if( hints & Dali::ShaderEffect::HINT_BLENDING ) { convertedHints |= Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT; diff --git a/dali/internal/event/rendering/geometry-impl.cpp b/dali/internal/event/rendering/geometry-impl.cpp index 07ecda9..281ca92 100644 --- a/dali/internal/event/rendering/geometry-impl.cpp +++ b/dali/internal/event/rendering/geometry-impl.cpp @@ -83,21 +83,6 @@ Dali::Geometry::GeometryType Geometry::GetGeometryType() const return mGeometryType; } -void Geometry::SetRequiresDepthTesting( bool requiresDepthTest ) -{ - if( requiresDepthTest != mRequiresDepthTest ) - { - SceneGraph::SetGeometryRequiresDepthTestMessage(mEventThreadServices.GetUpdateManager(), *mRenderObject, requiresDepthTest ); - - mRequiresDepthTest = requiresDepthTest; - } -} - -bool Geometry::GetRequiresDepthTesting() const -{ - return mRequiresDepthTest; -} - const Render::Geometry* Geometry::GetRenderObject() const { return mRenderObject; @@ -106,8 +91,7 @@ const Render::Geometry* Geometry::GetRenderObject() const Geometry::Geometry() : mEventThreadServices( *Stage::GetCurrent() ), mRenderObject( NULL ), - mGeometryType(Dali::Geometry::TRIANGLES), - mRequiresDepthTest(false) + mGeometryType(Dali::Geometry::TRIANGLES) { } diff --git a/dali/internal/event/rendering/geometry-impl.h b/dali/internal/event/rendering/geometry-impl.h index 1d7ba29..3d08050 100644 --- a/dali/internal/event/rendering/geometry-impl.h +++ b/dali/internal/event/rendering/geometry-impl.h @@ -88,16 +88,6 @@ public: Dali::Geometry::GeometryType GetGeometryType() const; /** - * @copydoc Dali::Geometry::SetRequiresDepthTesting() - */ - void SetRequiresDepthTesting( bool requiresDepthTest ); - - /** - * @copydoc Dali::Geometry::GetRequiresDepthTesting() - */ - bool GetRequiresDepthTesting() const; - - /** * @brief Get the geometry scene object * * @return the geometry scene object @@ -134,8 +124,6 @@ private: // data std::vector mVertexBuffers; ///< Vector of intrusive pointers to vertex buffers Dali::Geometry::GeometryType mGeometryType; ///< Geometry type (cached) - bool mRequiresDepthTest; ///< Establish if geometry requires depth testing (cached) - }; } // namespace Internal diff --git a/dali/internal/event/rendering/renderer-impl.cpp b/dali/internal/event/rendering/renderer-impl.cpp index aa93136..a044737 100644 --- a/dali/internal/event/rendering/renderer-impl.cpp +++ b/dali/internal/event/rendering/renderer-impl.cpp @@ -53,6 +53,7 @@ DALI_PROPERTY( "blendingColor", VECTOR4, true, false, false 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_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX ) const ObjectImplHelper RENDERER_IMPL = { DEFAULT_PROPERTY_DETAILS }; @@ -459,6 +460,19 @@ void Renderer::SetDefaultProperty( Property::Index index, } break; } + case Dali::Renderer::Property::DEPTH_WRITE_MODE: + { + int value; + propertyValue.Get( value ); + Dali::Renderer::DepthWriteMode mode = static_cast(value); + if( mode != mDepthWriteMode ) + { + mDepthWriteMode = mode; + SetDepthWriteModeMessage( GetEventThreadServices(), *mSceneObject, mode ); + } + + break; + } } } @@ -567,6 +581,11 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const value = static_cast( mIndexedDrawElementCount ); break; } + case Dali::Renderer::Property::DEPTH_WRITE_MODE: + { + value = mDepthWriteMode; + break; + } } return value; } @@ -652,9 +671,10 @@ Renderer::Renderer() mOnStageCount( 0 ), mIndexedDrawFirstElement( 0 ), mIndexedDrawElementCount( 0 ), - mFaceCullingMode( Dali::Renderer::NONE ), + mFaceCullingMode( Dali::Renderer::CULL_NONE ), mBlendingMode( Dali::BlendingMode::AUTO ), mBlendingOptions(), + mDepthWriteMode( Dali::Renderer::DEPTH_WRITE_AUTO ), mPremultipledAlphaEnabled( false ) { } diff --git a/dali/internal/event/rendering/renderer-impl.h b/dali/internal/event/rendering/renderer-impl.h index aec6305..55d8109 100644 --- a/dali/internal/event/rendering/renderer-impl.h +++ b/dali/internal/event/rendering/renderer-impl.h @@ -317,8 +317,9 @@ private: // data Dali::Renderer::FaceCullingMode mFaceCullingMode; ///< Local copy of face culling mode BlendingMode::Type mBlendingMode; ///< Local copy of blending mode BlendingOptions mBlendingOptions; ///< Local copy of blending options bitmask - bool mPremultipledAlphaEnabled; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required + Dali:: Renderer::DepthWriteMode mDepthWriteMode; ///< Local copy of depth write mode + bool mPremultipledAlphaEnabled : 1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required }; } // namespace Internal diff --git a/dali/internal/event/rendering/shader-impl.cpp b/dali/internal/event/rendering/shader-impl.cpp index 1f5ade8..698a03b 100644 --- a/dali/internal/event/rendering/shader-impl.cpp +++ b/dali/internal/event/rendering/shader-impl.cpp @@ -50,9 +50,7 @@ const ObjectImplHelper SHADER_IMPL = { DEFAULT_PROPERTY_ Dali::Scripting::StringEnum ShaderHintsTable[] = { { "HINT_NONE", Dali::Shader::HINT_NONE}, - { "HINT_REQUIRES_SELF_DEPTH_TEST", Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST}, { "HINT_OUTPUT_IS_TRANSPARENT", Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT}, - { "HINT_OUTPUT_IS_OPAQUE", Dali::Shader::HINT_OUTPUT_IS_OPAQUE}, { "HINT_MODIFIES_GEOMETRY", Dali::Shader::HINT_MODIFIES_GEOMETRY} }; @@ -85,21 +83,11 @@ Property::Value HintString(const Dali::Shader::ShaderHints& hints) s = "HINT_NONE"; } - if(hints & Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST) - { - AppendString(s, "HINT_REQUIRES_SELF_DEPTH_TEST"); - } - if(hints & Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT) { AppendString(s, "HINT_OUTPUT_IS_TRANSPARENT"); } - if(hints & Dali::Shader::HINT_OUTPUT_IS_OPAQUE) - { - AppendString(s, "HINT_OUTPUT_IS_OPAQUE"); - } - if(hints & Dali::Shader::HINT_MODIFIES_GEOMETRY) { AppendString(s, "HINT_MODIFIES_GEOMETRY"); @@ -307,26 +295,7 @@ void Shader::Initialize( { EventThreadServices& eventThreadServices = GetEventThreadServices(); SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager(); - - // @todo MESH_REWORK - Pass hints directly to a new scene graph shader - int effectHint = Dali::ShaderEffect::HINT_NONE; - if( hints & Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT ) - { - effectHint |= Dali::ShaderEffect::HINT_BLENDING; - } - - if( hints & Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST ) - { - effectHint |= Dali::ShaderEffect::HINT_DEPTH_BUFFER; - } - - if( (hints & Dali::Shader::HINT_MODIFIES_GEOMETRY) == 0x0 ) - { - effectHint |= Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY; - } - Dali::ShaderEffect::GeometryHints shaderEffectHint = static_cast( effectHint ); - - mSceneObject = new SceneGraph::Shader( shaderEffectHint ); + mSceneObject = new SceneGraph::Shader( hints ); // Add to update manager AddShaderMessage( updateManager, *mSceneObject ); diff --git a/dali/internal/render/common/render-algorithms.cpp b/dali/internal/render/common/render-algorithms.cpp index abdfdd7..bb51831 100644 --- a/dali/internal/render/common/render-algorithms.cpp +++ b/dali/internal/render/common/render-algorithms.cpp @@ -70,18 +70,24 @@ inline void SetRenderFlags( const RenderList& renderList, Context& context ) { const unsigned int renderFlags = renderList.GetFlags(); - bool enableDepthBuffer = ( ( renderFlags & RenderList::DEPTH_BUFFER_ENABLED ) != 0u ); + if( ( renderFlags & RenderList::DEPTH_BUFFER_ENABLED ) != 0u ) + { + //Enable depth testing + context.EnableDepthBuffer( true ); + } + else + { + //Disable depth test and depth write + context.EnableDepthBuffer( false ); + context.DepthMask( false ); + } GLbitfield clearMask = ( renderFlags & RenderList::DEPTH_CLEAR ) ? GL_DEPTH_BUFFER_BIT : 0u; - context.EnableDepthBuffer( enableDepthBuffer ); - // Stencil enabled, writing, and clearing... const bool enableStencilBuffer( renderFlags & RenderList::STENCIL_BUFFER_ENABLED ); const bool enableStencilWrite( renderFlags & RenderList::STENCIL_WRITE ); - context.EnableStencilBuffer( enableStencilBuffer ); - if( enableStencilBuffer ) { context.StencilFunc( (enableStencilWrite ? GL_ALWAYS : GL_EQUAL), 1, 0xFF ); @@ -130,15 +136,30 @@ inline void ProcessRenderList( { bool depthBufferEnabled = ( ( renderList.GetFlags() & RenderList::DEPTH_BUFFER_ENABLED ) != 0u ); size_t count = renderList.Count(); - for ( size_t index = 0; index < count; ++index ) + + if( depthBufferEnabled ) { - const RenderItem& item = renderList.GetItem( index ); - DALI_PRINT_RENDER_ITEM( item ); + for ( size_t index = 0; index < count; ++index ) + { + const RenderItem& item = renderList.GetItem( index ); + DALI_PRINT_RENDER_ITEM( item ); - //Enable depth writes if depth buffer is enabled and item is opaque - context.DepthMask( depthBufferEnabled && ( item.IsOpaque() || item.GetRenderer().RequiresDepthTest() ) ); + Renderer& renderer = item.GetRenderer(); + Dali::Renderer::DepthWriteMode depthWriteMode = renderer.GetDepthWriteMode(); + context.DepthMask( ( depthWriteMode == Dali::Renderer::DEPTH_WRITE_AUTO && item.IsOpaque() ) || + ( depthWriteMode == Dali::Renderer::DEPTH_WRITE_ON ) ); - item.GetRenderer().Render( context, textureCache, bufferIndex, item.GetNode(), defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, item.GetSize(), !item.IsOpaque() ); + renderer.Render( context, textureCache, bufferIndex, item.GetNode(), defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, item.GetSize(), !item.IsOpaque() ); + } + } + else + { + for ( size_t index = 0; index < count; ++index ) + { + const RenderItem& item = renderList.GetItem( index ); + DALI_PRINT_RENDER_ITEM( item ); + item.GetRenderer().Render( context, textureCache, bufferIndex, item.GetNode(), defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, item.GetSize(), !item.IsOpaque() ); + } } } else diff --git a/dali/internal/render/common/render-manager.cpp b/dali/internal/render/common/render-manager.cpp index 04b90a3..eeccd6f 100644 --- a/dali/internal/render/common/render-manager.cpp +++ b/dali/internal/render/common/render-manager.cpp @@ -400,11 +400,6 @@ void RenderManager::SetGeometryType( Render::Geometry* geometry, unsigned int ge geometry->SetGeometryType( Render::Geometry::GeometryType(geometryType) ); } -void RenderManager::SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest ) -{ - geometry->SetRequiresDepthTest( requiresDepthTest ); -} - void RenderManager::AddRenderTracker( Render::RenderTracker* renderTracker ) { mImpl->AddRenderTracker(renderTracker); diff --git a/dali/internal/render/common/render-manager.h b/dali/internal/render/common/render-manager.h index ad4c059..25a55d5 100644 --- a/dali/internal/render/common/render-manager.h +++ b/dali/internal/render/common/render-manager.h @@ -262,13 +262,6 @@ public: void SetGeometryType( Render::Geometry* geometry, unsigned int geometryType ); /** - * Set if an existing geometry requires depth testing - * @param[in] geometry The render geometry - * @param[in] requiresDepthTest True if depth testing is required, false otherwise - */ - void SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest ); - - /** * Adds a render tracker to the RenderManager. RenderManager takes ownership of the * tracker. The lifetime of the tracker is related to the lifetime of the tracked * object, usually an offscreen render task. diff --git a/dali/internal/render/gl-resources/context.cpp b/dali/internal/render/gl-resources/context.cpp index e701452..e3741a8 100644 --- a/dali/internal/render/gl-resources/context.cpp +++ b/dali/internal/render/gl-resources/context.cpp @@ -93,7 +93,7 @@ Context::Context(Integration::GlAbstraction& glAbstraction) mBlendEquationSeparateModeAlpha( GL_FUNC_ADD ), mMaxTextureSize(0), mClearColor(Color::WHITE), // initial color, never used until it's been set by the user - mCullFaceMode( Dali::Renderer::NONE ), + mCullFaceMode( Dali::Renderer::CULL_NONE ), mViewPort( 0, 0, 0, 0 ) { } @@ -227,7 +227,7 @@ void Context::InitializeGlState() mBlendEquationSeparateModeRGB = GL_FUNC_ADD; mBlendEquationSeparateModeAlpha = GL_FUNC_ADD; - mCullFaceMode = Dali::Renderer::NONE; //By default cullface is disabled, front face is set to CCW and cull face is set to back + mCullFaceMode = Dali::Renderer::CULL_NONE; //By default cullface is disabled, front face is set to CCW and cull face is set to back // get maximum texture size mGlAbstraction.GetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize); diff --git a/dali/internal/render/gl-resources/context.h b/dali/internal/render/gl-resources/context.h index 16782e3..42e90c7 100644 --- a/dali/internal/render/gl-resources/context.h +++ b/dali/internal/render/gl-resources/context.h @@ -545,7 +545,7 @@ public: mCullFaceMode = mode; switch(mode) { - case Dali::Renderer::NONE: + case Dali::Renderer::CULL_NONE: { LOG_GL("Disable GL_CULL_FACE\n"); CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_CULL_FACE) ); diff --git a/dali/internal/render/renderers/render-geometry.cpp b/dali/internal/render/renderers/render-geometry.cpp index 0fc5c78..e151493 100644 --- a/dali/internal/render/renderers/render-geometry.cpp +++ b/dali/internal/render/renderers/render-geometry.cpp @@ -33,7 +33,6 @@ Geometry::Geometry() mIndexBuffer(NULL), mGeometryType( Dali::Geometry::TRIANGLES ), mIndicesChanged(false), - mRequiresDepthTest(false ), mHasBeenUpdated(false), mAttributesChanged(true) { diff --git a/dali/internal/render/renderers/render-geometry.h b/dali/internal/render/renderers/render-geometry.h index f9777f4..90f06af 100644 --- a/dali/internal/render/renderers/render-geometry.h +++ b/dali/internal/render/renderers/render-geometry.h @@ -117,24 +117,6 @@ public: } /** - * Sets if the geometry requires depth testing - * @param[in] requiresDepthTest True if depth testing is required, false otherwise - */ - void SetRequiresDepthTest( bool requiresDepthTest ) - { - mRequiresDepthTest = requiresDepthTest; - } - - /** - * Check if geometry requires depth testing - * @return True if depth testing is required, false otherwise - */ - bool RequiresDepthTest() const - { - return mRequiresDepthTest; - } - - /** * Upload the geometry if it has changed, set up the attributes and perform * the Draw call corresponding to the geometry type * @param[in] context The GL context @@ -160,7 +142,6 @@ private: // Booleans bool mIndicesChanged : 1; - bool mRequiresDepthTest : 1; bool mHasBeenUpdated : 1; bool mAttributesChanged : 1; diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp index 1edc017..f87cfbb 100644 --- a/dali/internal/render/renderers/render-renderer.cpp +++ b/dali/internal/render/renderers/render-renderer.cpp @@ -115,9 +115,10 @@ Renderer* Renderer::New( SceneGraph::RenderDataProvider* dataProvider, unsigned int blendingBitmask, const Vector4* blendColor, Dali::Renderer::FaceCullingMode faceCullingMode, - bool preMultipliedAlphaEnabled ) + bool preMultipliedAlphaEnabled, + Dali::Renderer::DepthWriteMode depthWriteMode ) { - return new Renderer( dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled ); + return new Renderer( dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode ); } Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider, @@ -125,7 +126,8 @@ Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider, unsigned int blendingBitmask, const Vector4* blendColor, Dali::Renderer::FaceCullingMode faceCullingMode, - bool preMultipliedAlphaEnabled) + bool preMultipliedAlphaEnabled, + Dali::Renderer::DepthWriteMode depthWriteMode ) : mRenderDataProvider( dataProvider ), mContext(NULL), mTextureCache( NULL ), @@ -135,9 +137,9 @@ Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider, mAttributesLocation(), mBlendingOptions(), mFaceCullingMode( faceCullingMode ), + mDepthWriteMode( depthWriteMode ), mIndexedDrawFirstElement( 0 ), mIndexedDrawElementsCount( 0 ), - mSamplerBitfield( ImageSampler::PackBitfield( FilterMode::DEFAULT, FilterMode::DEFAULT ) ), mUpdateAttributesLocation( true ), mPremultipledAlphaEnabled( preMultipliedAlphaEnabled ) { @@ -175,14 +177,6 @@ void Renderer::SetGeometry( Render::Geometry* geometry ) mUpdateAttributesLocation = true; } -// Note - this is currently called from UpdateThread, PrepareRenderInstructions, -// as an optimisation. -// @todo MESH_REWORK Should use Update thread objects only in PrepareRenderInstructions. -bool Renderer::RequiresDepthTest() const -{ - return mGeometry->RequiresDepthTest(); -} - void Renderer::SetBlending( Context& context, bool blend ) { context.SetBlend( blend ); @@ -434,9 +428,14 @@ void Renderer::EnablePreMultipliedAlpha( bool enable ) mPremultipledAlphaEnabled = enable; } -void Renderer::SetSampler( unsigned int samplerBitfield ) +void Renderer::SetDepthWriteMode( Dali::Renderer::DepthWriteMode depthWriteMode ) +{ + mDepthWriteMode = depthWriteMode; +} + +Dali::Renderer::DepthWriteMode Renderer::GetDepthWriteMode() const { - mSamplerBitfield = samplerBitfield; + return mDepthWriteMode; } void Renderer::Render( Context& context, diff --git a/dali/internal/render/renderers/render-renderer.h b/dali/internal/render/renderers/render-renderer.h index 9c6b5b4..764c09f 100644 --- a/dali/internal/render/renderers/render-renderer.h +++ b/dali/internal/render/renderers/render-renderer.h @@ -82,13 +82,15 @@ public: * @param[in] blendColor The blend color to pass to GL * @param[in] faceCullingMode The face-culling mode. * @param[in] preMultipliedAlphaEnabled whether alpha is pre-multiplied. + * @param[in] depthWriteMode Depth buffer write mode */ static Renderer* New( SceneGraph::RenderDataProvider* dataProviders, Render::Geometry* geometry, unsigned int blendingBitmask, const Vector4* blendColor, Dali::Renderer::FaceCullingMode faceCullingMode, - bool preMultipliedAlphaEnabled); + bool preMultipliedAlphaEnabled, + Dali::Renderer::DepthWriteMode depthWriteMode ); /** * Constructor. @@ -98,13 +100,15 @@ public: * @param[in] blendColor The blend color to pass to GL * @param[in] faceCullingMode The face-culling mode. * @param[in] preMultipliedAlphaEnabled whether alpha is pre-multiplied. + * @param[in] depthWriteMode Depth buffer write mode */ Renderer( SceneGraph::RenderDataProvider* dataProviders, Render::Geometry* geometry, unsigned int blendingBitmask, const Vector4* blendColor, Dali::Renderer::FaceCullingMode faceCullingMode, - bool preMultipliedAlphaEnabled); + bool preMultipliedAlphaEnabled, + Dali::Renderer::DepthWriteMode depthWriteMode ); /** * Change the data providers of the renderer @@ -169,16 +173,16 @@ public: void EnablePreMultipliedAlpha( bool preMultipled ); /** - * Set the sampler used to render the set texture. - * @param[in] samplerBitfield The packed sampler options used to render. + * Query the Renderer's depth write mode + * @return The renderer depth write mode */ - void SetSampler( unsigned int samplerBitfield ); + Dali::Renderer::DepthWriteMode GetDepthWriteMode() const; /** - * Query whether the derived type of Renderer requires depth testing. - * @return True if the renderer requires depth testing. + * Sets the depth write mode + * @param[in] depthWriteMode The depth write mode */ - bool RequiresDepthTest() const; + void SetDepthWriteMode( Dali::Renderer::DepthWriteMode depthWriteMode ); /** * Called to render during RenderManager::Render(). @@ -238,6 +242,9 @@ private: /** * Set the program uniform in the map from the mapped property + * @param[in] bufferIndex The index of the previous update buffer. + * @param[in] program The shader program + * @param[in] map The uniform */ void SetUniformFromProperty( BufferIndex bufferIndex, Program& program, UniformIndexMap& map ); @@ -249,12 +256,10 @@ private: */ bool BindTextures( SceneGraph::TextureCache& textureCache, Program& program ); -public: +private: OwnerPointer< SceneGraph::RenderDataProvider > mRenderDataProvider; -private: - Context* mContext; SceneGraph::TextureCache* mTextureCache; Render::UniformNameCache* mUniformNameCache; @@ -273,13 +278,13 @@ private: BlendingOptions mBlendingOptions; /// Blending options including blend color, blend func and blend equation Dali::Renderer::FaceCullingMode mFaceCullingMode; /// Mode of face culling + Dali::Renderer::DepthWriteMode mDepthWriteMode; /// Depth write mode size_t mIndexedDrawFirstElement; /// Offset of first element to draw size_t mIndexedDrawElementsCount; /// Number of elements to draw - unsigned int mSamplerBitfield; ///< Sampler options used for texture filtering bool mUpdateAttributesLocation:1; ///< Indicates attribute locations have changed - bool mPremultipledAlphaEnabled:1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required + bool mPremultipledAlphaEnabled:1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required }; } // namespace SceneGraph diff --git a/dali/internal/render/shaders/scene-graph-shader.cpp b/dali/internal/render/shaders/scene-graph-shader.cpp index a95600a..3966d15 100644 --- a/dali/internal/render/shaders/scene-graph-shader.cpp +++ b/dali/internal/render/shaders/scene-graph-shader.cpp @@ -35,8 +35,8 @@ namespace Internal namespace SceneGraph { -Shader::Shader( Dali::ShaderEffect::GeometryHints& hints ) -: mGeometryHints( hints ), +Shader::Shader( Dali::Shader::ShaderHints& hints ) +: mHints( hints ), mProgram( NULL ), mConnectionObservers() { diff --git a/dali/internal/render/shaders/scene-graph-shader.h b/dali/internal/render/shaders/scene-graph-shader.h index 813657b..278d5f2 100644 --- a/dali/internal/render/shaders/scene-graph-shader.h +++ b/dali/internal/render/shaders/scene-graph-shader.h @@ -47,9 +47,9 @@ public: /** * Constructor - * @param hints Geometry hints + * @param hints Shader hints */ - Shader( Dali::ShaderEffect::GeometryHints& hints ); + Shader( Dali::Shader::ShaderHints& hints ); /** * Virtual destructor @@ -61,32 +61,14 @@ public: //////////////////////////////////////////////////////////////////////////////////////////////////////////////// /** - * Query whether a shader geometry hint is set. + * Query whether a shader hint is set. * @pre The shader has been initialized. - * @param[in] hint The geometry hint to check. - * @return True if the given geometry hint is set. + * @param[in] hint The hint to check. + * @return True if the given hint is set. */ - bool GeometryHintEnabled( Dali::ShaderEffect::GeometryHints hint ) const + bool HintEnabled( Dali::Shader::ShaderHints hint ) const { - return mGeometryHints & hint; - } - - /** - * Retrieve the set of geometry hints. - * @return The hints. - */ - Dali::ShaderEffect::GeometryHints GetGeometryHints() const - { - return mGeometryHints; - } - - /** - * Set the geometry hints. - * @param[in] hints The hints. - */ - void SetGeometryHints( Dali::ShaderEffect::GeometryHints hints ) - { - mGeometryHints = hints; + return mHints & hint; } /** @@ -173,7 +155,7 @@ public: // UniformMap::Observer private: // Data - Dali::ShaderEffect::GeometryHints mGeometryHints; ///< shader geometry hints for building the geometry + Dali::Shader::ShaderHints mHints; Program* mProgram; diff --git a/dali/internal/update/manager/prepare-render-instructions.cpp b/dali/internal/update/manager/prepare-render-instructions.cpp index 4f3e2e9..0dbbeda 100644 --- a/dali/internal/update/manager/prepare-render-instructions.cpp +++ b/dali/internal/update/manager/prepare-render-instructions.cpp @@ -73,7 +73,7 @@ inline void AddRendererToRenderList( BufferIndex updateBufferIndex, const Matrix& worldMatrix = renderable.mNode->GetWorldMatrix( updateBufferIndex ); const Vector3& size = renderable.mNode->GetSize( updateBufferIndex ); - if ( cull && renderable.mRenderer->GetShader().GeometryHintEnabled( Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY ) ) + if ( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::HINT_MODIFIES_GEOMETRY ) ) { const Vector3& position = worldMatrix.GetTranslation3(); float radius( size.Length() * 0.5f ); @@ -371,15 +371,12 @@ inline void AddColorRenderers( BufferIndex updateBufferIndex, flags = RenderList::STENCIL_BUFFER_ENABLED; } - // Special optimization if depth test is disabled or if only one opaque rendered in the layer (for example background image) - // and this renderer does not need depth test against itself (e.g. mesh) - // and if this layer has got exactly one opaque renderer - // and this renderer is not interested in depth testing - // (i.e. is an image and not a mesh) - + // Special optimization. If this layer has got exactly one renderer + // and this renderer is not writing to the depth buffer there is no point on enabling + // depth buffering if ( ( renderList.Count() == 1 ) && - ( !renderList.GetRenderer( 0 ).RequiresDepthTest() ) && - ( !renderList.GetItem(0).IsOpaque() ) ) + (( renderList.GetRenderer( 0 ).GetDepthWriteMode() == Dali::Renderer::DEPTH_WRITE_OFF ) || + ( renderList.GetRenderer( 0 ).GetDepthWriteMode() == Dali::Renderer::DEPTH_WRITE_AUTO && !renderList.GetItem(0).IsOpaque() ))) { //Nothing to do here } diff --git a/dali/internal/update/manager/update-manager.cpp b/dali/internal/update/manager/update-manager.cpp index 7903261..bb3da52 100644 --- a/dali/internal/update/manager/update-manager.cpp +++ b/dali/internal/update/manager/update-manager.cpp @@ -1237,17 +1237,6 @@ void UpdateManager::RemoveGeometry( Render::Geometry* geometry ) new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveGeometry, geometry ); } -void UpdateManager::SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest ) -{ - typedef MessageValue2< RenderManager, Render::Geometry*, bool > DerivedType; - - // Reserve some memory inside the render queue - unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); - - // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetGeometryRequiresDepthTest, geometry, requiresDepthTest ); -} - void UpdateManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType ) { typedef MessageValue2< RenderManager, Render::Geometry*, unsigned int > DerivedType; diff --git a/dali/internal/update/manager/update-manager.h b/dali/internal/update/manager/update-manager.h index e8ea3b6..8ccae95 100644 --- a/dali/internal/update/manager/update-manager.h +++ b/dali/internal/update/manager/update-manager.h @@ -442,13 +442,6 @@ public: void RemoveGeometry( Render::Geometry* geometry ); /** - * Sets if a Geometry requieres depth testing - * @param[in] geometry The geometry - * @param[in] requiresDepthTest True if the geometry requires depth testing, false otherwise - */ - void SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest ); - - /** * Sets the geometry type of an existing Geometry * @param[in] geometry The geometry * @param[in] geometryType The type of the geometry @@ -1156,17 +1149,6 @@ inline void SetGeometryTypeMessage( UpdateManager& manager, Render::Geometry& ge new (slot) LocalType( &manager, &UpdateManager::SetGeometryType, &geometry, geometryType ); } -inline void SetGeometryRequiresDepthTestMessage( UpdateManager& manager, Render::Geometry& geometry, bool requiresDepthTest ) -{ - typedef MessageValue2< UpdateManager, Render::Geometry*, bool > LocalType; - - // Reserve some memory inside the message queue - unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) ); - - // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &manager, &UpdateManager::SetGeometryRequiresDepthTest, &geometry, requiresDepthTest ); -} - } // namespace SceneGraph } // namespace Internal diff --git a/dali/internal/update/rendering/scene-graph-renderer.cpp b/dali/internal/update/rendering/scene-graph-renderer.cpp index ec8965f..3c0595c 100644 --- a/dali/internal/update/rendering/scene-graph-renderer.cpp +++ b/dali/internal/update/rendering/scene-graph-renderer.cpp @@ -97,6 +97,7 @@ enum Flags RESEND_PREMULTIPLIED_ALPHA = 1 << 5, RESEND_INDEXED_DRAW_FIRST_ELEMENT = 1 << 6, RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 7, + RESEND_DEPTH_WRITE_MODE = 1 << 8, }; } @@ -121,8 +122,9 @@ Renderer::Renderer() mShader( NULL ), mBlendColor( NULL ), mBlendBitmask( 0u ), - mFaceCullingMode( Dali::Renderer::NONE ), + mFaceCullingMode( Dali::Renderer::CULL_NONE ), mBlendingMode( Dali::BlendingMode::AUTO ), + mDepthWriteMode( Dali::Renderer::DEPTH_WRITE_AUTO ), mIndexedDrawFirstElement( 0 ), mIndexedDrawElementsCount( 0 ), mReferenceCount( 0 ), @@ -130,6 +132,7 @@ Renderer::Renderer() mResendFlag( 0 ), mResourcesReady( false ), mFinishedResourceAcquisition( false ), + mPremultipledAlphaEnabled(false), mDepthIndex( 0 ) { mUniformMapChanged[0] = false; @@ -212,76 +215,75 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex ) mRegenerateUniformMap--; } - if( mResendFlag == 0 ) + if( mResendFlag != 0 ) { - return; - } + if( mResendFlag & RESEND_DATA_PROVIDER ) + { + RenderDataProvider* dataProvider = NewRenderDataProvider(); - if( mResendFlag & RESEND_DATA_PROVIDER ) - { - RenderDataProvider* dataProvider = NewRenderDataProvider(); + typedef MessageValue1< Render::Renderer, OwnerPointer > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderDataProvider, dataProvider ); + } - typedef MessageValue1< Render::Renderer, OwnerPointer > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderDataProvider, dataProvider ); - mResendFlag &= ~RESEND_DATA_PROVIDER; - } + if( mResendFlag & RESEND_GEOMETRY ) + { + typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - if( mResendFlag & RESEND_GEOMETRY ) - { - typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry ); + } - new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry ); - mResendFlag &= ~RESEND_GEOMETRY; - } + if( mResendFlag & RESEND_FACE_CULLING_MODE ) + { + typedef MessageValue1< Render::Renderer, Dali::Renderer::FaceCullingMode > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode ); + } - if( mResendFlag & RESEND_FACE_CULLING_MODE ) - { - typedef MessageValue1< Render::Renderer, Dali::Renderer::FaceCullingMode > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode ); - mResendFlag &= ~RESEND_FACE_CULLING_MODE; - } + if( mResendFlag & RESEND_BLEND_BIT_MASK ) + { + typedef MessageValue1< Render::Renderer, unsigned int > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask ); + } - if( mResendFlag & RESEND_BLEND_BIT_MASK ) - { - typedef MessageValue1< Render::Renderer, unsigned int > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask ); - mResendFlag &= ~RESEND_BLEND_BIT_MASK; - } + if( mResendFlag & RESEND_BLEND_COLOR ) + { + typedef MessageValue1< Render::Renderer, const Vector4* > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, mBlendColor ); + } - if( mResendFlag & RESEND_BLEND_COLOR ) - { - typedef MessageValue1< Render::Renderer, const Vector4* > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, mBlendColor ); - mResendFlag &= ~RESEND_BLEND_COLOR; - } + if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA ) + { + typedef MessageValue1< Render::Renderer, bool > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled ); + } - if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA ) - { - typedef MessageValue1< Render::Renderer, bool > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled ); - mResendFlag &= ~RESEND_PREMULTIPLIED_ALPHA; - } + if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT ) + { + typedef MessageValue1< Render::Renderer, size_t > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement ); + } - if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT ) - { - typedef MessageValue1< Render::Renderer, size_t > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement ); - mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT; - } + if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT ) + { + typedef MessageValue1< Render::Renderer, size_t > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount ); + } - if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT ) - { - typedef MessageValue1< Render::Renderer, size_t > DerivedType; - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount ); - mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT; + if( mResendFlag & RESEND_DEPTH_WRITE_MODE ) + { + typedef MessageValue1< Render::Renderer, Dali::Renderer::DepthWriteMode > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode ); + } + + mResendFlag = 0; } } @@ -383,6 +385,12 @@ void Renderer::EnablePreMultipliedAlpha( bool preMultipled ) mResendFlag |= RESEND_PREMULTIPLIED_ALPHA; } +void Renderer::SetDepthWriteMode( unsigned int depthWriteMode ) +{ + mDepthWriteMode = static_cast(depthWriteMode); + mResendFlag |= RESEND_DEPTH_WRITE_MODE; +} + //Called when a node with this renderer is added to the stage void Renderer::OnStageConnect() { @@ -394,7 +402,9 @@ void Renderer::OnStageConnect() mRenderer = Render::Renderer::New( dataProvider, mGeometry, mBlendBitmask, mBlendColor, static_cast< Dali::Renderer::FaceCullingMode >( mFaceCullingMode ), - mPremultipledAlphaEnabled ); + mPremultipledAlphaEnabled, + mDepthWriteMode ); + mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer ); mResendFlag = 0; } @@ -481,7 +491,7 @@ Renderer::Opacity Renderer::GetOpacity( BufferIndex updateBufferIndex, const Nod } case BlendingMode::AUTO: { - bool shaderRequiresBlending( mShader->GeometryHintEnabled( Dali::ShaderEffect::HINT_BLENDING ) ); + bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT ) ); if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) ) { opacity = Renderer::TRANSLUCENT; diff --git a/dali/internal/update/rendering/scene-graph-renderer.h b/dali/internal/update/rendering/scene-graph-renderer.h index 03af729..627e29e 100644 --- a/dali/internal/update/rendering/scene-graph-renderer.h +++ b/dali/internal/update/rendering/scene-graph-renderer.h @@ -167,6 +167,12 @@ public: void EnablePreMultipliedAlpha( bool preMultipled ); /** + * Sets the depth buffer write mode + * @param[in] depthWriteMode The depth buffer write mode + */ + void SetDepthWriteMode( unsigned int depthWriteMode ); + + /** * Called when an actor with this renderer is added to the stage */ void OnStageConnect(); @@ -316,6 +322,7 @@ private: unsigned int mBlendBitmask; ///< The bitmask of blending options Dali::Renderer::FaceCullingMode mFaceCullingMode; ///< The mode of face culling BlendingMode::Type mBlendingMode; ///< The mode of blending + Dali::Renderer::DepthWriteMode mDepthWriteMode; ///< The depth write mode CollectedUniformMap mCollectedUniformMap[2]; ///< Uniform maps collected by the renderer @@ -323,11 +330,12 @@ private: size_t mIndexedDrawElementsCount; ///< number of elements to be drawn using indexed draw unsigned int mReferenceCount; ///< Number of nodes currently using this renderer unsigned int mRegenerateUniformMap; ///< 2 if the map should be regenerated, 1 if it should be copied. - unsigned char mResendFlag; ///< Indicate whether data should be resent to the renderer + unsigned char mResendFlag; ///< Indicate whether data should be resent to the renderer bool mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame bool mResourcesReady; ///< Set during the Update algorithm; true if the attachment has resources ready for the current frame. bool mFinishedResourceAcquisition; ///< Set during DoPrepareResources; true if ready & all resource acquisition has finished (successfully or otherwise) - bool mPremultipledAlphaEnabled; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required + bool mPremultipledAlphaEnabled : 1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required + public: int mDepthIndex; ///< Used only in PrepareRenderInstructions @@ -449,6 +457,16 @@ inline void SetEnablePreMultipliedAlphaMessage( EventThreadServices& eventThread new (slot) LocalType( &renderer, &Renderer::EnablePreMultipliedAlpha, preMultiplied ); } +inline void SetDepthWriteModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, Dali::Renderer::DepthWriteMode depthWriteMode ) +{ + typedef MessageValue1< Renderer, unsigned int > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetDepthWriteMode, depthWriteMode ); +} + inline void OnStageConnectMessage( EventThreadServices& eventThreadServices, const Renderer& renderer ) { typedef Message< Renderer > LocalType; -- 2.7.4