[Rendering] Fixes to Entity Transform Buffer;

Author: LittleCodingFox

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

@@ -1,5 +1,7 @@
 using SDL3;
 using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
 
 namespace Staple.Internal;
 
@@ -245,6 +247,156 @@ public void DestroyIndexBuffer(ResourceHandle<IndexBuffer> buffer)
         AddCommand(new SDLGPUDestroyIndexBufferCommand(buffer));
     }
 
+    private void UpdateEntityTransformBuffer()
+    {
+        var elementCount = RenderSystem.Instance.entityTransforms.Length;
+
+        var targetLength = elementCount * Marshal.SizeOf<Matrix4x4>();
+
+        if (entityTransformsBuffer != nint.Zero &&
+            entityTransformsBufferLength >= targetLength &&
+            RenderSystem.Instance.changedEntityTransformRanges.Count == 0)
+        {
+            return;
+        }
+
+        if (entityTransformsBuffer == nint.Zero || entityTransformsBufferLength != targetLength)
+        {
+            entityTransformsBufferLength = targetLength;
+
+            if (entityTransformsBuffer != nint.Zero)
+            {
+                SDL.ReleaseGPUBuffer(device, entityTransformsBuffer);
+
+                entityTransformsBuffer = nint.Zero;
+            }
+
+            var createInfo = new SDL.GPUBufferCreateInfo()
+            {
+                Size = (uint)targetLength,
+                Usage = SDL.GPUBufferUsageFlags.Vertex | SDL.GPUBufferUsageFlags.GraphicsStorageRead,
+            };
+
+            entityTransformsBuffer = SDL.CreateGPUBuffer(device, in createInfo);
+
+            if (entityTransformsBuffer == nint.Zero)
+            {
+                return;
+            }
+
+            var transferBuffer = GetTransferBuffer(false, targetLength);
+
+            if (transferBuffer == nint.Zero)
+            {
+                SDL.ReleaseGPUBuffer(device, entityTransformsBuffer);
+
+                entityTransformsBuffer = nint.Zero;
+
+                return;
+            }
+
+            if (renderPass != nint.Zero)
+            {
+                FinishPasses();
+            }
+
+            if (copyPass == nint.Zero)
+            {
+                copyPass = SDL.BeginGPUCopyPass(commandBuffer);
+            }
+
+            if (copyPass == nint.Zero)
+            {
+                return;
+            }
+
+            var mapData = SDL.MapGPUTransferBuffer(device, transferBuffer, true);
+
+            unsafe
+            {
+                var from = RenderSystem.Instance.entityTransforms.AsSpan();
+                var to = new Span<Matrix4x4>((void*)mapData, elementCount);
+
+                from.CopyTo(to);
+            }
+
+            SDL.UnmapGPUTransferBuffer(device, transferBuffer);
+
+            var location = new SDL.GPUTransferBufferLocation()
+            {
+                TransferBuffer = transferBuffer,
+                Offset = 0,
+            };
+
+            var region = new SDL.GPUBufferRegion()
+            {
+                Buffer = entityTransformsBuffer,
+                Size = (uint)targetLength,
+            };
+
+            SDL.UploadToGPUBuffer(copyPass, in location, in region, false);
+        }
+        else
+        {
+            if (renderPass != nint.Zero)
+            {
+                FinishPasses();
+            }
+
+            if (copyPass == nint.Zero)
+            {
+                copyPass = SDL.BeginGPUCopyPass(commandBuffer);
+            }
+
+            if (copyPass == nint.Zero)
+            {
+                return;
+            }
+
+            foreach (var (start, length) in RenderSystem.Instance.changedEntityTransformRanges)
+            {
+                targetLength = length * Marshal.SizeOf<Matrix4x4>();
+                
+                var transferBuffer = GetTransferBuffer(false, targetLength);
+
+                if (transferBuffer == nint.Zero)
+                {
+                    SDL.ReleaseGPUBuffer(device, entityTransformsBuffer);
+
+                    entityTransformsBuffer = nint.Zero;
+
+                    return;
+                }
+
+                var mapData = SDL.MapGPUTransferBuffer(device, transferBuffer, true);
+
+                unsafe
+                {
+                    var from = RenderSystem.Instance.entityTransforms.AsSpan().Slice(start, length);
+                    var to = new Span<Matrix4x4>((void*)mapData, length);
+
+                    from.CopyTo(to);
+                }
+
+                SDL.UnmapGPUTransferBuffer(device, transferBuffer);
+
+                var location = new SDL.GPUTransferBufferLocation()
+                {
+                    TransferBuffer = transferBuffer,
+                    Offset = (uint)(start * Marshal.SizeOf<Matrix4x4>()),
+                };
+
+                var region = new SDL.GPUBufferRegion()
+                {
+                    Buffer = entityTransformsBuffer,
+                    Size = (uint)targetLength,
+                };
+
+                SDL.UploadToGPUBuffer(copyPass, in location, in region, false);
+            }
+        }
+    }
+
     public void UpdateStaticMeshVertexBuffer<T>(BufferAttributeSource<T, VertexBuffer> buffer) where T : unmanaged
     {
         if (renderPass != nint.Zero)
@@ -253,7 +405,6 @@ public void UpdateStaticMeshVertexBuffer<T>(BufferAttributeSource<T, VertexBuffe
         }
 
         var index = buffer.index;
-        var transferBuffer = nint.Zero;
         var targetLength = buffer.allocator.buffer.Length * buffer.allocator.elementSize;
 
         ref var vertexBuffer = ref staticMeshVertexBuffers[index];
@@ -270,12 +421,10 @@ public void UpdateStaticMeshVertexBuffer<T>(BufferAttributeSource<T, VertexBuffe
                 vertexBuffer = nint.Zero;
             }
 
-            var usageFlags = SDL.GPUBufferUsageFlags.Vertex;
-
             var createInfo = new SDL.GPUBufferCreateInfo()
             {
                 Size = (uint)vertexBufferLength,
-                Usage = usageFlags,
+                Usage = SDL.GPUBufferUsageFlags.Vertex,
             };
 
             vertexBuffer = SDL.CreateGPUBuffer(device, in createInfo);
@@ -286,7 +435,7 @@ public void UpdateStaticMeshVertexBuffer<T>(BufferAttributeSource<T, VertexBuffe
             }
         }
 
-        transferBuffer = GetTransferBuffer(false, vertexBufferLength);
+        var transferBuffer = GetTransferBuffer(false, vertexBufferLength);
 
         if (transferBuffer == nint.Zero)
         {
@@ -348,7 +497,6 @@ public void UpdateStaticMeshIndexBuffer(BufferAttributeSource<uint, IndexBuffer>
             FinishPasses();
         }
 
-        var transferBuffer = nint.Zero;
         var targetLength = buffer.allocator.buffer.Length * buffer.allocator.elementSize;
 
         ref var indexBuffer = ref staticMeshIndexBuffer;
@@ -365,12 +513,10 @@ public void UpdateStaticMeshIndexBuffer(BufferAttributeSource<uint, IndexBuffer>
                 indexBuffer = nint.Zero;
             }
 
-            var usageFlags = SDL.GPUBufferUsageFlags.Index;
-
             var createInfo = new SDL.GPUBufferCreateInfo()
             {
                 Size = (uint)bufferLength,
-                Usage = usageFlags,
+                Usage = SDL.GPUBufferUsageFlags.Index,
             };
 
             indexBuffer = SDL.CreateGPUBuffer(device, in createInfo);
@@ -381,7 +527,7 @@ public void UpdateStaticMeshIndexBuffer(BufferAttributeSource<uint, IndexBuffer>
             }
         }
 
-        transferBuffer = GetTransferBuffer(false, bufferLength);
+        var transferBuffer = GetTransferBuffer(false, bufferLength);
 
         if (transferBuffer == nint.Zero)
         {

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

@@ -516,8 +516,10 @@ internal class RenderQueue
     internal static int[] staticMeshVertexBuffersLength = new int[18];
     internal static int[] staticMeshVertexBuffersElementSize = new int[18];
     internal static int staticMeshIndexBufferLength = 0;
+    internal static nint entityTransformsBuffer = nint.Zero;
+    internal static int entityTransformsBufferLength = 0;
 
-    private bool iteratingCommands = false;
+    private bool iteratingCommands;
     private int commandIndex;
     #endregion
 
@@ -657,7 +659,6 @@ public bool Initialize(RendererType renderer, bool debug, IRenderWindow window,
             {
                 RendererType.Metal => "metal",
                 RendererType.Direct3D12 => "direct3d12",
-                RendererType.Vulkan => "vulkan",
                 _ => "vulkan",
             });
 
@@ -671,16 +672,7 @@ public bool Initialize(RendererType renderer, bool debug, IRenderWindow window,
             return false;
         }
 
-        if(!DepthStencilFormat.HasValue)
-        {
-            SDL.DestroyGPUDevice(device);
-
-            device = nint.Zero;
-
-            return false;
-        }
-
-        if(!SDL.ClaimWindowForGPUDevice(device, w.window))
+        if(!DepthStencilFormat.HasValue || !SDL.ClaimWindowForGPUDevice(device, w.window))
         {
             SDL.DestroyGPUDevice(device);
 
@@ -882,6 +874,8 @@ public void EndFrame()
 
         frameAllocator.EnsurePin();
 
+        UpdateEntityTransformBuffer();
+
         StaticMeshData.Update();
 
         foreach (var pair in transientBuffers)

Engine/Staple.Core/Rendering/RenderSystem/RenderSystem+Internal.cs

@@ -76,12 +76,12 @@ internal class DrawBucket
     /// <summary>
     /// The entity query for every entity with a transform
     /// </summary>
-    private readonly SceneQuery<Transform> entityQuery = new();
+    internal readonly SceneQuery<Transform> entityQuery = new();
 
     /// <summary>
     /// All transforms of each entity
     /// </summary>
-    private Matrix4x4[] entityTransforms = new Matrix4x4[1024];
+    internal Matrix4x4[] entityTransforms = new Matrix4x4[1024];
 
     /// <summary>
     /// Tracker for each entity's transform

Engine/Staple.Core/Rendering/Windowing/Impls/SDL3RenderWindow.cs

@@ -415,12 +415,6 @@ public void PollEvents()
                     AppEventQueue.instance.Add(AppEvent.MoveWindow(new Vector2Int(winX, winY)));
 
                     break;
-                
-                case SDL.EventType.WindowResized:
-                    
-                    AppEventQueue.instance.Add(AppEvent.ResizeWindow());
-
-                    break;
 
                 case SDL.EventType.KeyDown:
                 case SDL.EventType.KeyUp:

Engine/Staple.Core/Rendering/Windowing/RenderWindow.cs

@@ -621,7 +621,6 @@ internal void CheckEvents()
 
                     break;
 
-                case AppEventType.ResizeWindow:
                 case AppEventType.MaximizeWindow:
 
                     RenderSystem.Backend.UpdateViewport(width, height);