Use multi draw indirect in renderer

Author: Moneyl

Nanoforge/Render/Misc/VkDrawIndexedIndirectCommand.cs

@@ -0,0 +1,30 @@
+using System.Runtime.InteropServices;
+
+namespace Nanoforge.Render.Misc;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct VkDrawIndexedIndirectCommand
+{
+    public uint IndexCount;
+    public uint InstanceCount;
+    public uint FirstIndex;
+    public int VertexOffset;
+    public uint FirstInstance;
+
+    public VkDrawIndexedIndirectCommand(uint indexCount, uint instanceCount, uint firstIndex, int vertexOffset, uint firstInstance)
+    {
+        IndexCount = indexCount;
+        InstanceCount = instanceCount;
+        FirstIndex = firstIndex;
+        VertexOffset = vertexOffset;
+        FirstInstance = firstInstance;
+    }
+}
+
+// struct VkDrawIndexedIndirectCommand {
+//     uint32_t    indexCount;
+//     uint32_t    instanceCount;
+//     uint32_t    firstIndex;
+//     int32_t     vertexOffset;
+//     uint32_t    firstInstance;
+// };

Nanoforge/Render/RenderContext.cs

@@ -202,6 +202,7 @@ public RenderContext()
         PhysicalDeviceFeatures deviceFeatures = new()
         {
             SamplerAnisotropy = true,
+            MultiDrawIndirect = true,
         };
 
         DeviceCreateInfo deviceCreateInfo = new()

Nanoforge/Render/Renderer.cs

@@ -46,6 +46,10 @@ public unsafe class Renderer
     private VkBuffer[] _materialInfoGPUBuffer; 
     private GpuFrameDataWriter _gpuFrameDataWriter = new(MaxObjectsPerScene, MaxMaterialInstances);
 
+    public const int MaxCommands = 150_000;
+    private VkDrawIndexedIndirectCommand[] _cpuDrawCommandsBuffer;
+    private VkBuffer[] _drawCommandBuffer;
+    
     public static readonly Format RenderTextureImageFormat = Format.B8G8R8A8Srgb;
     public static Format DepthTextureFormat { get; private set; }
 
@@ -109,6 +113,10 @@ public unsafe Renderer(uint viewportWidth, uint viewportHeight)
         {
             throw new Exception("SizeOf<Pixlit4UvNmapVertex>() != 36. Required for shaders to work.");
         }
+        if (Unsafe.SizeOf<VkDrawIndexedIndirectCommand>() != 20)
+        {
+            throw new Exception("SizeOf<VkDrawIndexedIndirectCommand>() != 20. Required for shaders to work.");
+        }
 
         Context = new RenderContext();
         //Load global textures like 1x1 white texture & setup default texture sampler
@@ -118,6 +126,7 @@ public unsafe Renderer(uint viewportWidth, uint viewportHeight)
         CreateUniformBuffers();
         CreatePerObjectConstantBuffers();
         CreateMaterialInfoBuffers();
+        CreateDrawCommandBuffers();
         MaterialHelper.Init(Context, _renderPass, _perFrameUniformBuffers!, _perObjectConstantsGPUBuffer, _materialInfoGPUBuffer);
         CreateSyncObjects();
     }
@@ -331,6 +340,22 @@ private void CreateMaterialInfoBuffers()
                 MemoryPropertyFlags.HostVisibleBit | MemoryPropertyFlags.HostCoherentBit);
         }
     }
+    
+    [MemberNotNull(nameof(_drawCommandBuffer))]
+    [MemberNotNull(nameof(_cpuDrawCommandsBuffer))]
+    private void CreateDrawCommandBuffers()
+    {
+        _cpuDrawCommandsBuffer = new VkDrawIndexedIndirectCommand[MaxCommands];
+        
+        int bufferSize = MaxCommands * Unsafe.SizeOf<VkDrawIndexedIndirectCommand>();
+        _drawCommandBuffer = new VkBuffer[MaxFramesInFlight];
+        for (int i = 0; i < MaxFramesInFlight; i++)
+        {
+            _drawCommandBuffer[i] = new VkBuffer(Context, (ulong)bufferSize, 
+                BufferUsageFlags.TransferDstBit | BufferUsageFlags.StorageBufferBit | BufferUsageFlags.IndirectBufferBit,
+                MemoryPropertyFlags.HostVisibleBit | MemoryPropertyFlags.HostCoherentBit);
+        }
+    }
 
     private void UpdatePerObjectConstantBuffers(uint currentImage)
     {
@@ -442,15 +467,33 @@ private void RecordCommands(Scene scene, uint index)
 
         MaterialPipeline unifiedPipeline = MaterialHelper.GetMaterialPipeline("UnifiedMaterial") ?? throw new NullReferenceException("Failed to get unified material pipeline!");
         unifiedPipeline.Bind(commandBuffer, (int)index);
+        int totalNumCommands = 0;
         foreach (IGrouping<Mesh, RenderCommand> meshGrouping in _commands.GroupBy(command => command.Mesh))
         {
             Mesh mesh = meshGrouping.Key;
             mesh.Bind(Context, commandBuffer);
 
+            int batchFirstCommand = totalNumCommands;
+            int batchNumCommands = 0;
             foreach (RenderCommand command in meshGrouping)
             {
-                Context.Vk.CmdDrawIndexed(commandBuffer, command.IndexCount, 1, command.StartIndex, 0, command.ObjectIndex);
+                if (totalNumCommands >= MaxCommands)
+                    throw new Exception($"Exceeded max draw command count of {MaxCommands}. Please increase Renderer.MaxCommands and recompile Nanoforge to fix this.");
+                
+                _cpuDrawCommandsBuffer[totalNumCommands++] = new VkDrawIndexedIndirectCommand(command.IndexCount, 1, command.StartIndex, 0, command.ObjectIndex);
+                batchNumCommands++;
             }
+
+            ulong batchOffset = (ulong)batchFirstCommand * (ulong)Unsafe.SizeOf<VkDrawIndexedIndirectCommand>();
+            fixed (VkDrawIndexedIndirectCommand* commandsPtr = _cpuDrawCommandsBuffer)
+            {
+                var commandsSpan = new Span<VkDrawIndexedIndirectCommand>(commandsPtr + batchFirstCommand, batchNumCommands);
+                _drawCommandBuffer[index].SetData(commandsSpan, batchOffset);
+            }
+
+            uint drawCount = (uint)batchNumCommands;
+            uint drawCommandStride = (uint)Unsafe.SizeOf<VkDrawIndexedIndirectCommand>();
+            Context.Vk.CmdDrawIndexedIndirect(commandBuffer, _drawCommandBuffer[index].VkHandle, batchOffset, drawCount, drawCommandStride);
         }
 
         scene.PrimitiveRenderer.RenderPrimitives(Context, commandBuffer, index);

Nanoforge/Render/Resources/VkBuffer.cs

@@ -64,25 +64,25 @@ private void Init()
         Vk.BindBufferMemory(Device, VkHandle, Memory, 0);
     }
 
-    public void SetData<T>(ref T data) where T : unmanaged
+    public void SetData<T>(ref T data, ulong offset = 0) where T : unmanaged
     {
         fixed (void* ptr = &data)
         {
             int sizeInBytes = Unsafe.SizeOf<T>();
-            SetData(new Span<byte>(ptr, sizeInBytes));
+            SetData(new Span<byte>(ptr, sizeInBytes), offset);
         }
     }
 
-    public void SetData<T>(Span<T> data) where T : unmanaged
+    public void SetData<T>(Span<T> data, ulong offset = 0) where T : unmanaged
     {
         fixed (void* ptr = data)
         {
             int sizeInBytes = Unsafe.SizeOf<T>() * data.Length;
-            SetData(new Span<byte>(ptr, sizeInBytes));
+            SetData(new Span<byte>(ptr, sizeInBytes), offset);
         }
     }
 
-    public void SetData(Span<byte> data)
+    public void SetData(Span<byte> data, ulong offset = 0)
     {
         if ((ulong)data.Length > Size)
         {
@@ -99,7 +99,9 @@ public void SetData(Span<byte> data)
 
         void* ptr = null;
         MapMemory(ref ptr);
-        data.CopyTo(new Span<byte>(ptr, data.Length));
+        byte* offsetPtr = (byte*)ptr;
+        offsetPtr += offset;
+        data.CopyTo(new Span<byte>(offsetPtr, data.Length));
         UnmapMemory();
     }