feat: Custom Depth Test Function for Materials

sources/engine/Stride.Rendering/Rendering/MaterialPass.cs

@@ -43,6 +43,11 @@ public MaterialPass(ParameterCollection parameters)
         /// </summary>
         public CullMode? CullMode;
 
+        /// <summary>
+        /// Overrides depth clip for this material.
+        /// </summary>
+        public CompareFunction? DepthFunction;
+
         /// <summary>
         /// Overrides the blend state for this material.
         /// </summary>

sources/engine/Stride.Rendering/Rendering/Materials/MaterialAttributes.cs

@@ -172,6 +172,15 @@ public MaterialAttributes()
         [DefaultValue(CullMode.Back)]
         public CullMode CullMode { get; set; }
 
+        /// <summary>
+        /// The test used to figure out whether the material should be drawn when beind other models
+        /// </summary>
+        /// <userdoc>The test used to figure out whether the material should be drawn when beind other models</userdoc>
+        [Display("Depth Function", "Misc")]
+        [DataMember(135)]
+        [DefaultValue(CompareFunction.Less)]
+        public CompareFunction DepthFunction { get; set; } = CompareFunction.Less;
+
         /// <summary>
         /// Gets or sets the clear coat shading features for the material.
         /// </summary>
@@ -198,8 +207,7 @@ public void Visit(MaterialGeneratorContext context)
             // TODO: Should we apply it to any Diffuse Model?
             var isEnergyConservative = (Specular as MaterialSpecularMapFeature)?.IsEnergyConservative ?? false;
 
-            var lambert = DiffuseModel as IEnergyConservativeDiffuseModelFeature;
-            if (lambert != null)
+            if (DiffuseModel is IEnergyConservativeDiffuseModelFeature lambert)
             {
                 lambert.IsEnergyConservative = isEnergyConservative;
             }
@@ -227,8 +235,8 @@ public void Visit(MaterialGeneratorContext context)
 
             // If hair shading is enabled, ignore the transparency feature to avoid errors during shader compilation.
             // Allowing the transparency feature while hair shading is on makes no sense anyway.
-            if (!(SpecularModel is MaterialSpecularHairModelFeature) &&
-                !(DiffuseModel is MaterialDiffuseHairModelFeature))
+            if (SpecularModel is not MaterialSpecularHairModelFeature &&
+                DiffuseModel is not MaterialDiffuseHairModelFeature)
             {
                 context.Visit(Transparency);
             }
@@ -246,6 +254,15 @@ public void Visit(MaterialGeneratorContext context)
                     context.MaterialPass.CullMode = CullMode;
                 }
             }
+
+            // Only set the DepthFunction when the pass is not overriden (Only based on assumptions from how CullMode operates, not exactly sure how/when this would be used) 
+            if (context.Step == MaterialGeneratorStep.GenerateShader && DepthFunction != CompareFunction.Less)
+            {
+                if (context.MaterialPass.DepthFunction == null)
+                {
+                    context.MaterialPass.DepthFunction = DepthFunction;
+                }
+            }
         }
     }
 }

sources/engine/Stride.Rendering/Rendering/Materials/MaterialRenderFeature.cs

@@ -66,6 +66,7 @@ internal class MaterialInfo : MaterialInfoBase
             public int PermutationCounter; // Dirty counter against material.Parameters.PermutationCounter
             public ParameterCollection MaterialParameters; // Protect against changes of Material.Parameters instance (happens with editor fast reload)
             public CullMode? CullMode;
+            public CompareFunction? DepthFunction;
 
             public ShaderSource VertexStageSurfaceShaders;
             public ShaderSource VertexStageStreamInitializer;
@@ -92,6 +93,7 @@ public MaterialInfo(MaterialPass materialPass)
             {
                 MaterialPass = materialPass;
                 CullMode = materialPass.CullMode;
+                DepthFunction = materialPass.DepthFunction;
             }
         }
 
@@ -182,6 +184,12 @@ public override void PrepareEffectPermutations(RenderDrawContext context)
                     resetPipelineState = true;
                 }
 
+                if (materialInfo != null && materialInfo.DepthFunction != material.DepthFunction)
+                {
+                    materialInfo.DepthFunction = material.DepthFunction;
+                    resetPipelineState = true;
+                }
+
                 for (int i = 0; i < effectSlotCount; ++i)
                 {
                     var staticEffectObjectNode = staticObjectNode * effectSlotCount + i;

sources/engine/Stride.Rendering/Rendering/MeshPipelineProcessor.cs

@@ -65,6 +65,9 @@ public override void Process(RenderNodeReference renderNodeReference, ref Render
 
             pipelineState.RasterizerState.CullMode = cullMode;
 
+            if (renderMesh.MaterialInfo.DepthFunction is {} newDepthFunction)
+                pipelineState.DepthStencilState.DepthBufferFunction = newDepthFunction;
+
             if (isMultisample)
             {
                 pipelineState.RasterizerState.MultisampleCount = output.MultisampleCount;