Move particle vertex processing to the GPU

src/api/java/net/caffeinemc/mods/sodium/api/buffer/UnmanagedBufferBuilder.java

@@ -0,0 +1,70 @@
+package net.caffeinemc.mods.sodium.api.buffer;
+
+import net.caffeinemc.mods.sodium.api.memory.MemoryIntrinsics;
+import net.minecraft.client.util.GlAllocationUtils;
+import org.lwjgl.system.MemoryStack;
+import org.lwjgl.system.MemoryUtil;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Provides a growing buffer with a push method for convenience.
+ * Otherwise, this class is very un-managed.
+ */
+public class UnmanagedBufferBuilder {
+    private ByteBuffer buffer;
+    private int byteOffset = 0;
+
+    public UnmanagedBufferBuilder(int initialCapacity) {
+        this.buffer = GlAllocationUtils.allocateByteBuffer(initialCapacity);
+    }
+
+    public void ensureCapacity(int capacity) {
+        if (capacity > this.buffer.capacity()) {
+            int newCapacity = (int) Math.ceil(this.buffer.capacity() * 1.5);
+            ByteBuffer byteBuffer = GlAllocationUtils.resizeByteBuffer(this.buffer, Math.max(newCapacity, capacity));
+            byteBuffer.rewind();
+            this.buffer = byteBuffer;
+        }
+    }
+
+    /**
+     * Copies memory from the stack onto the end of this buffer builder.
+     */
+    public void push(MemoryStack ignoredStack, long src, int size) {
+        ensureCapacity(byteOffset + size);
+
+        long dst = MemoryUtil.memAddress(this.buffer, this.byteOffset);
+        MemoryIntrinsics.copyMemory(src, dst, size);
+        byteOffset += size;
+    }
+
+    public Built build() {
+        return new Built(this.byteOffset, MemoryUtil.memSlice(this.buffer, 0, this.byteOffset));
+    }
+
+    public void reset() {
+        this.byteOffset = 0;
+    }
+
+    /**
+     * Builds and resets this builder.
+     * Make sure to use/upload the return value before pushing more data.
+     * @return a built buffer containing all the data pushed to this builder
+     */
+    public Built end() {
+        int endOffset = this.byteOffset;
+        this.byteOffset = 0;
+        return new Built(endOffset, MemoryUtil.memSlice(this.buffer, 0, endOffset));
+    }
+
+    public static class Built {
+        public int size;
+        public ByteBuffer buffer;
+
+        Built(int size, ByteBuffer buffer) {
+            this.size = size;
+            this.buffer = buffer;
+        }
+    }
+}

src/api/java/net/caffeinemc/mods/sodium/api/util/RawUVs.java

@@ -0,0 +1,50 @@
+package net.caffeinemc.mods.sodium.api.util;
+
+import org.lwjgl.system.MemoryUtil;
+
+public record RawUVs(float minU, float minV, float maxU, float maxV) {
+    public static final int STRIDE = 16;
+
+    public void put(long ptr) {
+        MemoryUtil.memPutFloat(ptr + 0, minU);
+        MemoryUtil.memPutFloat(ptr + 4, minV);
+        MemoryUtil.memPutFloat(ptr + 8, maxU);
+        MemoryUtil.memPutFloat(ptr + 12, maxV);
+    }
+
+    public static void putNull(long ptr) {
+        MemoryUtil.memPutFloat(ptr + 0, Float.NaN);
+        MemoryUtil.memPutFloat(ptr + 4, Float.NaN);
+        MemoryUtil.memPutFloat(ptr + 8, Float.NaN);
+        MemoryUtil.memPutFloat(ptr + 12, Float.NaN);
+    }
+
+    public long key() {
+        return ((long) Float.floatToRawIntBits(minU)) << 32 | Float.floatToRawIntBits(minV);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o instanceof RawUVs other) {
+            return Float.floatToRawIntBits(minU) == Float.floatToRawIntBits(other.minU()) &&
+                   Float.floatToRawIntBits(minV) == Float.floatToRawIntBits(other.minV()) &&
+                   Float.floatToRawIntBits(maxU) == Float.floatToRawIntBits(other.maxU()) &&
+                   Float.floatToRawIntBits(maxV) == Float.floatToRawIntBits(other.maxV());
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 1;
+
+        result = 31 * result + Float.floatToRawIntBits(minU);
+        result = 31 * result + Float.floatToRawIntBits(minV);
+        result = 31 * result + Float.floatToRawIntBits(maxU);
+        result = 31 * result + Float.floatToRawIntBits(maxV);
+
+        return result;
+    }
+}

src/main/java/me/jellysquid/mods/sodium/client/gl/arena/staging/StagingBufferBuilder.java

@@ -0,0 +1,76 @@
+package me.jellysquid.mods.sodium.client.gl.arena.staging;
+
+import me.jellysquid.mods.sodium.client.SodiumClientMod;
+import me.jellysquid.mods.sodium.client.gl.buffer.*;
+import me.jellysquid.mods.sodium.client.gl.device.CommandList;
+import me.jellysquid.mods.sodium.client.gl.util.EnumBitField;
+import org.lwjgl.system.MemoryStack;
+
+public class StagingBufferBuilder {
+    private static final EnumBitField<GlBufferStorageFlags> STORAGE_FLAGS =
+            EnumBitField.of(GlBufferStorageFlags.PERSISTENT, GlBufferStorageFlags.CLIENT_STORAGE, GlBufferStorageFlags.MAP_WRITE);
+
+    private static final EnumBitField<GlBufferMapFlags> MAP_FLAGS =
+            EnumBitField.of(GlBufferMapFlags.PERSISTENT, GlBufferMapFlags.INVALIDATE_BUFFER, GlBufferMapFlags.WRITE, GlBufferMapFlags.EXPLICIT_FLUSH);
+
+    private final MappedBuffer mappedBuffer;
+
+    private int capacity;
+
+    private int start = 0;
+    private int pos = 0;
+
+    private int numFrames = 0;
+
+    public StagingBufferBuilder(CommandList commandList, int capacity) {
+        this.capacity = capacity;
+
+        GlImmutableBuffer buffer = commandList.createImmutableBuffer(capacity, STORAGE_FLAGS);
+        GlBufferMapping map = commandList.mapBuffer(buffer, 0, capacity, MAP_FLAGS);
+
+        this.mappedBuffer = new MappedBuffer(buffer, map);
+    }
+
+    public void push(MemoryStack stack, long ptr, int size) {
+        if (pos + size > this.capacity) {
+            // TODO: Needs a fallback instead of throwing, (even if it is highly unlikely)
+
+            throw new IllegalStateException("Particle data buffer overflowed!\n" +
+                    "Capacity: " + this.capacity);
+        }
+
+        this.mappedBuffer.map.write(stack, ptr, size, pos);
+        pos += size;
+    }
+
+    public void endAndUpload(CommandList commandList, GlBuffer dst, long writeOffset) {
+        this.flush(commandList, dst, this.start, this.pos - this.start, writeOffset);
+        this.start = this.pos;
+    }
+
+    public void flipFrame() {
+        this.numFrames++;
+        if (numFrames >= SodiumClientMod.options().advanced.cpuRenderAheadLimit) {
+            this.reset();
+        }
+    }
+
+    private void reset() {
+        this.start = 0;
+        this.pos = 0;
+        this.numFrames = 0;
+    }
+
+    private void flush(CommandList commandList, GlBuffer dst, int readOffset, int length, long writeOffset) {
+        commandList.flushMappedRange(this.mappedBuffer.map, readOffset, length);
+        commandList.copyBufferSubData(this.mappedBuffer.buffer, dst, readOffset, writeOffset, length);
+    }
+
+    private record MappedBuffer(GlImmutableBuffer buffer,
+                                GlBufferMapping map) {
+        public void delete(CommandList commandList) {
+            commandList.unmap(this.map);
+            commandList.deleteBuffer(this.buffer);
+        }
+    }
+}

src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBufferMapping.java

@@ -1,5 +1,6 @@
 package me.jellysquid.mods.sodium.client.gl.buffer;
 
+import org.lwjgl.system.MemoryStack;
 import org.lwjgl.system.MemoryUtil;
 
 import java.nio.ByteBuffer;
@@ -19,6 +20,10 @@ public void write(ByteBuffer data, int writeOffset) {
         MemoryUtil.memCopy(MemoryUtil.memAddress(data), MemoryUtil.memAddress(this.map, writeOffset), data.remaining());
     }
 
+    public void write(MemoryStack ignoredStack, long ptr, int size, int writeOffset) {
+        MemoryUtil.memCopy(ptr, MemoryUtil.memAddress(this.map, writeOffset), size);
+    }
+
     public GlBuffer getBufferObject() {
         return this.buffer;
     }

src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlBufferTexture.java

@@ -0,0 +1,33 @@
+package me.jellysquid.mods.sodium.client.gl.buffer;
+
+import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.systems.RenderSystem;
+import me.jellysquid.mods.sodium.client.gl.device.CommandList;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL31;
+
+import java.nio.ByteBuffer;
+
+public class GlBufferTexture {
+    private final GlBuffer buffer;
+
+    private final int glTexHandle;
+
+    private final int textureNum;
+
+    public GlBufferTexture(GlBuffer buffer, int textureNum) {
+        this.buffer = buffer;
+        this.glTexHandle = GlStateManager._genTexture();
+        this.textureNum = textureNum;
+    }
+
+    public int getTextureNum() {
+        return textureNum;
+    }
+
+    public void bind() {
+        GL11.glBindTexture(GL31.GL_TEXTURE_BUFFER, this.glTexHandle);
+        GL31.glTexBuffer(GL31.GL_TEXTURE_BUFFER, GL31.GL_R32UI, this.buffer.handle());
+        RenderSystem.setShaderTexture(this.textureNum, this.glTexHandle);
+    }
+}

src/main/java/me/jellysquid/mods/sodium/client/gl/buffer/GlContinuousUploadBuffer.java

@@ -0,0 +1,51 @@
+package me.jellysquid.mods.sodium.client.gl.buffer;
+
+import me.jellysquid.mods.sodium.client.SodiumClientMod;
+import me.jellysquid.mods.sodium.client.gl.arena.staging.FallbackStagingBuffer;
+import me.jellysquid.mods.sodium.client.gl.arena.staging.MappedStagingBuffer;
+import me.jellysquid.mods.sodium.client.gl.arena.staging.StagingBuffer;
+import me.jellysquid.mods.sodium.client.gl.device.CommandList;
+import me.jellysquid.mods.sodium.client.gl.device.RenderDevice;
+
+import java.nio.ByteBuffer;
+
+public class GlContinuousUploadBuffer extends GlMutableBuffer {
+    private static final GlBufferUsage BUFFER_USAGE = GlBufferUsage.STATIC_DRAW;
+    private static final int DEFAULT_INITIAL_CAPACITY = 1024;
+
+    private final StagingBuffer stagingBuffer;
+
+    private int capacity;
+
+    public GlContinuousUploadBuffer(CommandList commands, int initialCapacity) {
+        super();
+        this.capacity = initialCapacity;
+        this.stagingBuffer = createStagingBuffer(commands);
+        commands.allocateStorage(this, this.capacity, BUFFER_USAGE);
+    }
+
+    public GlContinuousUploadBuffer(CommandList commands) {
+        this(commands, DEFAULT_INITIAL_CAPACITY);
+    }
+
+    public void uploadOverwrite(CommandList commandList, ByteBuffer data, int size) {
+        ensureCapacity(commandList, size);
+        this.stagingBuffer.enqueueCopy(commandList, data, this, 0);
+        this.stagingBuffer.flush(commandList);
+    }
+
+    public void ensureCapacity(CommandList commandList, int capacity) {
+        if (capacity > this.capacity) {
+            this.capacity = capacity;
+            commandList.allocateStorage(this, capacity, BUFFER_USAGE);
+        }
+    }
+
+    private static StagingBuffer createStagingBuffer(CommandList commandList) {
+        if (SodiumClientMod.options().advanced.useAdvancedStagingBuffers && MappedStagingBuffer.isSupported(RenderDevice.INSTANCE)) {
+            return new MappedStagingBuffer(commandList);
+        }
+
+        return new FallbackStagingBuffer(commandList);
+    }
+}

src/main/java/me/jellysquid/mods/sodium/client/render/particle/BillboardExtended.java

@@ -0,0 +1,10 @@
+package me.jellysquid.mods.sodium.client.render.particle;
+
+import me.jellysquid.mods.sodium.client.gl.arena.staging.StagingBufferBuilder;
+import me.jellysquid.mods.sodium.client.render.particle.cache.ParticleTextureCache;
+import net.caffeinemc.mods.sodium.api.buffer.UnmanagedBufferBuilder;
+import net.minecraft.client.render.Camera;
+
+public interface BillboardExtended {
+    void sodium$buildParticleData(StagingBufferBuilder builder, ParticleTextureCache registry, Camera camera, float tickDelta);
+}

src/main/java/me/jellysquid/mods/sodium/client/render/particle/ParticleBuffers.java

@@ -0,0 +1,37 @@
+package me.jellysquid.mods.sodium.client.render.particle;
+
+import me.jellysquid.mods.sodium.client.gl.arena.staging.StagingBufferBuilder;
+import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferTexture;
+import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferUsage;
+import me.jellysquid.mods.sodium.client.gl.buffer.GlContinuousUploadBuffer;
+import me.jellysquid.mods.sodium.client.gl.buffer.GlMutableBuffer;
+import me.jellysquid.mods.sodium.client.gl.device.CommandList;
+import net.caffeinemc.mods.sodium.api.buffer.UnmanagedBufferBuilder;
+
+public class ParticleBuffers {
+    private final GlMutableBuffer particleData;
+    private final GlContinuousUploadBuffer textureCache;
+
+    private final GlBufferTexture particleDataTex;
+    private final GlBufferTexture textureCacheTex;
+
+    public ParticleBuffers(CommandList commandList) {
+        this.particleData = commandList.createMutableBuffer();
+        commandList.allocateStorage(particleData, 3 * 16384 * 32, GlBufferUsage.STATIC_DRAW);
+
+        this.textureCache = new GlContinuousUploadBuffer(commandList);
+
+        this.particleDataTex = new GlBufferTexture(particleData, 3);
+        this.textureCacheTex = new GlBufferTexture(textureCache, 4);
+    }
+
+    public void uploadParticleData(CommandList commandList, StagingBufferBuilder data, UnmanagedBufferBuilder.Built cache) {
+        data.endAndUpload(commandList, this.particleData, 0);
+        this.textureCache.uploadOverwrite(commandList, cache.buffer, cache.size);
+    }
+
+    public void bind() {
+        this.particleDataTex.bind();
+        this.textureCacheTex.bind();
+    }
+}

src/main/java/me/jellysquid/mods/sodium/client/render/particle/ParticleExtended.java

@@ -0,0 +1,5 @@
+package me.jellysquid.mods.sodium.client.render.particle;
+
+public interface ParticleExtended {
+    void sodium$configure(ParticleRenderView renderView);
+}