From: Andrew Poor Date: Fri, 2 Sep 2016 09:24:53 +0000 (+0100) Subject: Set up the depth buffer based on per-renderer flags. X-Git-Tag: dali_1.2.5~4 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=0a8193887ef54d7f22f30a0199eddcbe9e4f8e01;p=platform%2Fcore%2Fuifw%2Fdali-core.git Set up the depth buffer based on per-renderer flags. Related toolkit and demo changes: "Removed 3D layer dependency of Model3dView and Mesh Visual." Change-Id: Ib9b1c3110189950b0c1a9cea155eb3ca5c37bf4a --- 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 02353f3..3d5982c 100644 --- a/dali/internal/render/common/render-algorithms.cpp +++ b/dali/internal/render/common/render-algorithms.cpp @@ -85,9 +85,8 @@ inline void SetScissorTest( const RenderList& renderList, Context& context ) * @param[in] renderList The render list from which to get the render flags * @param[in] context The 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; @@ -110,20 +109,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. @@ -186,21 +183,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() ] ); @@ -231,64 +228,47 @@ 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 std::size_t count = renderList.Count(); + bool skip( false ); + for ( size_t index = 0; index < count; ++index ) { - size_t count = renderList.Count(); - bool skip( false ); - 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. + // 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 ); + + // Check if the node has a valid batch index value ( set previously by + // GeometryBatcher ). If so, then it queries the geometry object for this particular batch. + // If not, it still checks if the batch parent is set as it is possible, batching may + // fail ( for example if vertex format or buffers are not set ). In that case we need + // to skip rendering, otherwise unwanted GPU buffers will get uploaded. This is very rare case. + uint32_t batchIndex = item.mNode->mBatchIndex; + if( batchIndex != BATCH_NULL_HANDLE ) { - const RenderItem& item = renderList.GetItem( index ); - DALI_PRINT_RENDER_ITEM( item ); - - SetupPerRendererFlags( item, context, usedStencilBuffer, stencilManagedByDrawMode ); - - // Check if the node has a valid batch index value ( set previously by - // GeometryBatcher ). If so, then it queries the geometry object for this particular batch. - // If not, it still checks if the batch parent is set as it is possible, batching may - // fail ( for example if vertex format or buffers are not set ). In that case we need - // to skip rendering, otherwise unwanted GPU buffers will get uploaded. This is very rare case. - uint32_t batchIndex = item.mNode->mBatchIndex; - if( batchIndex != BATCH_NULL_HANDLE ) - { - item.mBatchRenderGeometry = geometryBatcher->GetGeometry( batchIndex ); - } - else - { - skip = item.mNode->GetBatchParent(); - item.mBatchRenderGeometry = NULL; - } - if( !skip ) - { - item.mRenderer->Render( context, textureCache, bufferIndex, *item.mNode, defaultShader, - item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mSize, item.mBatchRenderGeometry, !item.mIsOpaque ); - } + item.mBatchRenderGeometry = geometryBatcher->GetGeometry( batchIndex ); } - } - else - { - size_t count = renderList.Count(); - for ( size_t index = 0; index < count; ++index ) + else + { + skip = item.mNode->GetBatchParent(); + item.mBatchRenderGeometry = NULL; + } + if( DALI_LIKELY( !skip ) ) { - 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.mBatchRenderGeometry, !item.mIsOpaque ); + item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mSize, item.mBatchRenderGeometry, !item.mIsOpaque ); } } }