[Performance + VRAM] Re-implement 16-byte Vertex Format + use 4 Byte alignment

build.gradle

@@ -1,5 +1,5 @@
 plugins {
-	id 'fabric-loom' version '1.6.11'
+	id 'fabric-loom' version '1.9.2'
 	id 'maven-publish'
 }
 
@@ -23,7 +23,6 @@ dependencies {
 	// Fabric API. This is technically optional, but you probably want it anyway.
 	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
 
-	// Needed in order to load mod namespace
 	ext.includeModule = { name ->
 		var module = fabricApi.module(name, project.fabric_version)
 		modImplementation(module)
@@ -32,8 +31,11 @@ dependencies {
 
 	includeModule("fabric-api-base")
 	includeModule("fabric-resource-loader-v0")
-	includeModule("fabric-rendering-fluids-v1")
 	includeModule("fabric-rendering-v1")
+	includeModule("fabric-renderer-api-v1")
+	includeModule("fabric-rendering-fluids-v1")
+	includeModule("fabric-rendering-data-attachment-v1")
+	includeModule("fabric-block-view-api-v2")
 }
 
 project.ext.lwjglVersion = "3.3.3"

gradle.properties

@@ -4,14 +4,14 @@ org.gradle.parallel=true
 
 # Fabric Properties
 # check these on https://fabricmc.net/develop
-minecraft_version=1.21
-yarn_mappings=1.21+build.1
-loader_version=0.16.5
+minecraft_version=1.21.1
+yarn_mappings=1.21.1+build.3
+loader_version=0.16.9
 
 # Fabric API
-fabric_version=0.102.0+1.21
+fabric_version=0.114.0+1.21.1
 
 # Mod Properties
-mod_version = 0.4.8_dev
+mod_version = 0.5.3-dev
 maven_group = net.vulkanmod
-archives_base_name = VulkanMod_1.21
+archives_base_name = VulkanMod_1.21.1

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/java/net/vulkanmod/Initializer.java

@@ -1,10 +1,12 @@
 package net.vulkanmod;
 
 import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.renderer.v1.RendererAccess;
 import net.fabricmc.loader.api.FabricLoader;
 import net.vulkanmod.config.Config;
 import net.vulkanmod.config.Platform;
 import net.vulkanmod.config.video.VideoModeManager;
+import net.vulkanmod.render.chunk.build.frapi.VulkanModRenderer;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -35,6 +37,8 @@ public void onInitializeClient() {
 				.resolve("vulkanmod_settings.json");
 
 		CONFIG = loadConfig(configPath);
+
+		RendererAccess.INSTANCE.registerRenderer(VulkanModRenderer.INSTANCE);
 	}
 
 	private static Config loadConfig(Path path) {

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

@@ -16,17 +16,19 @@ public class Config {
 
     public int frameQueueSize = 2;
     public VideoModeSet.VideoMode videoMode = VideoModeManager.getFirstAvailable().getVideoMode();
-    public boolean windowedFullscreen = false;
+    public int windowMode = 0;
 
     public int advCulling = 2;
-    public boolean indirectDraw = false;
+    public boolean indirectDraw = true;
 
     public boolean uniqueOpaqueLayer = true;
     public boolean entityCulling = true;
     public int device = -1;
 
     public int ambientOcclusion = 1;
 
+    public boolean backFaceCulling = true;
+
     public void write() {
 
         if(!Files.exists(CONFIG_PATH.getParent())) {

src/main/java/net/vulkanmod/config/gui/GuiRenderer.java

@@ -20,9 +20,10 @@ public abstract class GuiRenderer {
     public static Font font;
     public static GuiGraphics guiGraphics;
     public static PoseStack pose;
-
     public static BufferBuilder bufferBuilder;
-    public static boolean batching = false;
+
+    private static boolean batching = false;
+    private static boolean drawing = false;
 
     public static void setPoseStack(PoseStack poseStack) {
         pose = poseStack;
@@ -61,16 +62,14 @@ public static void fill(float x0, float y0, float x1, float y1, float z, int col
 
         RenderSystem.setShader(GameRenderer::getPositionColorShader);
 
-        if (!batching)
-            bufferBuilder = Tesselator.getInstance().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
+        setupBufferBuilder();
 
         bufferBuilder.addVertex(matrix4f, x0, y0, z).setColor(r, g, b, a);
         bufferBuilder.addVertex(matrix4f, x0, y1, z).setColor(r, g, b, a);
         bufferBuilder.addVertex(matrix4f, x1, y1, z).setColor(r, g, b, a);
         bufferBuilder.addVertex(matrix4f, x1, y0, z).setColor(r, g, b, a);
 
-        if (!batching)
-            BufferUploader.drawWithShader(bufferBuilder.buildOrThrow());
+        submitIfNeeded();
     }
 
     public static void fillGradient(float x0, float y0, float x1, float y1, int color1, int color2) {
@@ -89,18 +88,14 @@ public static void fillGradient(float x0, float y0, float x1, float y1, float z,
 
         Matrix4f matrix4f = pose.last().pose();
 
-        RenderSystem.setShader(GameRenderer::getPositionColorShader);
-
-        if (!batching)
-            bufferBuilder = Tesselator.getInstance().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
+        setupBufferBuilder();
 
         bufferBuilder.addVertex(matrix4f, x0, y0, z).setColor(r1, g1, b1, a1);
         bufferBuilder.addVertex(matrix4f, x0, y1, z).setColor(r2, g2, b2, a2);
         bufferBuilder.addVertex(matrix4f, x1, y1, z).setColor(r2, g2, b2, a2);
         bufferBuilder.addVertex(matrix4f, x1, y0, z).setColor(r1, g1, b1, a1);
 
-        if (!batching)
-            BufferUploader.drawWithShader(bufferBuilder.buildOrThrow());
+        submitIfNeeded();
     }
 
     public static void renderBoxBorder(float x0, float y0, float width, float height, float borderWidth, int color) {
@@ -147,13 +142,43 @@ public static int getMaxTextWidth(Font font, List<FormattedCharSequence> list) {
         return maxWidth;
     }
 
-    public static void beginBatch(VertexFormat.Mode mode, VertexFormat format) {
-        bufferBuilder = Tesselator.getInstance().begin(mode, format);
+    public static void beginBatch() {
         batching = true;
     }
 
     public static void endBatch() {
-        BufferUploader.drawWithShader(bufferBuilder.buildOrThrow());
+        RenderSystem.setShader(GameRenderer::getPositionColorShader);
+        MeshData meshData = bufferBuilder.build();
+
+        if (meshData != null) {
+            BufferUploader.drawWithShader(meshData);
+            meshData.close();
+        }
+
         batching = false;
+        drawing = false;
+    }
+
+    public static void flush() {
+        guiGraphics.flush();
+
+        if (batching) {
+            endBatch();
+        }
+    }
+
+    private static void setupBufferBuilder() {
+        if (!batching || !drawing) {
+            bufferBuilder = Tesselator.getInstance().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
+            drawing = true;
+        }
+    }
+
+    private static void submitIfNeeded() {
+        if (!batching) {
+            RenderSystem.setShader(GameRenderer::getPositionColorShader);
+            BufferUploader.drawWithShader(bufferBuilder.buildOrThrow());
+            drawing = false;
+        }
     }
 }

src/main/java/net/vulkanmod/config/gui/VOptionList.java

@@ -272,6 +272,8 @@ protected void renderList(int mouseX, int mouseY) {
 
             rowTop += entry.getTotalHeight();
         }
+
+        GuiRenderer.flush();
     }
 
     private Entry getEntry(int j) {

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

@@ -8,7 +8,9 @@
 import net.vulkanmod.config.gui.OptionBlock;
 import net.vulkanmod.config.video.VideoModeManager;
 import net.vulkanmod.config.video.VideoModeSet;
+import net.vulkanmod.config.video.WindowMode;
 import net.vulkanmod.render.chunk.build.light.LightMode;
+import net.vulkanmod.render.vertex.TerrainRenderType;
 import net.vulkanmod.vulkan.Renderer;
 import net.vulkanmod.vulkan.device.DeviceManager;
 
@@ -76,19 +78,18 @@ public static OptionBlock[] getVideoOpts() {
                 new OptionBlock("", new Option<?>[]{
                         resolutionOption,
                         RefreshRate,
-                        new SwitchOption(Component.translatable("options.fullscreen"),
+                        new CyclingOption<>(Component.translatable("vulkanmod.options.windowMode"),
+                                WindowMode.values(),
                                 value -> {
-                                    minecraftOptions.fullscreen().set(value);
-//                            window.toggleFullScreen();
-                                    fullscreenDirty = true;
-                                },
-                                () -> minecraftOptions.fullscreen().get()),
-                        new SwitchOption(Component.translatable("vulkanmod.options.windowedFullscreen"),
-                                value -> {
-                                    config.windowedFullscreen = value;
+                                    boolean exclusiveFullscreen = value == WindowMode.EXCLUSIVE_FULLSCREEN;
+                                    minecraftOptions.fullscreen()
+                                                    .set(exclusiveFullscreen);
+
+                                    config.windowMode = value.mode;
                                     fullscreenDirty = true;
                                 },
-                                () -> config.windowedFullscreen),
+                                () -> WindowMode.fromValue(config.windowMode))
+                                .setTranslator(value -> Component.translatable(WindowMode.getComponentName(value))),
                         new RangeOption(Component.translatable("options.framerateLimit"),
                                 10, 260, 10,
                                 value -> Component.nullToEmpty(value == 260 ?
@@ -252,10 +253,18 @@ public static OptionBlock[] getOptimizationOpts() {
                         new SwitchOption(Component.translatable("vulkanmod.options.uniqueOpaqueLayer"),
                                 value -> {
                                     config.uniqueOpaqueLayer = value;
+                                    TerrainRenderType.updateMapping();
                                     minecraft.levelRenderer.allChanged();
                                 },
                                 () -> config.uniqueOpaqueLayer)
                                 .setTooltip(Component.translatable("vulkanmod.options.uniqueOpaqueLayer.tooltip")),
+                        new SwitchOption(Component.translatable("vulkanmod.options.backfaceCulling"),
+                                value -> {
+                                    config.backFaceCulling = value;
+                                    Minecraft.getInstance().levelRenderer.allChanged();
+                                },
+                                () -> config.backFaceCulling)
+                                .setTooltip(Component.translatable("vulkanmod.options.backfaceCulling.tooltip")),
                         new SwitchOption(Component.translatable("vulkanmod.options.indirectDraw"),
                                 value -> config.indirectDraw = value,
                                 () -> config.indirectDraw)

src/main/java/net/vulkanmod/config/video/WindowMode.java

@@ -0,0 +1,31 @@
+package net.vulkanmod.config.video;
+
+public enum WindowMode {
+    WINDOWED(0),
+    WINDOWED_FULLSCREEN(1),
+    EXCLUSIVE_FULLSCREEN(2);
+
+    public final int mode;
+
+    WindowMode(int mode) {
+        this.mode = mode;
+    }
+
+    public static WindowMode fromValue(int value) {
+        return switch (value) {
+            case 0 -> WINDOWED;
+            case 1 -> WINDOWED_FULLSCREEN;
+            case 2 -> EXCLUSIVE_FULLSCREEN;
+
+            default -> throw new IllegalStateException("Unexpected value: " + value);
+        };
+    }
+
+    public static String getComponentName(WindowMode windowMode) {
+        return switch (windowMode) {
+            case WINDOWED -> "vulkanmod.options.windowMode.windowed";
+            case WINDOWED_FULLSCREEN -> "vulkanmod.options.windowMode.windowedFullscreen";
+            case EXCLUSIVE_FULLSCREEN -> "options.fullscreen";
+        };
+    }
+}