[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 (file)
--- 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 (file)
--- 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 );
   }
 }