Per ChunkArea PushConstants + VRAM Usage Reductions

src/main/java/net/vulkanmod/config/Config.java

@@ -21,6 +21,8 @@ public class Config {
     public boolean uniqueOpaqueLayer = true;
     public boolean entityCulling = true;
     public int device = -1;
+    public boolean animations = true;
+    public boolean renderSky = true;
 
     private static Path path;
 

src/main/java/net/vulkanmod/config/Options.java

@@ -154,6 +154,12 @@ public static Option<?>[] getGraphicsOpts() {
                 new RangeOption("Entity Distance", 50, 500, 25,
                         value -> minecraftOptions.entityDistanceScaling().set(value * 0.01),
                         () -> minecraftOptions.entityDistanceScaling().get().intValue() * 100),
+                new SwitchOption("Animations",
+                        value -> config.animations = value,
+                        () -> config.animations),
+                new SwitchOption("Render Sky",
+                        value -> config.renderSky = value,
+                        () -> config.renderSky),
                 new CyclingOption<>("Mipmap Levels",
                         new Integer[]{0, 1, 2, 3, 4},
                         value -> Component.nullToEmpty(value.toString()),

src/main/java/net/vulkanmod/mixin/render/RenderSystemMixin.java

@@ -357,13 +357,13 @@ public static void _setShaderLights(Vector3f p_157174_, Vector3f p_157175_) {
         shaderLightDirections[0] = p_157174_;
         shaderLightDirections[1] = p_157175_;
 
-        VRenderSystem.lightDirection0.buffer.putFloat(0, p_157174_.x());
-        VRenderSystem.lightDirection0.buffer.putFloat(4, p_157174_.y());
-        VRenderSystem.lightDirection0.buffer.putFloat(8, p_157174_.z());
+        VRenderSystem.lightDirection0.buffer().putFloat(0, p_157174_.x());
+        VRenderSystem.lightDirection0.buffer().putFloat(4, p_157174_.y());
+        VRenderSystem.lightDirection0.buffer().putFloat(8, p_157174_.z());
 
-        VRenderSystem.lightDirection1.buffer.putFloat(0, p_157175_.x());
-        VRenderSystem.lightDirection1.buffer.putFloat(4, p_157175_.y());
-        VRenderSystem.lightDirection1.buffer.putFloat(8, p_157175_.z());
+        VRenderSystem.lightDirection1.buffer().putFloat(0, p_157175_.x());
+        VRenderSystem.lightDirection1.buffer().putFloat(4, p_157175_.y());
+        VRenderSystem.lightDirection1.buffer().putFloat(8, p_157175_.z());
     }
 
     /**

src/main/java/net/vulkanmod/mixin/render/vertex/VertexBufferM.java

@@ -3,6 +3,7 @@
 import com.mojang.blaze3d.vertex.BufferBuilder;
 import com.mojang.blaze3d.vertex.VertexBuffer;
 import net.minecraft.client.renderer.ShaderInstance;
+import net.vulkanmod.Initializer;
 import net.vulkanmod.render.VBO;
 import org.joml.Matrix4f;
 import org.spongepowered.asm.mixin.Mixin;
@@ -57,7 +58,8 @@ public void upload(BufferBuilder.RenderedBuffer buffer) {
      */
     @Overwrite
     public void drawWithShader(Matrix4f viewMatrix, Matrix4f projectionMatrix, ShaderInstance shader) {
-        vbo.drawWithShader(viewMatrix, projectionMatrix, shader);
+      if(Initializer.CONFIG.renderSky)
+          vbo.drawWithShader(viewMatrix, projectionMatrix, shader);
     }
 
     /**

src/main/java/net/vulkanmod/mixin/texture/MTextureManager.java

@@ -5,6 +5,7 @@
 import net.minecraft.client.renderer.texture.TextureManager;
 import net.minecraft.client.renderer.texture.Tickable;
 import net.minecraft.resources.ResourceLocation;
+import net.vulkanmod.Initializer;
 import net.vulkanmod.render.texture.SpriteUtil;
 import net.vulkanmod.vulkan.DeviceManager;
 import net.vulkanmod.vulkan.Renderer;
@@ -29,7 +30,7 @@ public abstract class MTextureManager {
      */
     @Overwrite
     public void tick() {
-        if(Renderer.skipRendering)
+        if(Renderer.skipRendering|| !Initializer.CONFIG.animations)
             return;
 
         //Debug D

src/main/java/net/vulkanmod/render/PipelineManager.java

@@ -3,73 +3,81 @@
 import com.mojang.blaze3d.vertex.VertexFormat;
 import net.minecraft.client.renderer.RenderType;
 import net.vulkanmod.Initializer;
-import net.vulkanmod.render.chunk.build.ThreadBuilderPack;
 import net.vulkanmod.render.vertex.CustomVertexFormat;
+import net.vulkanmod.render.vertex.TerrainRenderType;
 import net.vulkanmod.vulkan.shader.GraphicsPipeline;
 import net.vulkanmod.vulkan.shader.Pipeline;
+import net.vulkanmod.vulkan.shader.SPIRVUtils;
 
 import java.util.function.Function;
 
+import static net.vulkanmod.vulkan.shader.SPIRVUtils.compileShaderAbsoluteFile;
+
 public abstract class PipelineManager {
+    private static final String resourcePath1 = SPIRVUtils.class.getResource("/assets/vulkanmod/shaders/").toExternalForm();
     public static VertexFormat TERRAIN_VERTEX_FORMAT;
 
     public static void setTerrainVertexFormat(VertexFormat format) {
         TERRAIN_VERTEX_FORMAT = format;
     }
 
-    static GraphicsPipeline terrainIndirectShader;
-    public static GraphicsPipeline terrainDirectShader;
-    public static GraphicsPipeline fastBlitPipeline;
+    static GraphicsPipeline terrainShaderEarlyZ, terrainShader, fastBlitPipeline;
 
-    private static Function<RenderType, GraphicsPipeline> shaderGetter;
+    private static Function<TerrainRenderType, GraphicsPipeline> shaderGetter;
 
     public static void init() {
         setTerrainVertexFormat(CustomVertexFormat.COMPRESSED_TERRAIN);
         createBasicPipelines();
         setDefaultShader();
-        ThreadBuilderPack.defaultTerrainBuilderConstructor();
+
     }
 
     public static void setDefaultShader() {
-        setShaderGetter(renderType -> Initializer.CONFIG.indirectDraw ? terrainIndirectShader : terrainDirectShader);
+        setShaderGetter(renderType -> renderType == TerrainRenderType.TRANSLUCENT ? terrainShaderEarlyZ : terrainShader);
     }
 
     private static void createBasicPipelines() {
-        terrainIndirectShader = createPipeline("terrain_indirect", CustomVertexFormat.COMPRESSED_TERRAIN);
-        terrainDirectShader = createPipeline("terrain_direct", CustomVertexFormat.COMPRESSED_TERRAIN);
-        fastBlitPipeline = createPipeline("blit", CustomVertexFormat.NONE);
+        terrainShaderEarlyZ = createPipeline("terrain","terrain", "terrain_Z", CustomVertexFormat.COMPRESSED_TERRAIN);
+        terrainShader = createPipeline("terrain", "terrain", "terrain", CustomVertexFormat.COMPRESSED_TERRAIN);
+        fastBlitPipeline = createPipeline("blit", "blit", "blit", CustomVertexFormat.NONE);
     }
 
-    private static GraphicsPipeline createPipeline(String name, VertexFormat vertexFormat) {
-        String path = String.format("basic/%s/%s", name, name);
+    private static GraphicsPipeline createPipeline(String baseName, String vertName, String fragName,VertexFormat vertexFormat) {
+        String pathB = String.format("basic/%s/%s", baseName, baseName);
+        String pathV = String.format("basic/%s/%s", baseName, vertName);
+        String pathF = String.format("basic/%s/%s", baseName, fragName);
 
-        Pipeline.Builder pipelineBuilder = new Pipeline.Builder(vertexFormat, path);
+        Pipeline.Builder pipelineBuilder = new Pipeline.Builder(vertexFormat, pathB);
         pipelineBuilder.parseBindingsJSON();
-        pipelineBuilder.compileShaders();
+
+
+        SPIRVUtils.SPIRV vertShaderSPIRV = compileShaderAbsoluteFile(String.format("%s%s.vsh", resourcePath1, pathV), SPIRVUtils.ShaderKind.VERTEX_SHADER);
+        SPIRVUtils.SPIRV fragShaderSPIRV = compileShaderAbsoluteFile(String.format("%s%s.fsh", resourcePath1, pathF), SPIRVUtils.ShaderKind.FRAGMENT_SHADER);
+        pipelineBuilder.compileShaders2(vertShaderSPIRV, fragShaderSPIRV);
+
         return pipelineBuilder.createGraphicsPipeline();
     }
-
-    public static GraphicsPipeline getTerrainShader(RenderType renderType) {
+    public static GraphicsPipeline getTerrainShader(TerrainRenderType renderType) {
         return shaderGetter.apply(renderType);
     }
 
-    public static void setShaderGetter(Function<RenderType, GraphicsPipeline> consumer) {
+    public static void setShaderGetter(Function<TerrainRenderType, GraphicsPipeline> consumer) {
         shaderGetter = consumer;
     }
 
     public static GraphicsPipeline getTerrainDirectShader(RenderType renderType) {
-        return terrainDirectShader;
+        return terrainShader;
     }
 
     public static GraphicsPipeline getTerrainIndirectShader(RenderType renderType) {
-        return terrainIndirectShader;
+        return terrainShaderEarlyZ;
     }
 
     public static GraphicsPipeline getFastBlitPipeline() { return fastBlitPipeline; }
 
     public static void destroyPipelines() {
-        terrainIndirectShader.cleanUp();
-        terrainDirectShader.cleanUp();
+        terrainShaderEarlyZ.cleanUp();
+        terrainShader.cleanUp();
         fastBlitPipeline.cleanUp();
     }
 }

src/main/java/net/vulkanmod/render/chunk/ChunkArea.java

@@ -1,28 +1,18 @@
 package net.vulkanmod.render.chunk;
 
 import net.minecraft.core.BlockPos;
-import net.vulkanmod.render.chunk.util.ResettableQueue;
 import net.vulkanmod.render.chunk.util.StaticQueue;
+import net.vulkanmod.render.vertex.TerrainRenderType;
 import org.joml.FrustumIntersection;
 import org.joml.Vector3i;
 
 import java.util.Arrays;
 
-public class ChunkArea {
-    public final int index;
-    private final byte[] inFrustum = new byte[64];
+public record ChunkArea(int index, byte[] inFrustum, Vector3i position, DrawBuffers drawBuffers)
+{
 
-    final Vector3i position;
-
-    DrawBuffers drawBuffers;
-
-    //Help JIT optimisations by hardcoding the queue size to the max possible ChunkArea limit
-    final StaticQueue<RenderSection> sectionQueue = new StaticQueue<>(512);
-
-    public ChunkArea(int i, Vector3i origin) {
-        this.index = i;
-        this.position = origin;
-        this.drawBuffers = new DrawBuffers();
+    public ChunkArea(int i, Vector3i origin, int minHeight) {
+        this(i, new byte[64], origin, new DrawBuffers(i, origin, minHeight));
     }
 
     public void updateFrustum(VFrustum frustum) {
@@ -120,16 +110,16 @@ public DrawBuffers getDrawBuffers() {
         return this.drawBuffers;
     }
 
-    private void allocateDrawBuffers() {
-        this.drawBuffers = new DrawBuffers();
-    }
+//    private void allocateDrawBuffers() {
+//        this.drawBuffers = new DrawBuffers(this.index, this.position);
+//    }
 
-    public void addSection(RenderSection section) {
-        this.sectionQueue.add(section);
+    public void addSection(RenderSection section, TerrainRenderType renderType) {
+        this.drawBuffers.addDrawCommands(renderType, section.getDrawParameters(renderType));
     }
 
     public void resetQueue() {
-        this.sectionQueue.clear();
+        this.drawBuffers.clear();
     }
 
     public void setPosition(int x, int y, int z) {

src/main/java/net/vulkanmod/render/chunk/ChunkAreaManager.java

@@ -45,7 +45,7 @@ public ChunkAreaManager(int width, int height, int minHeight) {
                 for(int l = 0; l < this.xzSize; ++l) {
                     int i1 = this.getAreaIndex(j, k, l);
                     Vector3i vector3i = new Vector3i(j << BASE_SH_XZ + 4, k << BASE_SH_Y + 4, l << BASE_SH_XZ + 4);
-                    this.chunkAreasArr[i1] = new ChunkArea(i1, vector3i);
+                    this.chunkAreasArr[i1] = new ChunkArea(i1, vector3i, minHeight);
                 }
             }
         }
@@ -180,7 +180,7 @@ public void updateFrustumVisibility(VFrustum frustum) {
 
     public void resetQueues() {
         for(ChunkArea chunkArea : this.chunkAreasArr) {
-            chunkArea.sectionQueue.clear();
+            chunkArea.drawBuffers().clear();
         }
     }