Setup entry point + integrated moonworks stuff

2024-07-05 14:32:58 +02:00
parent e7a4a862be
commit 8334a24fd1
116 changed files with 16988 additions and 3 deletions
@@ -0,0 +1,191 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+using WellspringCS;
+
+namespace Nerfed.Runtime.Graphics;
+
+public unsafe class TextBatch : GraphicsResource
+{
+    public const int INITIAL_CHAR_COUNT = 64;
+    public const int INITIAL_VERTEX_COUNT = INITIAL_CHAR_COUNT * 4;
+    public const int INITIAL_INDEX_COUNT = INITIAL_CHAR_COUNT * 6;
+
+    public IntPtr Handle { get; }
+    public Buffer VertexBuffer { get; protected set; } = null;
+    public Buffer IndexBuffer { get; protected set; } = null;
+    public uint PrimitiveCount { get; protected set; }
+    public Font CurrentFont { get; private set; }
+
+    private readonly GraphicsDevice graphicsDevice;
+    private readonly int stringBytesLength;
+    private TransferBuffer TransferBuffer;
+    private byte* stringBytes;
+
+    public TextBatch(GraphicsDevice device) : base(device)
+    {
+        graphicsDevice = device;
+        Handle = Wellspring.Wellspring_CreateTextBatch();
+
+        stringBytesLength = 128;
+        stringBytes = (byte*)NativeMemory.Alloc((nuint)stringBytesLength);
+
+        VertexBuffer = Buffer.Create<FontVertex>(graphicsDevice, BufferUsageFlags.Vertex, INITIAL_VERTEX_COUNT);
+        IndexBuffer = Buffer.Create<uint>(graphicsDevice, BufferUsageFlags.Index, INITIAL_INDEX_COUNT);
+
+        TransferBuffer = TransferBuffer.Create<byte>(
+            graphicsDevice,
+            TransferBufferUsage.Upload,
+            VertexBuffer.Size + IndexBuffer.Size
+        );
+    }
+
+    // Call this to initialize or reset the batch.
+    public void Start(Font font)
+    {
+        Wellspring.Wellspring_StartTextBatch(Handle, font.Handle);
+        CurrentFont = font;
+        PrimitiveCount = 0;
+    }
+
+    // Add text with size and color to the batch
+    public unsafe bool Add(
+        string text,
+        int pixelSize,
+        Color color,
+        HorizontalAlignment horizontalAlignment = HorizontalAlignment.Left,
+        VerticalAlignment verticalAlignment = VerticalAlignment.Baseline
+    )
+    {
+        int byteCount = System.Text.Encoding.UTF8.GetByteCount(text);
+
+        if (stringBytesLength < byteCount)
+        {
+            stringBytes = (byte*)NativeMemory.Realloc(stringBytes, (nuint)byteCount);
+        }
+
+        fixed (char* chars = text)
+        {
+            System.Text.Encoding.UTF8.GetBytes(chars, text.Length, stringBytes, byteCount);
+
+            byte result = Wellspring.Wellspring_AddToTextBatch(
+                Handle,
+                pixelSize,
+                new Wellspring.Color { R = color.R, G = color.G, B = color.B, A = color.A },
+                (Wellspring.HorizontalAlignment)horizontalAlignment,
+                (Wellspring.VerticalAlignment)verticalAlignment,
+                (IntPtr)stringBytes,
+                (uint)byteCount
+            );
+
+            if (result == 0)
+            {
+                Log.Warning("Could not decode string: " + text);
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    // Call this after you have made all the Add calls you want, but before beginning a render pass.
+    public unsafe void UploadBufferData(CommandBuffer commandBuffer)
+    {
+        Wellspring.Wellspring_GetBufferData(
+            Handle,
+            out uint vertexCount,
+            out IntPtr vertexDataPointer,
+            out uint vertexDataLengthInBytes,
+            out IntPtr indexDataPointer,
+            out uint indexDataLengthInBytes
+        );
+
+        Span<byte> vertexSpan = new Span<byte>((void*)vertexDataPointer, (int)vertexDataLengthInBytes);
+        Span<byte> indexSpan = new Span<byte>((void*)indexDataPointer, (int)indexDataLengthInBytes);
+
+        bool newTransferBufferNeeded = false;
+
+        if (VertexBuffer.Size < vertexDataLengthInBytes)
+        {
+            VertexBuffer.Dispose();
+            VertexBuffer = new Buffer(graphicsDevice, BufferUsageFlags.Vertex, vertexDataLengthInBytes);
+            newTransferBufferNeeded = true;
+        }
+
+        if (IndexBuffer.Size < indexDataLengthInBytes)
+        {
+            IndexBuffer.Dispose();
+            IndexBuffer = new Buffer(graphicsDevice, BufferUsageFlags.Index, vertexDataLengthInBytes);
+            newTransferBufferNeeded = true;
+        }
+
+        if (newTransferBufferNeeded)
+        {
+            TransferBuffer.Dispose();
+            TransferBuffer = new TransferBuffer(
+                graphicsDevice,
+                TransferBufferUsage.Upload,
+                VertexBuffer.Size + IndexBuffer.Size
+            );
+        }
+
+        if (vertexDataLengthInBytes > 0 && indexDataLengthInBytes > 0)
+        {
+            TransferBuffer.SetData(vertexSpan, true);
+            TransferBuffer.SetData(indexSpan, (uint)vertexSpan.Length, false);
+
+            CopyPass copyPass = commandBuffer.BeginCopyPass();
+            copyPass.UploadToBuffer(
+                new TransferBufferLocation(TransferBuffer),
+                new BufferRegion(VertexBuffer, 0, (uint)vertexSpan.Length),
+                true
+            );
+            copyPass.UploadToBuffer(
+                new TransferBufferLocation(TransferBuffer, (uint)vertexSpan.Length),
+                new BufferRegion(IndexBuffer, 0, (uint)indexSpan.Length),
+                true
+            );
+            commandBuffer.EndCopyPass(copyPass);
+        }
+
+        PrimitiveCount = vertexCount / 2;
+    }
+
+    // Call this AFTER binding your text pipeline!
+    public void Render(CommandBuffer commandBuffer, RenderPass renderPass, Matrix4x4 transformMatrix)
+    {
+        commandBuffer.PushVertexUniformData(transformMatrix);
+        commandBuffer.PushFragmentUniformData(CurrentFont.DistanceRange);
+
+        renderPass.BindFragmentSampler(
+            new TextureSamplerBinding(
+                CurrentFont.Texture,
+                graphicsDevice.LinearSampler
+            )
+        );
+        renderPass.BindVertexBuffer(VertexBuffer);
+        renderPass.BindIndexBuffer(IndexBuffer, IndexElementSize.ThirtyTwo);
+
+        renderPass.DrawIndexedPrimitives(
+            0,
+            0,
+            PrimitiveCount
+        );
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (!IsDisposed)
+        {
+            if (disposing)
+            {
+                VertexBuffer.Dispose();
+                IndexBuffer.Dispose();
+            }
+
+            NativeMemory.Free(stringBytes);
+            Wellspring.Wellspring_DestroyTextBatch(Handle);
+        }
+
+        base.Dispose(disposing);
+    }
+}