Add optional depth prepass and explicit SRP splat rendering

Editor/GsplatSettingsProvider.cs

@@ -26,6 +26,7 @@ public override void OnGUI(string searchContext)
             EditorGUILayout.PropertyField(m_gsplatSettings.FindProperty(nameof(GsplatSettings.ComputeShader)));
             EditorGUILayout.PropertyField(m_gsplatSettings.FindProperty(nameof(GsplatSettings.SplatInstanceSize)));
             EditorGUILayout.PropertyField(m_gsplatSettings.FindProperty(nameof(GsplatSettings.UploadBatchSize)));
+            EditorGUILayout.PropertyField(m_gsplatSettings.FindProperty(nameof(GsplatSettings.DepthPrepassAlphaCutoff)));
             EditorGUILayout.PropertyField(m_gsplatSettings.FindProperty(nameof(GsplatSettings.MaxRenderOrder)));
             EditorGUILayout.PropertyField(
                 m_gsplatSettings.FindProperty(nameof(GsplatSettings.CameraTranslationRefreshTreshold)));
@@ -73,4 +74,4 @@ public static SettingsProvider CreateGsplatSettingsProvider()
             return provider;
         }
     }
-}
+}

Runtime/GsplatGlobalMaterial.cs

@@ -9,10 +9,12 @@ namespace Gsplat
     public class GsplatGlobalMaterial : ScriptableObject
     {
         public Material DefaultMaterial;
+        public Material DefaultDepthMaterial;
         public ComputeShader MergeShader;
         public ComputeShader CopyBufferShader;
 
         Material[] m_materials; // indexed by SH band (0–4)
+        Material[] m_depthMaterials; // indexed by SH band (0–4)
 
         /// <summary>
         /// Returns five Material instances — one per SH band level — with the appropriate
@@ -41,8 +43,35 @@ public Material[] Materials
             }
         }
 
-        public void Reset() => m_materials = null;
+        public Material[] DepthMaterials
+        {
+            get
+            {
+                if (m_depthMaterials != null && m_depthMaterials[0] != null)
+                    return m_depthMaterials;
+
+                m_depthMaterials = new Material[5];
+                for (int i = 0; i < 5; i++)
+                {
+                    m_depthMaterials[i] = new Material(DefaultDepthMaterial);
+                    m_depthMaterials[i].DisableKeyword("SH_BANDS_0");
+                    m_depthMaterials[i].DisableKeyword("SH_BANDS_1");
+                    m_depthMaterials[i].DisableKeyword("SH_BANDS_2");
+                    m_depthMaterials[i].DisableKeyword("SH_BANDS_3");
+                    m_depthMaterials[i].DisableKeyword("SH_BANDS_4");
+                    m_depthMaterials[i].EnableKeyword($"SH_BANDS_{i}");
+                }
+
+                return m_depthMaterials;
+            }
+        }
+
+        public void Reset()
+        {
+            m_materials = null;
+            m_depthMaterials = null;
+        }
 
-        public bool Valid() => MergeShader && CopyBufferShader && DefaultMaterial;
+        public bool Valid() => MergeShader && CopyBufferShader && DefaultMaterial && DefaultDepthMaterial;
     }
-}
+}

Runtime/GsplatGlobalRenderer.cs

@@ -5,6 +5,9 @@
 using System.Linq;
 using UnityEngine;
 using UnityEngine.Rendering;
+#if UNITY_6000_0_OR_NEWER
+using UnityEngine.Rendering.RenderGraphModule;
+#endif
 
 namespace Gsplat
 {
@@ -57,6 +60,7 @@ struct RendererParams
         Matrix4x4[] m_rendererTransformsCache;
         RendererParams[] m_rendererParamsCache;
         MaterialPropertyBlock m_globalPropertyBlock;
+        int m_renderLayer;
 
         public bool Valid => m_globalMaterial
                              && m_globalMaterial.Valid()
@@ -111,6 +115,7 @@ struct RendererParams
         static readonly int k_rendererParamsProp = Shader.PropertyToID("_RendererParams");
         static readonly int k_totalSplatCount = Shader.PropertyToID("_TotalSplatCount");
         static readonly int k_splatInstanceSize = Shader.PropertyToID("_SplatInstanceSize");
+        static readonly int k_depthPrepassAlphaCutoff = Shader.PropertyToID("_DepthPrepassAlphaCutoff");
 
         public void InitGlobal(GsplatGlobalMaterial globalMaterial)
         {
@@ -156,9 +161,11 @@ public void Update(List<IGsplat> activeGsplats)
         {
             EnsureGlobalBuffers(activeGsplats);
             if (m_totalSplatCount == 0) return;
+            m_renderLayer = activeGsplats[0].transform.gameObject.layer;
             UpdateRendererTransforms(activeGsplats);
             UpdateRendererParams(activeGsplats);
-            Render();
+            if (!GraphicsSettings.currentRenderPipeline)
+                Render();
         }
 
         public void DispatchMerge(CommandBuffer cmd, List<IGsplat> activeGsplats)
@@ -479,6 +486,7 @@ void Render()
             m_globalPropertyBlock.SetBuffer(k_rendererParamsProp, m_rendererParamsBuffer);
             m_globalPropertyBlock.SetInteger(k_totalSplatCount, (int)m_totalRemainingCount);
             m_globalPropertyBlock.SetInteger(k_splatInstanceSize, (int)GsplatSettings.Instance.SplatInstanceSize);
+            m_globalPropertyBlock.SetFloat(k_depthPrepassAlphaCutoff, GsplatSettings.Instance.DepthPrepassAlphaCutoff);
 
             if (m_globalSHBands >= 1)
                 m_globalPropertyBlock.SetBuffer(k_globalSH1Buffer, m_globalSH1Buffer);
@@ -492,13 +500,89 @@ void Render()
             var rp = new RenderParams(m_globalMaterial.Materials[m_globalSHBands])
             {
                 worldBounds = new Bounds(Vector3.zero, Vector3.one * 1e6f),
-                matProps = m_globalPropertyBlock
+                matProps = m_globalPropertyBlock,
+                layer = m_renderLayer
             };
 
             int instances = Mathf.CeilToInt(m_totalRemainingCount / (float)GsplatSettings.Instance.SplatInstanceSize);
             Graphics.RenderMeshPrimitives(rp, GsplatSettings.Instance.Mesh, 0, instances);
         }
 
+        public void RenderColor(CommandBuffer cmd)
+        {
+            if (m_globalBuffersDirty || m_globalOrderBuffer == null || m_totalRemainingCount == 0) return;
+
+            BindGlobalDrawProperties();
+
+            int instances = Mathf.CeilToInt(m_totalRemainingCount / (float)GsplatSettings.Instance.SplatInstanceSize);
+            cmd.DrawMeshInstancedProcedural(GsplatSettings.Instance.Mesh, 0, m_globalMaterial.Materials[m_globalSHBands],
+                0, instances, m_globalPropertyBlock);
+        }
+
+        public void RenderDepthPrepass(CommandBuffer cmd)
+        {
+            if (GsplatSettings.Instance.DepthPrepassAlphaCutoff > 1.0f)
+                return;
+
+            if (m_globalBuffersDirty || m_globalOrderBuffer == null || m_totalRemainingCount == 0) return;
+
+            BindGlobalDrawProperties();
+
+            int instances = Mathf.CeilToInt(m_totalRemainingCount / (float)GsplatSettings.Instance.SplatInstanceSize);
+            cmd.DrawMeshInstancedProcedural(GsplatSettings.Instance.Mesh, 0,
+                m_globalMaterial.DepthMaterials[m_globalSHBands], 0, instances, m_globalPropertyBlock);
+        }
+
+#if UNITY_6000_0_OR_NEWER
+        public void RenderColor(RasterCommandBuffer cmd)
+        {
+            if (m_globalBuffersDirty || m_globalOrderBuffer == null || m_totalRemainingCount == 0) return;
+
+            BindGlobalDrawProperties();
+
+            int instances = Mathf.CeilToInt(m_totalRemainingCount / (float)GsplatSettings.Instance.SplatInstanceSize);
+            cmd.DrawMeshInstancedProcedural(GsplatSettings.Instance.Mesh, 0, m_globalMaterial.Materials[m_globalSHBands],
+                0, instances, m_globalPropertyBlock);
+        }
+
+        public void RenderDepthPrepass(RasterCommandBuffer cmd)
+        {
+            if (GsplatSettings.Instance.DepthPrepassAlphaCutoff > 1.0f)
+                return;
+
+            if (m_globalBuffersDirty || m_globalOrderBuffer == null || m_totalRemainingCount == 0) return;
+
+            BindGlobalDrawProperties();
+
+            int instances = Mathf.CeilToInt(m_totalRemainingCount / (float)GsplatSettings.Instance.SplatInstanceSize);
+            cmd.DrawMeshInstancedProcedural(GsplatSettings.Instance.Mesh, 0,
+                m_globalMaterial.DepthMaterials[m_globalSHBands], 0, instances, m_globalPropertyBlock);
+        }
+#endif
+
+        void BindGlobalDrawProperties()
+        {
+            m_globalPropertyBlock ??= new MaterialPropertyBlock();
+            m_globalPropertyBlock.Clear();
+            m_globalPropertyBlock.SetBuffer(k_globalOrderBuffer, m_globalOrderBuffer);
+            m_globalPropertyBlock.SetBuffer(k_globalPackedBuffer, m_globalPackedBuffer);
+            m_globalPropertyBlock.SetBuffer(k_rendererOffsetsProp, m_rendererOffsetsBuffer);
+            m_globalPropertyBlock.SetBuffer(k_rendererTransformsProp, m_rendererTransformsBuffer);
+            m_globalPropertyBlock.SetBuffer(k_rendererParamsProp, m_rendererParamsBuffer);
+            m_globalPropertyBlock.SetInteger(k_totalSplatCount, (int)m_totalRemainingCount);
+            m_globalPropertyBlock.SetInteger(k_splatInstanceSize, (int)GsplatSettings.Instance.SplatInstanceSize);
+            m_globalPropertyBlock.SetFloat(k_depthPrepassAlphaCutoff, GsplatSettings.Instance.DepthPrepassAlphaCutoff);
+
+            if (m_globalSHBands >= 1)
+                m_globalPropertyBlock.SetBuffer(k_globalSH1Buffer, m_globalSH1Buffer);
+            if (m_globalSHBands >= 2)
+                m_globalPropertyBlock.SetBuffer(k_globalSH2Buffer, m_globalSH2Buffer);
+            if (m_globalSHBands >= 3)
+                m_globalPropertyBlock.SetBuffer(k_globalSH3Buffer, m_globalSH3Buffer);
+            if (m_globalSHBands >= 4)
+                m_globalPropertyBlock.SetBuffer(k_globalSH4Buffer, m_globalSH4Buffer);
+        }
+
 
         // -----------------------------------------------------------------------
         // Cleanup
@@ -537,4 +621,4 @@ public void DisposeGlobalBuffers()
             m_builtSplatCounts = null;
         }
     }
-}
+}

Runtime/GsplatMaterial.cs

@@ -9,11 +9,14 @@ namespace Gsplat
     public class GsplatMaterial : ScriptableObject
     {
         public Material DefaultMaterial;
+        public Material DefaultDepthMaterial;
         private Material[][] m_material;
+        private Material[][] m_depthMaterial;
 
         public void Reset()
         {
             m_material = null;
+            m_depthMaterial = null;
         }
 
         public Material[][] Materials // materials generated with SH bands from 0 to 4 and custom renderOrders
@@ -43,6 +46,33 @@ public Material[][] Materials // materials generated with SH bands from 0 to 4 a
             }
         }
 
+        public Material[][] DepthMaterials
+        {
+            get
+            {
+                if (m_depthMaterial != null && m_depthMaterial[0][0] != null)
+                    return m_depthMaterial;
+
+                m_depthMaterial = new Material[5][];
+                for (var i = 0; i < 5; ++i)
+                {
+                    m_depthMaterial[i] = new Material[GsplatSettings.Instance.MaxRenderOrder];
+                    for (var j = 0; j < GsplatSettings.Instance.MaxRenderOrder; ++j)
+                    {
+                        m_depthMaterial[i][j] = new Material(DefaultDepthMaterial);
+                        m_depthMaterial[i][j].DisableKeyword($"SH_BANDS_0");
+                        m_depthMaterial[i][j].DisableKeyword($"SH_BANDS_1");
+                        m_depthMaterial[i][j].DisableKeyword($"SH_BANDS_2");
+                        m_depthMaterial[i][j].DisableKeyword($"SH_BANDS_3");
+                        m_depthMaterial[i][j].DisableKeyword($"SH_BANDS_4");
+                        m_depthMaterial[i][j].EnableKeyword($"SH_BANDS_{i}");
+                        m_depthMaterial[i][j].renderQueue = 3000 + j;
+                    }
+                }
+                return m_depthMaterial;
+            }
+        }
+
         public ComputeShader CalcDepthShader;
         public ComputeShader InitOrderShader;
     }

Runtime/GsplatRenderer.cs

@@ -5,6 +5,9 @@
 using UnityEditor;
 using UnityEngine;
 using UnityEngine.Rendering;
+#if UNITY_6000_0_OR_NEWER
+using UnityEngine.Rendering.RenderGraphModule;
+#endif
 
 namespace Gsplat
 {
@@ -87,6 +90,30 @@ public GsplatCutout[] Cutouts
 
         public void ComputeDepth(CommandBuffer cmd, Matrix4x4 matrixMv) => m_renderer.ComputeDepth(cmd, matrixMv);
 
+        public void RenderColor(CommandBuffer cmd, Camera camera)
+        {
+            m_renderer.RenderColor(cmd, transform, GammaToLinear, SHDegree, Brightness,
+                1.0f - SplatDownscaleFactor, RenderOrder);
+        }
+
+        public void RenderDepthPrepass(CommandBuffer cmd, Camera camera)
+        {
+            m_renderer.RenderDepthPrepass(cmd, transform, 1.0f - SplatDownscaleFactor, RenderOrder);
+        }
+
+#if UNITY_6000_0_OR_NEWER
+        public void RenderColor(RasterCommandBuffer cmd, Camera camera)
+        {
+            m_renderer.RenderColor(cmd, transform, GammaToLinear, SHDegree, Brightness,
+                1.0f - SplatDownscaleFactor, RenderOrder);
+        }
+
+        public void RenderDepthPrepass(RasterCommandBuffer cmd, Camera camera)
+        {
+            m_renderer.RenderDepthPrepass(cmd, transform, 1.0f - SplatDownscaleFactor, RenderOrder);
+        }
+#endif
+
         void OnEnable()
         {
             GsplatSorter.Instance.RegisterGsplat(this);
@@ -163,12 +190,17 @@ public void Update()
             {
                 m_renderer.EvaluateRefreshRequired(SortMode, SortRefreshRate - 1, CutoutsRefreshRate - 1);
                 m_renderer.DispatchInitOrder(Cutouts, transform.localToWorldMatrix, CutoutsUpdateBounds);
-                // When the global sorter has merged all renderers into a single draw call,
-                // skip the per-renderer draw — GsplatSorter.DrawAll handles rendering.
-                if (!GsplatSorter.Instance.GlobalRenderEnabled)
-                    m_renderer.Render(transform, gameObject.layer, GammaToLinear, SHDegree, Brightness,
-                        1.0f - SplatDownscaleFactor, RenderOrder);
             }
         }
+
+        // Called by GsplatSorter after it has selected one render path for the frame.
+        internal void Render()
+        {
+            if (!Valid || !GsplatSettings.Instance.Valid || !GsplatSorter.Instance.Valid)
+                return;
+
+            m_renderer.Render(transform, gameObject.layer, GammaToLinear, SHDegree, Brightness,
+                1.0f - SplatDownscaleFactor, RenderOrder);
+        }
     }
-}
+}