[Rendering] Improve instancing buffer usage;

Author: LittleCodingFox

Engine/Staple.Core/Rendering/Mesh/MeshRenderSystem.cs

@@ -24,12 +24,14 @@ private struct InstanceInfo
     private class InstanceData
     {
         public ExpandableContainer<InstanceInfo> instanceInfos = new();
-        public Matrix4x4[] transformMatrices = [];
     }
 
     private readonly Dictionary<int, InstanceData> instanceCache = [];
 
-    private readonly Dictionary<int, VertexBuffer> instanceBuffers = [];
+    private VertexBuffer instanceBuffer;
+    private int instanceOffset;
+    private int instanceCount;
+    private Matrix4x4[] transformMatrices = [];
 
     private readonly Lazy<VertexLayout> instanceLayout = new(() =>
     {
@@ -59,27 +61,6 @@ public void Prepare()
     }
     #endregion
 
-    private VertexBuffer GetInstanceBuffer(int count)
-    {
-        if (instanceBuffers.TryGetValue(count, out var buffer) && buffer.Disposed == false)
-        {
-            return buffer;
-        }
-
-        buffer = VertexBuffer.Create(new Matrix4x4[count], instanceLayout.Value, RenderBufferFlags.GraphicsRead);
-
-        if((buffer?.Disposed ?? true))
-        {
-            instanceBuffers.Remove(count);
-
-            return null;
-        }
-
-        instanceBuffers.AddOrSetKey(count, buffer);
-
-        return buffer;
-    }
-
     /// <summary>
     /// Renders a mesh
     /// </summary>
@@ -258,13 +239,7 @@ void Add(Material material, int submeshIndex)
             }
         }
 
-        foreach (var p in instanceCache)
-        {
-            if(p.Value.instanceInfos.Length != p.Value.transformMatrices.Length)
-            {
-                Array.Resize(ref p.Value.transformMatrices, p.Value.instanceInfos.Length);
-            }
-        }
+        instanceOffset = 0;
     }
 
     public void Submit()
@@ -275,6 +250,50 @@ public void Submit()
             enableDepth = true,
         };
 
+        if(instanceBuffer?.Disposed ?? true)
+        {
+            instanceBuffer = VertexBuffer.Create(new Matrix4x4[1], instanceLayout.Value, RenderBufferFlags.GraphicsRead);
+        }
+
+        instanceCount = instanceOffset = 0;
+
+        foreach (var (_, contents) in instanceCache)
+        {
+            if (contents.instanceInfos.Length <= 1)
+            {
+                continue;
+            }
+
+            instanceCount += contents.instanceInfos.Length;
+        }
+
+        if (instanceCount > 0)
+        {
+            if(instanceCount > transformMatrices.Length)
+            {
+                Array.Resize(ref transformMatrices, instanceCount);
+            }
+
+            foreach (var (_, contents) in instanceCache)
+            {
+                if (contents.instanceInfos.Length <= 1)
+                {
+                    continue;
+                }
+
+                for(var i = 0; i < contents.instanceInfos.Length; i++)
+                {
+                    transformMatrices[instanceOffset++] = contents.instanceInfos.Contents[i].transform.Matrix;
+                }
+            }
+
+            instanceOffset = 0;
+
+            var span = new Span<Matrix4x4>(transformMatrices, 0, instanceCount);
+
+            instanceBuffer.Update(span);
+        }
+
         foreach (var (_, contents) in instanceCache)
         {
             if (contents.instanceInfos.Length == 0)
@@ -284,6 +303,9 @@ public void Submit()
 
             renderState.ClearStorageBuffers();
 
+            renderState.instanceCount = 1;
+            renderState.instanceOffset = 0;
+
             var renderData = contents.instanceInfos.Contents[0];
 
             var material = renderData.material;
@@ -324,25 +346,14 @@ public void Submit()
 
                 contents.instanceInfos.Contents[0].mesh.SetActive(ref renderState, contents.instanceInfos.Contents[0].submeshIndex);
 
-                for (var i = 0; i < contents.instanceInfos.Length; i++)
-                {
-                    contents.transformMatrices[i] = contents.instanceInfos.Contents[i].transform.Matrix;
-                }
-
-                var buffer = GetInstanceBuffer(contents.transformMatrices.Length);
-
-                if(buffer == null)
+                if (instanceBuffer != null)
                 {
-                    continue;
-                }
-
-                buffer.Update(contents.transformMatrices);
+                    renderState.instanceOffset = instanceOffset;
+                    renderState.instanceCount = contents.instanceInfos.Length;
 
-                if (buffer != null)
-                {
-                    renderState.instanceCount = contents.transformMatrices.Length;
+                    instanceOffset += renderState.instanceCount;
 
-                    renderState.ApplyStorageBufferIfNeeded("StapleInstancingTransforms", buffer);
+                    renderState.ApplyStorageBufferIfNeeded("StapleInstancingTransforms", instanceBuffer);
 
                     RenderSystem.Submit(renderState, renderData.mesh.SubmeshTriangleCount(contents.instanceInfos.Contents[0].submeshIndex),
                         contents.instanceInfos.Length);

Engine/Staple.Core/Rendering/RenderSystem/Backend/Impls/SDLGPU/SDLGPURendererBackend.cs

@@ -30,6 +30,7 @@ internal struct StapleRenderData
         public Matrix4x4 world;
         public Matrix4x4 view;
         public Matrix4x4 projection;
+        public int instanceOffset;
     }
 
     [StructLayout(LayoutKind.Sequential, Pack = 0)]
@@ -1471,6 +1472,7 @@ state.indexBuffer is not SDLGPUIndexBuffer index ||
                 unsafe
                 {
                     viewData.renderData.world = state.world;
+                    viewData.renderData.instanceOffset = state.instanceOffset > 0 ? state.instanceOffset : 0;
 
                     fixed (void* ptr = &viewData.renderData)
                     {
@@ -1636,6 +1638,7 @@ public void RenderTransient<T>(Span<T> vertices, VertexLayout layout, Span<ushor
                 unsafe
                 {
                     viewData.renderData.world = state.world;
+                    viewData.renderData.instanceOffset = 0;
 
                     fixed (void* ptr = &viewData.renderData)
                     {
@@ -1802,6 +1805,7 @@ public void RenderTransient<T>(Span<T> vertices, VertexLayout layout, Span<uint>
                 unsafe
                 {
                     viewData.renderData.world = state.world;
+                    viewData.renderData.instanceOffset = 0;
 
                     fixed (void* ptr = &viewData.renderData)
                     {

Engine/Staple.Core/Rendering/RenderSystem/Backend/RenderState.cs

@@ -29,6 +29,7 @@ internal struct RenderState
     public Texture[] vertexTextures;
     public Texture[] fragmentTextures;
     public Matrix4x4 world;
+    public int instanceOffset;
     public int instanceCount;
 
     public readonly RenderState Clone()
@@ -56,6 +57,7 @@ public readonly RenderState Clone()
             vertexTextures = (Texture[])vertexTextures?.Clone(),
             wireframe = wireframe,
             world = world,
+            instanceOffset = instanceOffset,
             instanceCount = instanceCount,
         };
     }

Tools/ShaderIncludes/Staple.slang

@@ -10,6 +10,7 @@ public cbuffer StapleRenderData
     public float4x4 world;
     public float4x4 view;
     public float4x4 projection;
+    public int instanceOffset;
 };
 
 [[vk::binding(1, StapleUniformBufferSet)]]
@@ -49,6 +50,6 @@ public float4x4 StapleGetSkinningMatrix(float4x4 world, float4 indices, float4 w
 #ifdef INSTANCING
 public float4x4 StapleGetInstancedTransform(uint index)
 {
-    return StapleInstancingTransforms[index];
+    return StapleInstancingTransforms[index + instanceOffset];
 }
 #endif