From: Andrew Poor Date: Mon, 5 Sep 2016 16:02:01 +0000 (+0100) Subject: [3.0] Set up the depth buffer based on per-renderer flags. X-Git-Tag: accepted/tizen/3.0/ivi/20161011.043719~7 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-core.git;a=commitdiff_plain;h=13a43441a81bf8c6d83bb2ac1e9724302ed8ed18 [3.0] Set up the depth buffer based on per-renderer flags. Change-Id: I91cc5229433561044c163fd84ce564bb20299fd0 --- diff --git a/automated-tests/src/dali/utc-Dali-Renderer.cpp b/automated-tests/src/dali/utc-Dali-Renderer.cpp index 3bfbacf..78b4795 100644 --- a/automated-tests/src/dali/utc-Dali-Renderer.cpp +++ b/automated-tests/src/dali/utc-Dali-Renderer.cpp @@ -2166,8 +2166,7 @@ int UtcDaliRendererSetDepthTestMode(void) // 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 *still* off. - // This is because our renderer has DepthTestMode::AUTO and our layer behavior is LAYER_2D. + // Turn the layer depth-test flag back on, and confirm that depth testing is now on. Stage::GetCurrent().GetRootLayer().SetDepthTestDisabled( false ); glEnableDisableStack.Reset(); @@ -2175,7 +2174,7 @@ int UtcDaliRendererSetDepthTestMode(void) application.Render(); // Check depth-test is *still* disabled. - DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) ); + DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) ); END_TEST; } diff --git a/dali/internal/render/common/render-algorithms.cpp b/dali/internal/render/common/render-algorithms.cpp index 95c0cae..9410358 100644 --- a/dali/internal/render/common/render-algorithms.cpp +++ b/dali/internal/render/common/render-algorithms.cpp @@ -85,7 +85,7 @@ inline void SetScissorTest( const RenderList& renderList, Context& context ) * @param[in] depthTestEnabled True if depth test is enabled for the layer * @param[in] isLayer3D True if the layer is a 3D layer */ -inline void SetRenderFlags( const RenderList& renderList, Context& context, bool depthTestEnabled, bool isLayer3D ) +inline void SetRenderFlags( const RenderList& renderList, Context& context, bool depthTestEnabled ) { const unsigned int renderFlags = renderList.GetFlags(); GLbitfield clearMask = 0u; @@ -108,20 +108,18 @@ inline void SetRenderFlags( const RenderList& renderList, Context& context, bool } // Enable and Clear the depth buffer if required. - // DepthTest must be enabled for the layer, else testing is turned off. - if( !depthTestEnabled ) + if( depthTestEnabled ) { - context.EnableDepthBuffer( false ); - } - else if( renderList.HasColorRenderItems() || isLayer3D ) // Also, within the context of this if(), depth test is enabled. - { - clearMask |= GL_DEPTH_BUFFER_BIT; + // We need to enable the depth buffer to clear it. // Subsequently it is enabled and disabled on a per-RenderItem basis. - // If we do not have color renderers, this is only done for 3D layers. context.EnableDepthBuffer( true ); } + else + { + context.EnableDepthBuffer( false ); + } // Clear Depth and/or stencil buffers as required. // Note: The buffers will only be cleared if written to since a previous clear. @@ -184,21 +182,21 @@ inline void SetupPerRendererFlags( const RenderItem& item, Context& context, boo * If AUTO is selected for writing, the decision will be based on the items opacity. * @param item The RenderItem to set up the depth buffer for * @param context The context used to execute GL commands. - * @param isLayer3D True if the layer behavior is set to LAYER_3D + * @param depthTestEnabled True if depth testing has been enabled. */ -inline void SetupDepthBuffer( const RenderItem& item, Context& context, bool isLayer3D ) +inline void SetupDepthBuffer( const RenderItem& item, Context& context, bool depthTestEnabled ) { // Set up whether or not to write to the depth buffer. const DepthWriteMode::Type depthWriteMode = item.mRenderer->GetDepthWriteMode(); // Most common mode (AUTO) is tested first. - bool enableDepthWrite = ( ( depthWriteMode == DepthWriteMode::AUTO ) && item.mIsOpaque ) || + bool enableDepthWrite = ( ( depthWriteMode == DepthWriteMode::AUTO ) && depthTestEnabled && item.mIsOpaque ) || ( depthWriteMode == DepthWriteMode::ON ); context.DepthMask( enableDepthWrite ); // Set up whether or not to read from (test) the depth buffer. const DepthTestMode::Type depthTestMode = item.mRenderer->GetDepthTestMode(); // Most common mode (AUTO) is tested first. - bool enableDepthTest = ( ( depthTestMode == DepthTestMode::AUTO ) && isLayer3D ) || + bool enableDepthTest = ( ( depthTestMode == DepthTestMode::AUTO ) && depthTestEnabled ) || ( depthTestMode == DepthTestMode::ON ); // Look-up the GL depth function from the Dali::DepthFunction enum, and set it. context.DepthFunc( DaliDepthToGLDepthTable[ item.mRenderer->GetDepthFunction() ] ); @@ -227,45 +225,29 @@ inline void ProcessRenderList( { DALI_PRINT_RENDER_LIST( renderList ); - bool depthTestEnabled = !( renderList.GetSourceLayer()->IsDepthTestDisabled() ); - bool isLayer3D = renderList.GetSourceLayer()->GetBehavior() == Dali::Layer::LAYER_3D; + bool autoDepthTestMode = !( renderList.GetSourceLayer()->IsDepthTestDisabled() ) && renderList.HasColorRenderItems(); bool usedStencilBuffer = false; bool stencilManagedByDrawMode = renderList.GetFlags() & RenderList::STENCIL_BUFFER_ENABLED; SetScissorTest( renderList, context ); - SetRenderFlags( renderList, context, depthTestEnabled, isLayer3D ); + SetRenderFlags( renderList, context, autoDepthTestMode ); - // The Layers depth enabled flag overrides the per-renderer depth flags. - // So if depth test is disabled at the layer level, we ignore per-render flags. - // Note: Overlay renderers will not read or write from the depth buffer. - if( DALI_LIKELY( !renderList.HasColorRenderItems() || !depthTestEnabled ) ) + const size_t count = renderList.Count(); + for ( size_t index = 0; index < count; ++index ) { - size_t count = renderList.Count(); - for ( size_t index = 0; index < count; ++index ) - { - const RenderItem& item = renderList.GetItem( index ); - DALI_PRINT_RENDER_ITEM( item ); - - SetupPerRendererFlags( item, context, usedStencilBuffer, stencilManagedByDrawMode ); - item.mRenderer->Render( context, textureCache, bufferIndex, *item.mNode, defaultShader, - item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mSize, !item.mIsOpaque ); - } - } - else - { - size_t count = renderList.Count(); - for ( size_t index = 0; index < count; ++index ) - { - const RenderItem& item = renderList.GetItem( index ); - DALI_PRINT_RENDER_ITEM( item ); - - // Set up the depth buffer based on per-renderer flags. - SetupDepthBuffer( item, context, isLayer3D ); - SetupPerRendererFlags( item, context, usedStencilBuffer, stencilManagedByDrawMode ); - - item.mRenderer->Render( context, textureCache, bufferIndex, *item.mNode, defaultShader, - item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mSize, !item.mIsOpaque ); - } + const RenderItem& item = renderList.GetItem( index ); + DALI_PRINT_RENDER_ITEM( item ); + + // Set up the depth buffer based on per-renderer flags. + // If the per renderer flags are set to "ON" or "OFF", they will always override any Layer depth mode or + // draw-mode state, such as Overlays. + // If the flags are set to "AUTO", the behaviour then depends on the type of renderer. Overlay Renderers will always + // disable depth testing and writing. Color Renderers will enable them if the Layer does. + SetupDepthBuffer( item, context, autoDepthTestMode ); + SetupPerRendererFlags( item, context, usedStencilBuffer, stencilManagedByDrawMode ); + + item.mRenderer->Render( context, textureCache, bufferIndex, *item.mNode, defaultShader, + item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mSize, !item.mIsOpaque ); } }