一些优化

fixed issues with stencil testing

README.md

@@ -0,0 +1 @@
+Voxy is an LoD rendering mod for minecraft

build.gradle

@@ -1,5 +1,5 @@
 plugins {
-    id 'fabric-loom' version "1.11-SNAPSHOT"
+    id 'fabric-loom' version "1.14-SNAPSHOT"
     id 'maven-publish'
 }
 
@@ -24,6 +24,21 @@ repositories {
             includeGroup "maven.modrinth"
         }
     }
+
+    exclusiveContent {
+        forRepository {
+            maven {
+                name "caffeinemcRepository"
+                url "https://maven.caffeinemc.net/snapshots"
+            }
+        }
+        filter {
+            includeGroup "net.caffeinemc"
+        }
+    }
+
+
+
     maven { url = "https://maven.shedaniel.me/" }
     maven { url = "https://maven.terraformersmc.com/releases/" }
 
@@ -66,6 +81,7 @@ def gitCommitHash = { ->
 }
 
 def buildtime = {System.currentTimeSeconds()}
+
 processResources {
     def time = buildtime()
     def hash = gitCommitHash()
@@ -93,7 +109,7 @@ if (!isInGHA) {
 dependencies {
     // To change the versions see the gradle.properties file
     minecraft "com.mojang:minecraft:${project.minecraft_version}"
-    mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
+    mappings loom.officialMojangMappings()
     modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
 
 
@@ -104,36 +120,37 @@ dependencies {
 
     modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
 
-    //TODO: this is to eventually not need sodium installed as atm its just used for parsing shaders
+    if (true) {
-    modRuntimeOnlyMsk "maven.modrinth:sodium:mc1.21.8-0.7.0-fabric"
+        modImplementation "maven.modrinth:sodium:mc1.21.11-0.8.2-fabric"
-    modCompileOnly "maven.modrinth:sodium:mc1.21.8-0.7.0-fabric"
+    } else {
+        modImplementation "net.caffeinemc:sodium-fabric:0.8.2-SNAPSHOT+mc1.21.11+"
+    }
 
-    modImplementation("maven.modrinth:lithium:mc1.21.8-0.18.0-fabric")
+    modImplementation("maven.modrinth:lithium:mc1.21.11-0.21.0-fabric")
 
     //modRuntimeOnlyMsk "drouarb:nvidium:0.4.1-beta4:1.21.6@jar"
     modCompileOnly "drouarb:nvidium:0.4.1-beta4:1.21.6@jar"
 
-    modCompileOnly("maven.modrinth:modmenu:15.0.0-beta.3")
+    modCompileOnly("maven.modrinth:modmenu:17.0.0-alpha.1")
-    modRuntimeOnlyMsk("maven.modrinth:modmenu:15.0.0-beta.3")
+    modRuntimeOnlyMsk("maven.modrinth:modmenu:17.0.0-alpha.1")
 
-    modCompileOnly("maven.modrinth:iris:1.9.1+1.21.7-fabric")
+    modCompileOnly("maven.modrinth:iris:1.10.4+1.21.11-fabric")
-    //modRuntimeOnlyMsk("maven.modrinth:iris:1.9.1+1.21.7-fabric")
+    modRuntimeOnlyMsk("maven.modrinth:iris:1.10.4+1.21.11-fabric")
 
     //modCompileOnly("maven.modrinth:starlight:1.1.3+1.20.4")
 
     //modCompileOnly("maven.modrinth:immersiveportals:v5.1.7-mc1.20.4")
 
+    modCompileOnly("maven.modrinth:chunky:1.4.54-fabric")
+    //modRuntimeOnlyMsk("maven.modrinth:chunky:1.4.40-fabric")
 
-    modCompileOnly("maven.modrinth:chunky:1.4.40-fabric")
+    modRuntimeOnlyMsk("maven.modrinth:spark:1.10.152-fabric")
-    modRuntimeOnlyMsk("maven.modrinth:chunky:1.4.40-fabric")
-
-    modRuntimeOnlyMsk("maven.modrinth:spark:1.10.139-fabric")
     modRuntimeOnlyMsk("maven.modrinth:fabric-permissions-api:0.3.3")
     //modRuntimeOnly("maven.modrinth:nsight-loader:1.2.0")
 
     //modImplementation('io.github.douira:glsl-transformer:2.0.1')
 
-    modCompileOnly("maven.modrinth:vivecraft:1.21.1-1.1.14-b2-fabric")
+    modCompileOnly("maven.modrinth:vivecraft:1.21.9-1.3.2-fabric")
 
     modCompileOnly("maven.modrinth:flashback:rNCr1Rbs")
 }
@@ -141,14 +158,9 @@ dependencies {
 
 def targetJavaVersion = 21
 tasks.withType(JavaCompile).configureEach {
-    // ensure that the encoding is set to UTF-8, no matter what the system default is
-    // this fixes some edge cases with special characters not displaying correctly
-    // see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
-    // If Javadoc is generated, this must be specified in that task too.
     it.options.encoding = "UTF-8"
-    if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible()) {
+    it.options.release = targetJavaVersion
-        it.options.release = targetJavaVersion
+    it.options.deprecation = true
-    }
 }
 
 java {
@@ -233,19 +245,20 @@ dependencies {
 
     implementation "org.lwjgl:lwjgl"
     include(implementation "org.lwjgl:lwjgl-lmdb")
-    include(implementation "org.lwjgl:lwjgl-zstd")
+    //include(implementation "org.lwjgl:lwjgl-zstd")
     runtimeOnly "org.lwjgl:lwjgl:$lwjglVersion:natives-windows"
     runtimeOnly "org.lwjgl:lwjgl:$lwjglVersion:natives-linux"
     include(runtimeOnly "org.lwjgl:lwjgl-lmdb:$lwjglVersion:natives-windows")
-    include(runtimeOnly "org.lwjgl:lwjgl-zstd:$lwjglVersion:natives-windows")
+    //include(runtimeOnly "org.lwjgl:lwjgl-zstd:$lwjglVersion:natives-windows")
     include(runtimeOnly "org.lwjgl:lwjgl-lmdb:$lwjglVersion:natives-linux")
-    include(runtimeOnly "org.lwjgl:lwjgl-zstd:$lwjglVersion:natives-linux")
+    //include(runtimeOnly "org.lwjgl:lwjgl-zstd:$lwjglVersion:natives-linux")
 
     include(implementation 'redis.clients:jedis:5.1.0')
     include(implementation('org.rocksdb:rocksdbjni:10.2.1'))
     include(implementation 'org.apache.commons:commons-pool2:2.12.0')
     include(implementation 'org.lz4:lz4-java:1.8.0')
     include(implementation('org.tukaani:xz:1.10'))
+    include(implementation 'com.github.luben:zstd-jni:1.5.5-1')
 
     if (true) {
         if (!isInGHA) {
@@ -266,8 +279,9 @@ if (!isInGHA) {
     }
 
     dependencies {
-        modRuntimeOnly('me.djtheredstoner:DevAuth-fabric:1.1.0') {
+        /*
+        modRuntimeOnly('me.djtheredstoner:DevAuth-fabric:1.2.1') {
             exclude group: 'net.fabricmc', module: 'fabric-loader'
-        }
+        }*/
     }
 }

gradle.properties

@@ -7,15 +7,15 @@ org.gradle.daemon = false
 
 # Fabric Properties
 # check these on https://modmuss50.me/fabric.html
-minecraft_version=1.21.8
+minecraft_version=1.21.11
-yarn_mappings=1.21.8+build.1
+loader_version=0.18.2
-loader_version=0.16.14
+loom_version=1.14-SNAPSHOT
-loom_version=1.11-SNAPSHOT
 
 # Fabric API
-fabric_version=0.129.0+1.21.8
+fabric_version=0.140.2+1.21.11
+
 
 # Mod Properties
-mod_version = 0.2.5-alpha
+mod_version = 0.2.9-alpha
 maven_group = me.cortex
 archives_base_name = voxy

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/me/cortex/voxy/client/ClientImportManager.java

@@ -3,25 +3,24 @@ package me.cortex.voxy.client;
 import me.cortex.voxy.common.Logger;
 import me.cortex.voxy.commonImpl.ImportManager;
 import me.cortex.voxy.commonImpl.importers.IDataImporter;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.hud.ClientBossBar;
+import net.minecraft.client.gui.components.LerpingBossEvent;
-import net.minecraft.entity.boss.BossBar;
+import net.minecraft.network.chat.Component;
-import net.minecraft.text.Text;
+import net.minecraft.util.Mth;
-import net.minecraft.util.math.MathHelper;
+import net.minecraft.world.BossEvent;
-
 import java.util.UUID;
 
 public class ClientImportManager extends ImportManager {
     protected class ClientImportTask extends ImportTask {
         private final UUID bossbarUUID;
-        private final ClientBossBar bossBar;
+        private final LerpingBossEvent bossBar;
         protected ClientImportTask(IDataImporter importer) {
             super(importer);
 
-            this.bossbarUUID = MathHelper.randomUuid();
+            this.bossbarUUID = Mth.createInsecureUUID();
-            this.bossBar = new ClientBossBar(this.bossbarUUID, Text.of("Voxy world importer"), 0.0f, BossBar.Color.GREEN, BossBar.Style.PROGRESS, false, false, false);
+            this.bossBar = new LerpingBossEvent(this.bossbarUUID, Component.nullToEmpty("Voxy world importer"), 0.0f, BossEvent.BossBarColor.GREEN, BossEvent.BossBarOverlay.PROGRESS, false, false, false);
-            MinecraftClient.getInstance().execute(()->{
+            Minecraft.getInstance().execute(()->{
-                MinecraftClient.getInstance().inGameHud.getBossBarHud().bossBars.put(bossBar.getUuid(), bossBar);
+                Minecraft.getInstance().gui.getBossOverlay().events.put(bossBar.getId(), bossBar);
             });
         }
 
@@ -30,9 +29,9 @@ public class ClientImportManager extends ImportManager {
             if (!super.onUpdate(completed, outOf)) {
                 return false;
             }
-            MinecraftClient.getInstance().execute(()->{
+            Minecraft.getInstance().execute(()->{
-                this.bossBar.setPercent((float) (((double)completed) / ((double) Math.max(1, outOf))));
+                this.bossBar.setProgress((float) (((double)completed) / ((double) Math.max(1, outOf))));
-                this.bossBar.setName(Text.of("Voxy import: " + completed + "/" + outOf + " chunks"));
+                this.bossBar.setName(Component.nullToEmpty("Voxy import: " + completed + "/" + outOf + " chunks"));
             });
             return true;
         }
@@ -40,12 +39,12 @@ public class ClientImportManager extends ImportManager {
         @Override
         protected void onCompleted(int total) {
             super.onCompleted(total);
-            MinecraftClient.getInstance().execute(()->{
+            Minecraft.getInstance().execute(()->{
-                MinecraftClient.getInstance().inGameHud.getBossBarHud().bossBars.remove(this.bossbarUUID);
+                Minecraft.getInstance().gui.getBossOverlay().events.remove(this.bossbarUUID);
                 long delta = Math.max(System.currentTimeMillis() - this.startTime, 1);
 
                 String msg = "Voxy world import finished in " + (delta/1000) + " seconds, averaging " + (int)(total/(delta/1000f)) + " chunks per second";
-                MinecraftClient.getInstance().inGameHud.getChatHud().addMessage(Text.literal(msg));
+                Minecraft.getInstance().gui.getChat().addMessage(Component.literal(msg));
                 Logger.info(msg);
             });
         }

src/main/java/me/cortex/voxy/client/ICheekyClientChunkCache.java

@@ -0,0 +1,7 @@
+package me.cortex.voxy.client;
+
+import net.minecraft.world.level.chunk.LevelChunk;
+
+public interface ICheekyClientChunkCache {
+    LevelChunk voxy$cheekyGetChunk(int x, int z);
+}

src/main/java/me/cortex/voxy/client/ICheekyClientChunkManager.java

@@ -1,7 +0,0 @@
-package me.cortex.voxy.client;
-
-import net.minecraft.world.chunk.WorldChunk;
-
-public interface ICheekyClientChunkManager {
-    WorldChunk voxy$cheekyGetChunk(int x, int z);
-}

src/main/java/me/cortex/voxy/client/VoxyClient.java

@@ -1,5 +1,7 @@
 package me.cortex.voxy.client;
 
+import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
+import me.cortex.voxy.client.core.VoxyRenderSystem;
 import me.cortex.voxy.client.core.gl.Capabilities;
 import me.cortex.voxy.client.core.model.bakery.BudgetBufferRenderer;
 import me.cortex.voxy.client.core.rendering.util.SharedIndexBuffer;
@@ -8,19 +10,36 @@ import me.cortex.voxy.commonImpl.VoxyCommon;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.client.command.v2.ClientCommandRegistrationCallback;
 import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.components.debug.DebugScreenDisplayer;
+import net.minecraft.client.gui.components.debug.DebugScreenEntries;
+import net.minecraft.client.gui.components.debug.DebugScreenEntry;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.chunk.LevelChunk;
+import org.jspecify.annotations.Nullable;
 
 import java.util.HashSet;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import me.cortex.voxy.common.network.VoxyNetwork;
+import me.cortex.voxy.commonImpl.WorldIdentifier;
+
 public class VoxyClient implements ClientModInitializer {
     private static final HashSet<String> FREX = new HashSet<>();
 
-
     public static void initVoxyClient() {
         Capabilities.init();//Ensure clinit is called
 
-        boolean systemSupported = Capabilities.INSTANCE.compute && Capabilities.INSTANCE.indirectParameters;
+
+        if (Capabilities.INSTANCE.hasBrokenDepthSampler) {
+            Logger.error("AMD broken depth sampler detected, voxy does not work correctly and has been disabled, this will hopefully be fixed in the future");
+        }
+
+        boolean systemSupported = Capabilities.INSTANCE.compute && Capabilities.INSTANCE.indirectParameters && !Capabilities.INSTANCE.hasBrokenDepthSampler;
         if (systemSupported) {
 
             SharedIndexBuffer.INSTANCE.id();
@@ -39,6 +58,28 @@ public class VoxyClient implements ClientModInitializer {
 
     @Override
     public void onInitializeClient() {
+        DebugScreenEntries.register(Identifier.fromNamespaceAndPath("voxy", "version"), new DebugScreenEntry() {
+            @Override
+            public void display(DebugScreenDisplayer lines, @Nullable Level level, @Nullable LevelChunk levelChunk, @Nullable LevelChunk levelChunk2) {
+                if (!VoxyCommon.isAvailable()) {
+                    lines.addLine(ChatFormatting.RED + "voxy-"+VoxyCommon.MOD_VERSION);//Voxy installed, not avalible
+                    return;
+                }
+                var instance = VoxyCommon.getInstance();
+                if (instance == null) {
+                    lines.addLine(ChatFormatting.YELLOW + "voxy-" + VoxyCommon.MOD_VERSION);//Voxy avalible, no instance active
+                    return;
+                }
+                VoxyRenderSystem vrs = null;
+                var wr = Minecraft.getInstance().levelRenderer;
+                if (wr != null) vrs = ((IGetVoxyRenderSystem) wr).getVoxyRenderSystem();
+
+                //Voxy instance active
+                lines.addLine((vrs==null?ChatFormatting.DARK_GREEN:ChatFormatting.GREEN)+"voxy-"+VoxyCommon.MOD_VERSION);
+            }
+        });
+
+        DebugScreenEntries.register(Identifier.fromNamespaceAndPath("voxy","debug"), new VoxyDebugScreenEntry());
         ClientCommandRegistrationCallback.EVENT.register((dispatcher, registryAccess) -> {
             if (VoxyCommon.isAvailable()) {
                 dispatcher.register(VoxyCommands.register());
@@ -52,9 +93,50 @@ public class VoxyClient implements ClientModInitializer {
                 } else {
                     FREX.remove(name);
                 }}));
+
+        ClientPlayNetworking.registerGlobalReceiver(VoxyNetwork.ConfigSyncPayload.TYPE, (payload, context) -> {
+            context.client().execute(() -> {
+                 // Update client render distance cap if needed, or store server settings
+                 // For now, we can perhaps log it or update a transient config
+                 Logger.info("Received server view distance: " + payload.viewDistance());
+                 // We might want to clamp the local render distance to the server's max if strictly enforced,
+                 // or just use it as a hint for where to expect data.
+                 // The user requirement says: "server sends max view distance to client... client renders up to client setting, server updates outside sim distance up to server max"
+                 // So we should probably store this "server max view distance" somewhere in VoxyClientInstance.
+                 if (VoxyCommon.getInstance() instanceof VoxyClientInstance clientInstance) {
+                     clientInstance.setServerViewDistance(payload.viewDistance());
+                 }
+            });
+        });
+
+        ClientPlayNetworking.registerGlobalReceiver(VoxyNetwork.LodUpdatePayload.TYPE, (payload, context) -> {
+            // Deserialize off-thread if possible? Packet handling is on netty thread or main thread depending on configuration.
+            // But we can just schedule it.
+            // Actually deserialize needs Mapper which is world specific?
+            // The packet doesn't contain world ID?
+            // We assume it's for the current client world.
+            
+            // Wait, we need to know WHICH world this update is for if we have dimensions?
+            // Usually packets are for the current world the player is in.
+            
+            context.client().execute(() -> {
+                 // Logger.info("Received LOD update packet, size: " + payload.data().length);
+                 if (VoxyCommon.getInstance() instanceof VoxyClientInstance clientInstance) {
+                     clientInstance.handleLodUpdate(payload);
+                 }
+            });
+        });
     }
 
     public static boolean isFrexActive() {
         return !FREX.isEmpty();
     }
+
+    public static int getOcclusionDebugState() {
+        return 0;
+    }
+
+    public static boolean disableSodiumChunkRender() {
+        return false;// getOcclusionDebugState() != 0;
+    }
 }

src/main/java/me/cortex/voxy/client/VoxyClientInstance.java

@@ -1,8 +1,10 @@
 package me.cortex.voxy.client;
 
 import me.cortex.voxy.client.compat.FlashbackCompat;
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
+import me.cortex.voxy.client.mixin.sodium.AccessorSodiumWorldRenderer;
 import me.cortex.voxy.common.Logger;
+import me.cortex.voxy.common.StorageConfigUtil;
 import me.cortex.voxy.common.config.ConfigBuildCtx;
 import me.cortex.voxy.common.config.Serialization;
 import me.cortex.voxy.common.config.compressors.ZSTDCompressor;
@@ -14,9 +16,9 @@ import me.cortex.voxy.common.config.storage.rocksdb.RocksDBStorageBackend;
 import me.cortex.voxy.commonImpl.ImportManager;
 import me.cortex.voxy.commonImpl.VoxyInstance;
 import me.cortex.voxy.commonImpl.WorldIdentifier;
-import net.minecraft.client.MinecraftClient;
+import net.caffeinemc.mods.sodium.client.render.SodiumWorldRenderer;
-import net.minecraft.util.WorldSavePath;
+import net.minecraft.client.Minecraft;
-
+import net.minecraft.world.level.storage.LevelResource;
 import java.nio.file.Files;
 import java.nio.file.Path;
 
@@ -26,15 +28,83 @@ public class VoxyClientInstance extends VoxyInstance {
     private final SectionStorageConfig storageConfig;
     private final Path basePath;
     private final boolean noIngestOverride;
+    private int serverViewDistance = 32;
+
     public VoxyClientInstance() {
-        super(VoxyConfig.CONFIG.serviceThreads);
+        super();
         var path = FlashbackCompat.getReplayStoragePath();
         this.noIngestOverride = path != null;
         if (path == null) {
             path = getBasePath();
         }
         this.basePath = path;
-        this.storageConfig = getCreateStorageConfig(path);
+        this.storageConfig = StorageConfigUtil.getCreateStorageConfig(Config.class, c->c.version==1&&c.sectionStorageConfig!=null, ()->DEFAULT_STORAGE_CONFIG, path).sectionStorageConfig;
+        this.updateDedicatedThreads();
+    }
+
+    public long getLastLodUpdate() {
+        return lastLodUpdate;
+    }
+
+    public int getLodUpdatesReceived() {
+        return lodUpdatesReceived;
+    }
+
+    public void setServerViewDistance(int distance) {
+        this.serverViewDistance = distance;
+        // Trigger a re-evaluation of render distance?
+        Logger.info("Updating client view distance from server to: " + distance);
+    }
+    
+    public int getServerViewDistance() {
+        return this.serverViewDistance;
+    }
+    
+    private long lastLodUpdate;
+    private int lodUpdatesReceived;
+
+    public void handleLodUpdate(me.cortex.voxy.common.network.VoxyNetwork.LodUpdatePayload payload) {
+        this.lastLodUpdate = System.currentTimeMillis();
+        this.lodUpdatesReceived++;
+        // 1. Get current client world
+        var player = Minecraft.getInstance().player;
+        if (player == null) return;
+        var level = player.level();
+        var wi = WorldIdentifier.of(level);
+        if (wi == null) return;
+        
+        var engine = this.getNullable(wi);
+        if (engine == null) return;
+        
+        // 2. Deserialize payload using engine's mapper
+        // Note: Payload deserialization requires Mapper to resolve IDs.
+        // We need to ensure the engine's mapper is up to date with the server's palette?
+        // No, the payload contains palette strings/states.
+        // The deserializer maps them to LOCAL IDs using the provided mapper.
+        
+        try {
+            var section = payload.deserialize(engine.getMapper());
+            // 3. Insert update into engine
+            me.cortex.voxy.common.world.WorldUpdater.insertUpdate(engine, section);
+        } catch (Exception e) {
+            Logger.error("Failed to handle LOD update", e);
+        }
+    }
+
+    @Override
+    public void updateDedicatedThreads() {
+        int target = VoxyConfig.CONFIG.serviceThreads;
+        if (!VoxyConfig.CONFIG.dontUseSodiumBuilderThreads) {
+            var swr = SodiumWorldRenderer.instanceNullable();
+            if (swr != null) {
+                var rsm = ((AccessorSodiumWorldRenderer) swr).getRenderSectionManager();
+                if (rsm != null) {
+                    this.setNumThreads(Math.max(1, target - rsm.getBuilder().getTotalThreadCount()));
+                    return;
+                }
+            }
+        }
+        this.setNumThreads(target);
     }
 
     @Override
@@ -51,90 +121,39 @@ public class VoxyClientInstance extends VoxyInstance {
         return this.storageConfig.build(ctx);
     }
 
-    public static SectionStorageConfig getCreateStorageConfig(Path path) {
-        try {
-            Files.createDirectories(path);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-        var json = path.resolve("config.json");
-        Config config = null;
-        if (Files.exists(json)) {
-            try {
-                config = Serialization.GSON.fromJson(Files.readString(json), Config.class);
-                if (config == null) {
-                    Logger.error("Config deserialization null, reverting to default");
-                } else {
-                    if (config.sectionStorageConfig == null) {
-                        Logger.error("Config section storage null, reverting to default");
-                        config = null;
-                    }
-                }
-            } catch (Exception e) {
-                Logger.error("Failed to load the storage configuration file, resetting it to default, this will probably break your save if you used a custom storage config", e);
-            }
-        }
-
-        if (config == null) {
-            config = DEFAULT_STORAGE_CONFIG;
-        }
-        try {
-            Files.writeString(json, Serialization.GSON.toJson(config));
-        } catch (Exception e) {
-            throw new RuntimeException("Failed write the config, aborting!", e);
-        }
-        if (config == null) {
-            throw new IllegalStateException("Config is still null\n");
-        }
-        return config.sectionStorageConfig;
-    }
-
     public Path getStorageBasePath() {
         return this.basePath;
     }
 
     @Override
     public boolean isIngestEnabled(WorldIdentifier worldId) {
-        return !this.noIngestOverride;
+        return (!this.noIngestOverride) && VoxyConfig.CONFIG.ingestEnabled;
     }
 
     private static class Config {
         public int version = 1;
         public SectionStorageConfig sectionStorageConfig;
     }
+
     private static final Config DEFAULT_STORAGE_CONFIG;
     static {
         var config = new Config();
-
+        config.sectionStorageConfig = StorageConfigUtil.createDefaultSerializer();
-        //Load the default config
-        var baseDB = new RocksDBStorageBackend.Config();
-
-        var compressor = new ZSTDCompressor.Config();
-        compressor.compressionLevel = 1;
-
-        var compression = new CompressionStorageAdaptor.Config();
-        compression.delegate = baseDB;
-        compression.compressor = compressor;
-
-        var serializer = new SectionSerializationStorage.Config();
-        serializer.storage = compression;
-        config.sectionStorageConfig = serializer;
-
         DEFAULT_STORAGE_CONFIG = config;
     }
 
     private static Path getBasePath() {
-        Path basePath = MinecraftClient.getInstance().runDirectory.toPath().resolve(".voxy").resolve("saves");
+        Path basePath = Minecraft.getInstance().gameDirectory.toPath().resolve(".voxy").resolve("saves");
-        var iserver = MinecraftClient.getInstance().getServer();
+        var iserver = Minecraft.getInstance().getSingleplayerServer();
         if (iserver != null) {
-            basePath = iserver.getSavePath(WorldSavePath.ROOT).resolve("voxy");
+            basePath = iserver.getWorldPath(LevelResource.ROOT).resolve("voxy");
         } else {
-            var netHandle = MinecraftClient.getInstance().interactionManager;
+            var netHandle = Minecraft.getInstance().gameMode;
             if (netHandle == null) {
                 Logger.error("Network handle null");
                 basePath = basePath.resolve("UNKNOWN");
             } else {
-                var info = netHandle.networkHandler.getServerInfo();
+                var info = netHandle.connection.getServerData();
                 if (info == null) {
                     Logger.error("Server info null");
                     basePath = basePath.resolve("UNKNOWN");
@@ -142,7 +161,7 @@ public class VoxyClientInstance extends VoxyInstance {
                     if (info.isRealm()) {
                         basePath = basePath.resolve("realms");
                     } else {
-                        basePath = basePath.resolve(info.address.replace(":", "_"));
+                        basePath = basePath.resolve(info.ip.replace(":", "_"));
                     }
                 }
             }

src/main/java/me/cortex/voxy/client/VoxyCommands.java

@@ -6,21 +6,27 @@ import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.suggestion.Suggestions;
 import com.mojang.brigadier.suggestion.SuggestionsBuilder;
 import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
+import me.cortex.voxy.common.Logger;
 import me.cortex.voxy.commonImpl.VoxyCommon;
 import me.cortex.voxy.commonImpl.WorldIdentifier;
 import me.cortex.voxy.commonImpl.importers.DHImporter;
 import me.cortex.voxy.commonImpl.importers.WorldImporter;
 import net.fabricmc.fabric.api.client.command.v2.ClientCommandManager;
 import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
-import net.minecraft.command.CommandSource;
+import net.minecraft.commands.SharedSuggestionProvider;
-import net.minecraft.text.PlainTextContent;
+import net.minecraft.core.registries.BuiltInRegistries;
-import net.minecraft.text.Text;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.world.level.dimension.DimensionType;
 
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Locale;
 import java.util.concurrent.CompletableFuture;
 
 
@@ -63,19 +69,20 @@ public class VoxyCommands {
     private static int reloadInstance(CommandContext<FabricClientCommandSource> ctx) {
         var instance = (VoxyClientInstance)VoxyCommon.getInstance();
         if (instance == null) {
-            ctx.getSource().sendError(Text.translatable("Voxy must be enabled in settings to use this"));
+            ctx.getSource().sendError(Component.translatable("Voxy must be enabled in settings to use this"));
             return 1;
         }
-        var wr = MinecraftClient.getInstance().worldRenderer;
+        var wr = Minecraft.getInstance().levelRenderer;
         if (wr!=null) {
             ((IGetVoxyRenderSystem)wr).shutdownRenderer();
         }
 
         VoxyCommon.shutdownInstance();
+        System.gc();
         VoxyCommon.createInstance();
-        if (wr!=null) {
+
-            ((IGetVoxyRenderSystem)wr).createRenderer();
+        var r = Minecraft.getInstance().levelRenderer;
-        }
+        if (r != null) r.allChanged();
         return 0;
     }
 
@@ -85,7 +92,7 @@ public class VoxyCommands {
     private static int importDistantHorizons(CommandContext<FabricClientCommandSource> ctx) {
         var instance = (VoxyClientInstance)VoxyCommon.getInstance();
         if (instance == null) {
-            ctx.getSource().sendError(Text.translatable("Voxy must be enabled in settings to use this"));
+            ctx.getSource().sendError(Component.translatable("Voxy must be enabled in settings to use this"));
             return 1;
         }
         var dbFile = new File(ctx.getArgument("sqlDbPath", String.class));
@@ -100,10 +107,10 @@ public class VoxyCommands {
         }
 
         File dbFile_ = dbFile;
-        var engine = WorldIdentifier.ofEngine(MinecraftClient.getInstance().world);
+        var engine = WorldIdentifier.ofEngine(Minecraft.getInstance().level);
         if (engine==null)return 1;
         return instance.getImportManager().makeAndRunIfNone(engine, ()->
-                new DHImporter(dbFile_, engine, MinecraftClient.getInstance().world, instance.getThreadPool(), instance.savingServiceRateLimiter))?0:1;
+                new DHImporter(dbFile_, engine, Minecraft.getInstance().level, instance.getServiceManager(), instance.savingServiceRateLimiter))?0:1;
     }
 
     private static boolean fileBasedImporter(File directory) {
@@ -112,10 +119,10 @@ public class VoxyCommands {
             return false;
         }
 
-        var engine = WorldIdentifier.ofEngine(MinecraftClient.getInstance().world);
+        var engine = WorldIdentifier.ofEngine(Minecraft.getInstance().level);
         if (engine==null) return false;
         return instance.getImportManager().makeAndRunIfNone(engine, ()->{
-            var importer = new WorldImporter(engine, MinecraftClient.getInstance().world, instance.getThreadPool(), instance.savingServiceRateLimiter);
+            var importer = new WorldImporter(engine, Minecraft.getInstance().level, instance.getServiceManager(), instance.savingServiceRateLimiter);
             importer.importRegionDirectoryAsync(directory);
             return importer;
         });
@@ -123,7 +130,7 @@ public class VoxyCommands {
 
     private static int importRaw(CommandContext<FabricClientCommandSource> ctx) {
         if (VoxyCommon.getInstance() == null) {
-            ctx.getSource().sendError(Text.translatable("Voxy must be enabled in settings to use this"));
+            ctx.getSource().sendError(Component.translatable("Voxy must be enabled in settings to use this"));
             return 1;
         }
 
@@ -132,7 +139,7 @@ public class VoxyCommands {
 
     private static int importBobby(CommandContext<FabricClientCommandSource> ctx) {
         if (VoxyCommon.getInstance() == null) {
-            ctx.getSource().sendError(Text.translatable("Voxy must be enabled in settings to use this"));
+            ctx.getSource().sendError(Component.translatable("Voxy must be enabled in settings to use this"));
             return 1;
         }
 
@@ -141,10 +148,10 @@ public class VoxyCommands {
     }
 
     private static CompletableFuture<Suggestions> importWorldSuggester(CommandContext<FabricClientCommandSource> ctx, SuggestionsBuilder sb) {
-        return fileDirectorySuggester(MinecraftClient.getInstance().runDirectory.toPath().resolve("saves"), sb);
+        return fileDirectorySuggester(Minecraft.getInstance().gameDirectory.toPath().resolve("saves"), sb);
     }
     private static CompletableFuture<Suggestions> importBobbySuggester(CommandContext<FabricClientCommandSource> ctx, SuggestionsBuilder sb) {
-        return fileDirectorySuggester(MinecraftClient.getInstance().runDirectory.toPath().resolve(".bobby"), sb);
+        return fileDirectorySuggester(Minecraft.getInstance().gameDirectory.toPath().resolve(".bobby"), sb);
     }
 
     private static CompletableFuture<Suggestions> fileDirectorySuggester(Path dir, SuggestionsBuilder sb) {
@@ -179,7 +186,7 @@ public class VoxyCommands {
                 if (wn.equals(remaining)) {
                     continue;
                 }
-                if (CommandSource.shouldSuggest(remaining, wn) || CommandSource.shouldSuggest(remaining, '"'+wn)) {
+                if (SharedSuggestionProvider.matchesSubStr(remaining, wn) || SharedSuggestionProvider.matchesSubStr(remaining, '"'+wn)) {
                     wn = str+wn + "/";
                     sb.suggest(StringArgumentType.escapeIfRequired(wn));
                 }
@@ -191,20 +198,41 @@ public class VoxyCommands {
 
     private static int importWorld(CommandContext<FabricClientCommandSource> ctx) {
         if (VoxyCommon.getInstance() == null) {
-            ctx.getSource().sendError(Text.translatable("Voxy must be enabled in settings to use this"));
+            ctx.getSource().sendError(Component.translatable("Voxy must be enabled in settings to use this"));
             return 1;
         }
 
         var name = ctx.getArgument("world_name", String.class);
         var file = new File("saves").toPath().resolve(name);
-        name = name.toLowerCase();
+        name = name.toLowerCase(Locale.ROOT);
         if (name.endsWith("/")) {
             name = name.substring(0, name.length()-1);
         }
-        if (!(name.endsWith("region"))) {
+        if (file.resolve("level.dat").toFile().exists()) {
-            file = file.resolve("region");
+            var dimFile = DimensionType.getStorageFolder(Minecraft.getInstance().level.dimension(), file)
+                    .resolve("region")
+                    .toFile();
+            if (!dimFile.isDirectory()) return 1;
+            return fileBasedImporter(dimFile)?0:1;
+            //We are in a world directory, so import the current dimension we are in
+            /*
+            for (var dim : new String[]{"overworld", "the_nether", "the_end"}) {//This is so annoying that you cant loop through all the dimensions
+                var id = ResourceKey.create(Registries.DIMENSION, Identifier.withDefaultNamespace(dim));
+                var dimPath = DimensionType.getStorageFolder(id, file);
+                dimPath = dimPath.resolve("region");
+                var dimFile = dimPath.toFile();
+                if (dimFile.isDirectory()) {//exists and is a directory
+                    if (!fileBasedImporter(dimFile)) {
+                        Logger.error("Failed to import dimension: " + id);
+                    }
+                }
+            }*/
+        } else {
+            if (!(name.endsWith("region"))) {
+                file = file.resolve("region");
+            }
+            return fileBasedImporter(file.toFile()) ? 0 : 1;
         }
-        return fileBasedImporter(file.toFile())?0:1;
     }
 
     private static int importZip(CommandContext<FabricClientCommandSource> ctx) {
@@ -216,15 +244,15 @@ public class VoxyCommands {
 
         var instance = (VoxyClientInstance)VoxyCommon.getInstance();
         if (instance == null) {
-            ctx.getSource().sendError(Text.translatable("Voxy must be enabled in settings to use this"));
+            ctx.getSource().sendError(Component.translatable("Voxy must be enabled in settings to use this"));
             return 1;
         }
         String finalInnerDir = innerDir;
 
-        var engine = WorldIdentifier.ofEngine(MinecraftClient.getInstance().world);
+        var engine = WorldIdentifier.ofEngine(Minecraft.getInstance().level);
         if (engine != null) {
             return instance.getImportManager().makeAndRunIfNone(engine, () -> {
-                var importer = new WorldImporter(engine, MinecraftClient.getInstance().world, instance.getThreadPool(), instance.savingServiceRateLimiter);
+                var importer = new WorldImporter(engine, Minecraft.getInstance().level, instance.getServiceManager(), instance.savingServiceRateLimiter);
                 importer.importZippedRegionDirectoryAsync(zip, finalInnerDir);
                 return importer;
             }) ? 0 : 1;
@@ -235,10 +263,10 @@ public class VoxyCommands {
     private static int cancelImport(CommandContext<FabricClientCommandSource> ctx) {
         var instance = (VoxyClientInstance)VoxyCommon.getInstance();
         if (instance == null) {
-            ctx.getSource().sendError(Text.translatable("Voxy must be enabled in settings to use this"));
+            ctx.getSource().sendError(Component.translatable("Voxy must be enabled in settings to use this"));
             return 1;
         }
-        var world = WorldIdentifier.ofEngineNullable(MinecraftClient.getInstance().world);
+        var world = WorldIdentifier.ofEngineNullable(Minecraft.getInstance().level);
         if (world != null) {
             return instance.getImportManager().cancelImport(world)?0:1;
         }

src/main/java/me/cortex/voxy/client/VoxyDebugScreenEntry.java

@@ -0,0 +1,47 @@
+package me.cortex.voxy.client;
+
+import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
+import me.cortex.voxy.client.core.VoxyRenderSystem;
+import me.cortex.voxy.commonImpl.VoxyCommon;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.components.debug.DebugScreenDisplayer;
+import net.minecraft.client.gui.components.debug.DebugScreenEntry;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.chunk.LevelChunk;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class VoxyDebugScreenEntry implements DebugScreenEntry {
+    @Override
+    public void display(DebugScreenDisplayer lines, @Nullable Level world, @Nullable LevelChunk clientChunk, @Nullable LevelChunk chunk) {
+        if (!VoxyCommon.isAvailable()) {
+            return;
+        }
+
+        var instance = VoxyCommon.getInstance();
+        if (instance == null) {
+            return;
+        }
+
+        VoxyRenderSystem vrs = null;
+        var wr = Minecraft.getInstance().levelRenderer;
+        if (wr != null) vrs = ((IGetVoxyRenderSystem) wr).getVoxyRenderSystem();
+
+        //lines.addLineToSection();
+        List<String> instanceLines = new ArrayList<>();
+        instance.addDebug(instanceLines);
+        lines.addToGroup(Identifier.fromNamespaceAndPath("voxy", "instance_debug"), instanceLines);
+
+        if (vrs != null) {
+            List<String> renderLines = new ArrayList<>();
+            vrs.addDebugInfo(renderLines);
+            lines.addToGroup(Identifier.fromNamespaceAndPath("voxy", "render_debug"), renderLines);
+        }
+    }
+
+
+}

src/main/java/me/cortex/voxy/client/compat/FlashbackCompat.java

@@ -6,7 +6,6 @@ import com.moulberry.flashback.record.FlashbackMeta;
 import me.cortex.voxy.common.Logger;
 import me.cortex.voxy.common.config.section.SectionStorageConfig;
 import net.fabricmc.loader.api.FabricLoader;
-import org.apache.commons.logging.Log;
 
 import java.nio.file.Path;
 

src/main/java/me/cortex/voxy/client/compat/SemaphoreBlockImpersonator.java

@@ -0,0 +1,33 @@
+package me.cortex.voxy.client.compat;
+
+import me.cortex.voxy.common.thread.MultiThreadPrioritySemaphore;
+
+import java.util.concurrent.Semaphore;
+
+public class SemaphoreBlockImpersonator extends Semaphore {
+    private final MultiThreadPrioritySemaphore.Block block;
+    public SemaphoreBlockImpersonator(MultiThreadPrioritySemaphore.Block block) {
+        super(0);
+        this.block = block;
+    }
+
+    @Override
+    public void release(int permits) {
+        this.block.release(permits);
+    }
+
+    @Override
+    public void acquire() throws InterruptedException {
+        this.block.acquire();
+    }
+
+    @Override
+    public boolean tryAcquire() {
+        return this.block.tryAcquire();
+    }
+
+    @Override
+    public int availablePermits() {
+        return this.block.availablePermits();
+    }
+}

src/main/java/me/cortex/voxy/client/config/IConfigPageSetter.java

@@ -0,0 +1,8 @@
+package me.cortex.voxy.client.config;
+
+import net.caffeinemc.mods.sodium.client.config.structure.OptionPage;
+import net.caffeinemc.mods.sodium.client.config.structure.Page;
+
+public interface IConfigPageSetter {
+    void voxy$setPageJump(OptionPage page);
+}

src/main/java/me/cortex/voxy/client/config/ModMenuIntegration.java

@@ -4,25 +4,18 @@ import com.terraformersmc.modmenu.api.ConfigScreenFactory;
 import com.terraformersmc.modmenu.api.ModMenuApi;
 import me.cortex.voxy.common.Logger;
 import me.cortex.voxy.commonImpl.VoxyCommon;
-import net.caffeinemc.mods.sodium.client.gui.SodiumOptionsGUI;
+import net.caffeinemc.mods.sodium.client.config.ConfigManager;
+import net.caffeinemc.mods.sodium.client.config.structure.OptionPage;
+import net.caffeinemc.mods.sodium.client.gui.VideoSettingsScreen;
 
 public class ModMenuIntegration implements ModMenuApi {
     @Override
     public ConfigScreenFactory<?> getModConfigScreenFactory() {
         return parent -> {
             if (VoxyCommon.isAvailable()) {
-                var screen = (SodiumOptionsGUI) SodiumOptionsGUI.createScreen(parent);
+                var screen = (VideoSettingsScreen)VideoSettingsScreen.createScreen(parent);
-                //Sorry jelly and douira, please dont hurt me
+                var page = (OptionPage) ConfigManager.CONFIG.getModOptions().stream().filter(a->a.configId().equals("voxy")).findFirst().get().pages().get(0);
-                try {
+                ((IConfigPageSetter)screen).voxy$setPageJump(page);
-                    //We cant use .setPage() as that invokes rebuildGui, however the screen hasnt been initalized yet
-                    // causing things to crash
-                    var field = SodiumOptionsGUI.class.getDeclaredField("currentPage");
-                    field.setAccessible(true);
-                    field.set(screen, VoxyConfigScreenPages.voxyOptionPage);
-                    field.setAccessible(false);
-                } catch (Exception e) {
-                    Logger.error("Failed to set the current page to voxy", e);
-                }
                 return screen;
             } else {
                 return null;

src/main/java/me/cortex/voxy/client/config/SodiumConfigBuilder.java

@@ -0,0 +1,326 @@
+package me.cortex.voxy.client.config;
+
+import me.cortex.voxy.common.util.Pair;
+import net.caffeinemc.mods.sodium.api.config.ConfigState;
+import net.caffeinemc.mods.sodium.api.config.StorageEventHandler;
+import net.caffeinemc.mods.sodium.api.config.option.*;
+import net.caffeinemc.mods.sodium.api.config.structure.*;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.resources.Identifier;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.function.*;
+
+public class SodiumConfigBuilder {
+
+    private static record Enabler(Predicate<ConfigState> tester, Identifier[] dependencies) {
+        public Enabler(Predicate<ConfigState> tester, String[] dependencies) {
+            this(tester, mapIds(dependencies));
+        }
+    }
+
+    public abstract static class Enableable <TYPE extends Enableable<TYPE>> {
+        private @Nullable Enabler prevEnabler;
+        protected @Nullable Enabler enabler;
+
+        private TYPE setEnabler0(Enabler enabler) {
+            this.prevEnabler = this.enabler;
+            this.enabler = enabler;
+            {
+                var children = this.getEnablerChildren();
+                if (children != null) {
+                    for (var child : children) {
+                        if (child.enabler == null || child.enabler == this.prevEnabler) {
+                            child.setEnabler0(this.enabler);
+                        }
+                    }
+                }
+            }
+
+            return (TYPE) this;
+        }
+
+        public TYPE setEnabler(Predicate<ConfigState> enabler, String... dependencies) {
+            return this.setEnabler0(new Enabler(enabler, dependencies));
+        }
+
+        public TYPE setEnabler(String enabler) {
+            if (enabler == null) {
+                return this.setEnabler(s->true);
+            }
+            var id = Identifier.parse(enabler);
+            return this.setEnabler(s->s.readBooleanOption(id), enabler);
+        }
+
+        public TYPE setEnablerAND(String... enablers) {
+            var enablersId = mapIds(enablers);
+            return this.setEnabler0(new Enabler(s->{
+                for (var id : enablersId) {
+                    if (!s.readBooleanOption(id)) {
+                        return false;
+                    }
+                }
+                return true;
+            }, enablersId));
+        }
+
+        protected Enableable[] getEnablerChildren() {
+            return null;
+        }
+    }
+
+    public static class Page extends Enableable<Page> {
+        protected Component name;
+        protected Group[] groups;
+        public Page(Component name, Group... groups) {
+            this.name = name;
+            this.groups = groups;
+        }
+
+        protected OptionPageBuilder create(ConfigBuilder builder, BuildCtx ctx) {
+            var page = builder.createOptionPage();
+            page.setName(this.name);
+            for (var group : this.groups) {
+                page.addOptionGroup(group.create(builder, ctx));
+            }
+            return page;
+        }
+
+        @Override
+        protected Enableable[] getEnablerChildren() {
+            return this.groups;
+        }
+    }
+
+    public static class Group extends Enableable<Group> {
+        protected Option[] options;
+        public Group(Option... options) {
+            this.options = options;
+        }
+
+        protected OptionGroupBuilder create(ConfigBuilder builder, BuildCtx ctx) {
+            var group = builder.createOptionGroup();
+            for (var option : this.options) {
+                group.addOption(option.create(builder, ctx));
+            }
+            return group;
+        }
+
+        @Override
+        protected Enableable[] getEnablerChildren() {
+            return this.options;
+        }
+    }
+
+    public static abstract class Option <TYPE, OPTION extends Option<TYPE,OPTION,STYPE>, STYPE extends StatefulOptionBuilder<TYPE>> extends Enableable<Option<TYPE,OPTION,STYPE>> {
+        //Setter returns a post save update set
+        protected String id;
+        protected Component name;
+        protected Component tooltip;
+        protected Supplier<TYPE> getter;
+        protected Consumer<TYPE> setter;
+        public Option(String id, Component name, Component tooltip, Supplier<TYPE> getter, Consumer<TYPE> setter) {
+            this.id = id;
+            this.name = name;
+            this.tooltip = tooltip;
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        public Option(String id, Component name, Supplier<TYPE> getter, Consumer<TYPE> setter) {
+            this.id = id;
+            this.name = name;
+            this.getter = getter;
+            this.setter = setter;
+            if (name.getContents() instanceof TranslatableContents tc) {
+                this.tooltip = Component.translatable(tc.getKey() + ".tooltip");
+            } else {
+                this.tooltip = name;
+            }
+        }
+
+
+        protected Consumer<TYPE> postRunner;
+        protected Identifier[] postRunnerConflicts;
+        protected Identifier[] postChangeFlags;
+        public OPTION setPostChangeRunner(Consumer<TYPE> postRunner, String... dontRunIfChangedVars) {
+            this.postRunner = postRunner;
+            this.postRunnerConflicts = mapIds(dontRunIfChangedVars);
+            return (OPTION) this;
+        }
+
+        public OPTION setPostChangeFlags(String... flags) {
+            this.postChangeFlags = mapIds(flags);
+            return (OPTION) this;
+        }
+
+        protected abstract STYPE createType(ConfigBuilder builder);
+
+        protected STYPE create(ConfigBuilder builder, BuildCtx ctx) {
+            var option = this.createType(builder);
+            option.setName(this.name);
+            option.setTooltip(this.tooltip);
+
+            Set<Identifier> flags = new LinkedHashSet<>();
+            if (this.postRunner != null) {
+                var id = Identifier.parse(this.id);
+                var runner = this.postRunner;
+                var getter = this.getter;
+                ctx.postRunner.register(id, ()->runner.accept(getter.get()), this.postRunnerConflicts);
+                flags.add(id);
+            }
+
+            if (this.postChangeFlags != null) {
+                flags.addAll(List.of(this.postChangeFlags));
+            }
+
+            if (!flags.isEmpty()) {
+                option.setFlags(flags.toArray(Identifier[]::new));
+            }
+
+            option.setBinding(this.setter, this.getter);
+            if (this.enabler != null) {
+                var pred = this.enabler.tester;
+                option.setEnabledProvider(s->pred.test(s), this.enabler.dependencies);
+            }
+
+            option.setStorageHandler(ctx.saveHandler);
+
+            option.setDefaultValue(this.getter.get());
+
+            return option;
+        }
+    }
+
+    public static class IntOption extends Option<Integer, IntOption, IntegerOptionBuilder> {
+        protected Function<ConfigState, Range> rangeProvider;
+        protected String[] rangeDependencies;
+        protected ControlValueFormatter formatter = v->Component.literal(Integer.toString(v));
+
+        public IntOption(String id, Component name, Component tooltip, Supplier<Integer> getter, Consumer<Integer> setter, Range range) {
+            super(id, name, tooltip, getter, setter);
+            this.rangeProvider = s->range;
+        }
+
+        public IntOption(String id, Component name, Supplier<Integer> getter, Consumer<Integer> setter, Range range) {
+            super(id, name, getter, setter);
+            this.rangeProvider = s->range;
+        }
+
+        public IntOption setFormatter(IntFunction<Component> formatter) {
+            this.formatter = v->formatter.apply(v);
+            return this;
+        }
+
+        @Override
+        protected IntegerOptionBuilder createType(ConfigBuilder builder) {
+            return builder.createIntegerOption(Identifier.parse(this.id));
+        }
+
+        @Override
+        protected IntegerOptionBuilder create(ConfigBuilder builder, BuildCtx ctx) {
+            var option = super.create(builder, ctx);
+            if (this.rangeDependencies == null || this.rangeDependencies.length == 0) {
+                option.setRange(this.rangeProvider.apply(null));
+            } else {
+                option.setRangeProvider((Function<ConfigState, SteppedValidator>)(Object) this.rangeProvider, mapIds(this.rangeDependencies));
+            }
+            option.setValueFormatter(this.formatter);
+            return option;
+        }
+    }
+
+    public static class BoolOption extends Option<Boolean, BoolOption, BooleanOptionBuilder> {
+        public BoolOption(String id, Component name, Component tooltip, Supplier<Boolean> getter, Consumer<Boolean> setter) {
+            super(id, name, tooltip, getter, setter);
+        }
+
+        public BoolOption(String id, Component name, Supplier<Boolean> getter, Consumer<Boolean> setter) {
+            super(id, name, getter, setter);
+        }
+
+        @Override
+        protected BooleanOptionBuilder createType(ConfigBuilder builder) {
+            return builder.createBooleanOption(Identifier.parse(this.id));
+        }
+    }
+
+    private static <F,T> T[] map(F[] from, Function<F,T> mapper, Function<Integer,T[]> factory) {
+        T[] arr = factory.apply(from.length);
+        for (int i = 0; i < from.length; i++) {
+            arr[i] = mapper.apply(from[i]);
+        }
+        return arr;
+    }
+
+    private static Identifier[] mapIds(String[] strings) {
+        return map(strings, Identifier::parse, Identifier[]::new);
+    }
+
+
+    public static class PostApplyOps implements FlagHook {
+        private record Hook(Identifier name, Runnable runnable, Set<Identifier> conflicts) {}
+        private Map<Identifier, Hook> hooks = new LinkedHashMap<>();
+
+        public PostApplyOps register(String name, Runnable postRunner, String... conflicts) {
+            return this.register(Identifier.parse(name), postRunner, mapIds(conflicts));
+        }
+
+        public PostApplyOps register(Identifier name, Runnable postRunner, Identifier... conflicts) {
+            this.hooks.put(name, new Hook(name, postRunner, new LinkedHashSet<>(List.of(conflicts))));
+            return this;
+        }
+
+        protected PostApplyOps build() {
+            boolean changed = false;
+            do {
+                changed = false;
+                for (var hook : this.hooks.values()) {
+                    for (var ref : new LinkedHashSet<>(hook.conflicts)) {
+                        var other = this.hooks.getOrDefault(ref, null);
+                        if (other != null) {
+                            changed |= hook.conflicts.addAll(other.conflicts);
+                        }
+                    }
+                }
+            } while (changed);
+
+            return this;
+        }
+
+        @Override
+        public Collection<Identifier> getTriggers() {
+            return this.hooks.keySet();
+        }
+
+        @Override
+        public void accept(Collection<Identifier> identifiers, ConfigState configState) {
+            for (var id : identifiers) {
+                var hook = this.hooks.get(id);
+                if (hook != null) {
+                    if (Collections.disjoint(identifiers, hook.conflicts)) {
+                        hook.runnable.run();
+                    }
+                }
+            }
+        }
+    }
+
+
+    private static final class BuildCtx {
+        public PostApplyOps postRunner = new PostApplyOps();
+        public StorageEventHandler saveHandler;
+    }
+
+    public static void buildToSodium(ConfigBuilder builder, ModOptionsBuilder options, StorageEventHandler saveHandler, Consumer<PostApplyOps> registerOps, Page... pages) {
+        var ctx = new BuildCtx();
+        registerOps.accept(ctx.postRunner);
+        ctx.saveHandler = saveHandler;
+        for (var page : pages) {
+            options.addPage(page.create(builder, ctx));
+        }
+        options.registerFlagHook(ctx.postRunner.build());
+    }
+}

src/main/java/me/cortex/voxy/client/config/VoxyConfigMenu.java

@@ -0,0 +1,154 @@
+package me.cortex.voxy.client.config;
+
+import me.cortex.voxy.client.RenderStatistics;
+import me.cortex.voxy.client.config.SodiumConfigBuilder.*;
+import me.cortex.voxy.common.config.VoxyConfig;
+import me.cortex.voxy.client.VoxyClient;
+import me.cortex.voxy.client.VoxyClientInstance;
+import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
+import me.cortex.voxy.client.core.util.IrisUtil;
+import me.cortex.voxy.common.util.cpu.CpuLayout;
+import me.cortex.voxy.commonImpl.VoxyCommon;
+import net.caffeinemc.mods.sodium.api.config.ConfigEntryPoint;
+import net.caffeinemc.mods.sodium.api.config.option.OptionFlag;
+import net.caffeinemc.mods.sodium.api.config.option.OptionImpact;
+import net.caffeinemc.mods.sodium.api.config.option.Range;
+import net.caffeinemc.mods.sodium.api.config.structure.ConfigBuilder;
+import net.minecraft.client.Minecraft;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.Identifier;
+
+public class VoxyConfigMenu implements ConfigEntryPoint {
+    @Override
+    public void registerConfigLate(ConfigBuilder B) {
+        if (!VoxyCommon.isAvailable()) return;//Dont even register the config if its not avalible
+
+        var CFG = VoxyConfig.CONFIG;
+
+        var cc = B.registerModOptions("voxy", "Voxy", VoxyCommon.MOD_VERSION)
+                .setIcon(Identifier.parse("voxy:icon.png"));
+
+        final var RENDER_RELOAD = OptionFlag.REQUIRES_RENDERER_RELOAD.getId().toString();
+
+        SodiumConfigBuilder.buildToSodium(B, cc, CFG::save, postOp->{
+                    postOp.register("voxy:update_threads", ()->{
+                        var instance = VoxyCommon.getInstance();
+                        if (instance != null) {
+                            instance.updateDedicatedThreads();
+                        }
+                    }, "voxy:enabled").register("voxy:iris_reload", ()->IrisUtil.reload());
+                },
+                new Page(Component.translatable("voxy.config.general"),
+                        new Group(
+                                new BoolOption(
+                                        "voxy:enabled",
+                                        Component.translatable("voxy.config.general.enabled"),
+                                        ()->CFG.enabled, v->{
+                                            CFG.enabled=v;
+                                            //we need to special case enabled, since the render reload flag runs befor us and its quite important we get it right
+                                            if (v&&VoxyClientInstance.isInGame) {
+                                                VoxyCommon.createInstance();
+                                            }
+                                        })
+                                        .setPostChangeRunner(c->{
+                                            if (!c) {
+                                                var vrsh = (IGetVoxyRenderSystem) Minecraft.getInstance().levelRenderer;
+                                                if (vrsh != null) {
+                                                    vrsh.shutdownRenderer();
+                                                }
+                                                VoxyCommon.shutdownInstance();
+                                            }
+                                        }).setPostChangeFlags(RENDER_RELOAD, "voxy:iris_reload").setEnabler(null)
+                        ), new Group(
+                                new IntOption(
+                                        "voxy:thread_count",
+                                        Component.translatable("voxy.config.general.serviceThreads"),
+                                        ()->CFG.serviceThreads, v->CFG.serviceThreads=v,
+                                        new Range(1, CpuLayout.getCoreCount(), 1))
+                                        .setPostChangeFlags("voxy:update_threads"),
+                                new BoolOption(
+                                        "voxy:use_sodium_threads",
+                                        Component.translatable("voxy.config.general.useSodiumBuilder"),
+                                        ()->!CFG.dontUseSodiumBuilderThreads, v->CFG.dontUseSodiumBuilderThreads=!v)
+                                        .setPostChangeFlags("voxy:update_threads")
+                        ), new Group(
+                                new BoolOption(
+                                        "voxy:ingest_enabled",
+                                        Component.translatable("voxy.config.general.ingest"),
+                                        ()->CFG.ingestEnabled, v->CFG.ingestEnabled=v)
+                        )
+                ).setEnabler("voxy:enabled"),
+                new Page(Component.translatable("voxy.config.rendering"),
+                        new Group(
+                                new BoolOption(
+                                        "voxy:rendering",
+                                        Component.translatable("voxy.config.general.rendering"),
+                                        ()->CFG.enableRendering, v->CFG.enableRendering=v)
+                                        .setPostChangeRunner(c->{
+                                            var vrsh = (IGetVoxyRenderSystem)Minecraft.getInstance().levelRenderer;
+                                            if (vrsh != null) {
+                                                if (c) {
+                                                    vrsh.createRenderer();
+                                                } else {
+                                                    vrsh.shutdownRenderer();
+                                                }
+                                            }
+                                        },"voxy:enabled", RENDER_RELOAD)
+                                        .setPostChangeFlags("voxy:iris_reload")
+                                        .setEnabler("voxy:enabled")
+                        ), new Group(
+                                new IntOption(
+                                        "voxy:subdivsize",
+                                        Component.translatable("voxy.config.general.subDivisionSize"),
+                                        ()->subDiv2ln(CFG.subDivisionSize), v->CFG.subDivisionSize=ln2subDiv(v),
+                                        new Range(0, SUBDIV_IN_MAX, 1))
+                                        .setFormatter(v->Component.literal(Integer.toString(Math.round(ln2subDiv(v))))),
+                                new IntOption(
+                                        "voxy:render_distance",
+                                        Component.translatable("voxy.config.general.renderDistance"),
+                                        ()->CFG.sectionRenderDistance, v->CFG.sectionRenderDistance=v,
+                                        new Range(2, 64, 1))
+                                        .setFormatter(v->Component.literal(Integer.toString(v*32)))//Top level rd == 32 chunks
+                                        .setPostChangeRunner(c->{
+                                            var vrsh = (IGetVoxyRenderSystem)Minecraft.getInstance().levelRenderer;
+                                            if (vrsh != null) {
+                                                var vrs = vrsh.getVoxyRenderSystem();
+                                                if (vrs != null) {
+                                                    vrs.setRenderDistance(c);
+                                                }
+                                            }
+                                        }, "voxy:rendering", RENDER_RELOAD)
+                        ), new Group(
+                                new BoolOption(
+                                        "voxy:eviromental_fog",
+                                        Component.translatable("voxy.config.general.environmental_fog"),
+                                        ()->CFG.useEnvironmentalFog, v->CFG.useEnvironmentalFog=v)
+                                        .setPostChangeFlags(RENDER_RELOAD)
+                        ), new Group(
+                                new BoolOption(
+                                        "voxy:render_debug",
+                                        Component.translatable("voxy.config.general.render_statistics"),
+                                        ()-> RenderStatistics.enabled, v->RenderStatistics.enabled=v)
+                                        .setPostChangeFlags(RENDER_RELOAD))
+                ).setEnablerAND("voxy:enabled", "voxy:rendering"));
+
+    }
+
+
+    private static final int SUBDIV_IN_MAX = 100;
+    private static final double SUBDIV_MIN = 28;
+    private static final double SUBDIV_MAX = 256;
+    private static final double SUBDIV_CONST = Math.log(SUBDIV_MAX/SUBDIV_MIN)/Math.log(2);
+
+    //In range is 0->200
+    //Out range is 28->256
+    private static float ln2subDiv(int in) {
+        return (float) (SUBDIV_MIN*Math.pow(2, SUBDIV_CONST*((double)in/SUBDIV_IN_MAX)));
+    }
+
+    //In range is ... any?
+    //Out range is 0->200
+    private static int subDiv2ln(float in) {
+        return (int) (((Math.log(((double)in)/SUBDIV_MIN)/Math.log(2))/SUBDIV_CONST)*SUBDIV_IN_MAX);
+    }
+}

src/main/java/me/cortex/voxy/client/config/VoxyConfigScreenPages.java

@@ -1,173 +0,0 @@
-package me.cortex.voxy.client.config;
-
-import com.google.common.collect.ImmutableList;
-import me.cortex.voxy.client.RenderStatistics;
-import me.cortex.voxy.client.VoxyClientInstance;
-import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
-import me.cortex.voxy.common.util.cpu.CpuLayout;
-import me.cortex.voxy.commonImpl.VoxyCommon;
-import net.caffeinemc.mods.sodium.client.gui.options.*;
-import net.caffeinemc.mods.sodium.client.gui.options.control.SliderControl;
-import net.caffeinemc.mods.sodium.client.gui.options.control.TickBoxControl;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.text.Text;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public abstract class VoxyConfigScreenPages {
-    private VoxyConfigScreenPages(){}
-
-    public static OptionPage voxyOptionPage = null;
-
-    public static OptionPage page() {
-        List<OptionGroup> groups = new ArrayList<>();
-        VoxyConfig storage = VoxyConfig.CONFIG;
-
-        //General
-        groups.add(OptionGroup.createBuilder()
-                .add(OptionImpl.createBuilder(boolean.class, storage)
-                        .setName(Text.translatable("voxy.config.general.enabled"))
-                        .setTooltip(Text.translatable("voxy.config.general.enabled.tooltip"))
-                        .setControl(TickBoxControl::new)
-                        .setBinding((s, v)->{
-                            s.enabled = v;
-                            if (v) {
-                                if (VoxyClientInstance.isInGame) {
-                                    VoxyCommon.createInstance();
-                                    var vrsh = (IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer;
-                                    if (vrsh != null && s.enableRendering) {
-                                        vrsh.createRenderer();
-                                    }
-                                }
-                            } else {
-                                var vrsh = (IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer;
-                                if (vrsh != null) {
-                                    vrsh.shutdownRenderer();
-                                }
-                                VoxyCommon.shutdownInstance();
-                            }
-                        }, s -> s.enabled)
-                        .build()
-                ).add(OptionImpl.createBuilder(int.class, storage)
-                        .setName(Text.translatable("voxy.config.general.serviceThreads"))
-                        .setTooltip(Text.translatable("voxy.config.general.serviceThreads.tooltip"))
-                        .setControl(opt->new SliderControl(opt, 1,
-                                CpuLayout.CORES.length, //Just do core size as max
-                                //Runtime.getRuntime().availableProcessors(),//Note: this is threads not cores, the default value is half the core count, is fine as this should technically be the limit but CpuLayout.CORES.length is more realistic
-                                1, v->Text.literal(Integer.toString(v))))
-                        .setBinding((s, v)->{
-                            boolean wasEnabled = VoxyCommon.getInstance() != null;
-                            var vrsh = (IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer;
-                            if (wasEnabled) {
-                                if (vrsh != null) {
-                                    vrsh.shutdownRenderer();
-                                }
-                                VoxyCommon.shutdownInstance();
-                            }
-
-                            s.serviceThreads = v;
-
-                            if (wasEnabled) {
-                                VoxyCommon.createInstance();
-                            }
-                        }, s -> s.serviceThreads)
-                        .setImpact(OptionImpact.HIGH)
-                        .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
-                        .build()
-                ).add(OptionImpl.createBuilder(boolean.class, storage)
-                        .setName(Text.translatable("voxy.config.general.ingest"))
-                        .setTooltip(Text.translatable("voxy.config.general.ingest.tooltip"))
-                        .setControl(TickBoxControl::new)
-                        .setBinding((s, v) -> s.ingestEnabled = v, s -> s.ingestEnabled)
-                        .setImpact(OptionImpact.MEDIUM)
-                        .build()
-                ).build()
-        );
-
-        groups.add(OptionGroup.createBuilder()
-                .add(OptionImpl.createBuilder(boolean.class, storage)
-                        .setName(Text.translatable("voxy.config.general.rendering"))
-                        .setTooltip(Text.translatable("voxy.config.general.rendering.tooltip"))
-                        .setControl(TickBoxControl::new)
-                        .setBinding((s, v)->{
-                            s.enableRendering = v;
-                            var vrsh = (IGetVoxyRenderSystem)MinecraftClient.getInstance().worldRenderer;
-                            if (vrsh != null) {
-                                if (v) {
-                                    vrsh.createRenderer();
-                                } else {
-                                    vrsh.shutdownRenderer();
-                                }
-                            }
-                        }, s -> s.enableRendering)
-                        .setImpact(OptionImpact.HIGH)
-                        .build()
-                ).add(OptionImpl.createBuilder(int.class, storage)
-                        .setName(Text.translatable("voxy.config.general.subDivisionSize"))
-                        .setTooltip(Text.translatable("voxy.config.general.subDivisionSize.tooltip"))
-                        .setControl(opt->new SliderControl(opt, 0, SUBDIV_IN_MAX, 1, v->Text.literal(Integer.toString(Math.round(ln2subDiv(v))))))
-                        .setBinding((s, v) -> s.subDivisionSize = ln2subDiv(v), s -> subDiv2ln(s.subDivisionSize))
-                        .setImpact(OptionImpact.HIGH)
-                        .build()
-                ).add(OptionImpl.createBuilder(int.class, storage)
-                        .setName(Text.translatable("voxy.config.general.renderDistance"))
-                        .setTooltip(Text.translatable("voxy.config.general.renderDistance.tooltip"))
-                        .setControl(opt->new SliderControl(opt, 2, 64, 1, v->Text.literal(Integer.toString(v * 32))))//Every unit is equal to 32 vanilla chunks
-                        .setBinding((s, v)-> {
-                            s.sectionRenderDistance = v;
-                            var vrsh = (IGetVoxyRenderSystem)MinecraftClient.getInstance().worldRenderer;
-                            if (vrsh != null) {
-                                var vrs = vrsh.getVoxyRenderSystem();
-                                if (vrs != null) {
-                                    vrs.setRenderDistance(v);
-                                }
-                            }
-                        }, s -> s.sectionRenderDistance)
-                        .setImpact(OptionImpact.LOW)
-                        .build()
-                ).add(OptionImpl.createBuilder(boolean.class, storage)
-                        .setName(Text.translatable("voxy.config.general.environmental_fog"))
-                        .setTooltip(Text.translatable("voxy.config.general.environmental_fog.tooltip"))
-                        .setControl(TickBoxControl::new)
-                        .setImpact(OptionImpact.VARIES)
-                        .setBinding((s, v)-> s.useEnvironmentalFog = v, s -> s.useEnvironmentalFog)
-                        .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
-                        .build()
-                ).add(OptionImpl.createBuilder(boolean.class, storage)
-                        .setName(Text.translatable("voxy.config.general.vanilla_fog"))
-                        .setTooltip(Text.translatable("voxy.config.general.vanilla_fog.tooltip"))
-                        .setControl(TickBoxControl::new)
-                        .setBinding((s, v)-> s.renderVanillaFog = v, s -> s.renderVanillaFog)
-                        .build()
-                ).add(OptionImpl.createBuilder(boolean.class, storage)
-                        .setName(Text.translatable("voxy.config.general.render_statistics"))
-                        .setTooltip(Text.translatable("voxy.config.general.render_statistics.tooltip"))
-                        .setControl(TickBoxControl::new)
-                        .setBinding((s, v)-> RenderStatistics.enabled = v, s -> RenderStatistics.enabled)
-                        .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
-                        .build()
-                ).build()
-        );
-        return new OptionPage(Text.translatable("voxy.config.title"), ImmutableList.copyOf(groups));
-    }
-
-    private static final int SUBDIV_IN_MAX = 100;
-    private static final double SUBDIV_MIN = 28;
-    private static final double SUBDIV_MAX = 256;
-    private static final double SUBDIV_CONST = Math.log(SUBDIV_MAX/SUBDIV_MIN)/Math.log(2);
-
-
-    //In range is 0->200
-    //Out range is 28->256
-    private static float ln2subDiv(int in) {
-        return (float) (SUBDIV_MIN*Math.pow(2, SUBDIV_CONST*((double)in/SUBDIV_IN_MAX)));
-    }
-
-    //In range is ... any?
-    //Out range is 0->200
-    private static int subDiv2ln(float in) {
-        return (int) (((Math.log(((double)in)/SUBDIV_MIN)/Math.log(2))/SUBDIV_CONST)*SUBDIV_IN_MAX);
-    }
-
-}

src/main/java/me/cortex/voxy/client/core/AbstractRenderPipeline.java

@@ -2,14 +2,15 @@ package me.cortex.voxy.client.core;
 
 import me.cortex.voxy.client.RenderStatistics;
 import me.cortex.voxy.client.TimingStatistics;
-import me.cortex.voxy.client.core.gl.Capabilities;
+import me.cortex.voxy.client.VoxyClient;
 import me.cortex.voxy.client.core.model.ModelBakerySubsystem;
 import me.cortex.voxy.client.core.rendering.Viewport;
 import me.cortex.voxy.client.core.rendering.hierachical.AsyncNodeManager;
 import me.cortex.voxy.client.core.rendering.hierachical.HierarchicalOcclusionTraverser;
 import me.cortex.voxy.client.core.rendering.hierachical.NodeCleaner;
 import me.cortex.voxy.client.core.rendering.post.FullscreenBlit;
-import me.cortex.voxy.client.core.rendering.section.AbstractSectionRenderer;
+import me.cortex.voxy.client.core.rendering.section.backend.AbstractSectionRenderer;
+import me.cortex.voxy.client.core.rendering.util.DepthFramebuffer;
 import me.cortex.voxy.client.core.rendering.util.DownloadStream;
 import me.cortex.voxy.common.util.TrackedObject;
 import org.joml.Matrix4f;
@@ -23,7 +24,6 @@ import static org.lwjgl.opengl.GL11C.GL_ALWAYS;
 import static org.lwjgl.opengl.GL11C.GL_DEPTH_TEST;
 import static org.lwjgl.opengl.GL11C.GL_EQUAL;
 import static org.lwjgl.opengl.GL11C.GL_KEEP;
-import static org.lwjgl.opengl.GL11C.GL_NEAREST;
 import static org.lwjgl.opengl.GL11C.GL_REPLACE;
 import static org.lwjgl.opengl.GL11C.GL_STENCIL_TEST;
 import static org.lwjgl.opengl.GL11C.glColorMask;
@@ -32,16 +32,16 @@ import static org.lwjgl.opengl.GL11C.glEnable;
 import static org.lwjgl.opengl.GL11C.glStencilFunc;
 import static org.lwjgl.opengl.GL11C.glStencilMask;
 import static org.lwjgl.opengl.GL11C.glStencilOp;
+import static org.lwjgl.opengl.GL30C.GL_DEPTH24_STENCIL8;
 import static org.lwjgl.opengl.GL30C.GL_FRAMEBUFFER;
 import static org.lwjgl.opengl.GL30C.glBindFramebuffer;
-import static org.lwjgl.opengl.GL42.GL_DEPTH_BUFFER_BIT;
 import static org.lwjgl.opengl.GL42.GL_LEQUAL;
 import static org.lwjgl.opengl.GL42.GL_NOTEQUAL;
 import static org.lwjgl.opengl.GL42.glDepthFunc;
 import static org.lwjgl.opengl.GL42.*;
 import static org.lwjgl.opengl.GL45.glClearNamedFramebufferfi;
+import static org.lwjgl.opengl.GL45.glGetNamedFramebufferAttachmentParameteri;
 import static org.lwjgl.opengl.GL45C.glBindTextureUnit;
-import static org.lwjgl.opengl.GL45C.glBlitNamedFramebuffer;
 
 public abstract class AbstractRenderPipeline extends TrackedObject {
     private final BooleanSupplier frexStillHasWork;
@@ -54,11 +54,24 @@ public abstract class AbstractRenderPipeline extends TrackedObject {
 
     private final FullscreenBlit depthMaskBlit = new FullscreenBlit("voxy:post/fullscreen2.vert", "voxy:post/noop.frag");
     private final FullscreenBlit depthSetBlit = new FullscreenBlit("voxy:post/fullscreen2.vert", "voxy:post/depth0.frag");
-    protected AbstractRenderPipeline(AsyncNodeManager nodeManager, NodeCleaner nodeCleaner, HierarchicalOcclusionTraverser traversal, BooleanSupplier frexSupplier) {
+    private final FullscreenBlit depthCopy = new FullscreenBlit("voxy:post/fullscreen2.vert", "voxy:post/depth_copy.frag");
+
+    public final DepthFramebuffer fb = new DepthFramebuffer(GL_DEPTH24_STENCIL8);
+
+    protected final boolean deferTranslucency;
+
+    private static final int DEPTH_SAMPLER = glGenSamplers();
+    static {
+        glSamplerParameteri(DEPTH_SAMPLER, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glSamplerParameteri(DEPTH_SAMPLER, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    }
+
+    protected AbstractRenderPipeline(AsyncNodeManager nodeManager, NodeCleaner nodeCleaner, HierarchicalOcclusionTraverser traversal, BooleanSupplier frexSupplier, boolean deferTranslucency) {
         this.frexStillHasWork = frexSupplier;
         this.nodeManager = nodeManager;
         this.nodeCleaner = nodeCleaner;
         this.traversal = traversal;
+        this.deferTranslucency = deferTranslucency;
     }
 
     //Allows pipelines to configure model baking system
@@ -86,13 +99,20 @@ public abstract class AbstractRenderPipeline extends TrackedObject {
 
         var rs = ((AbstractSectionRenderer)this.sectionRenderer);
         rs.renderOpaque(viewport);
-        this.innerPrimaryWork(viewport, depthTexture);
+        var occlusionDebug = VoxyClient.getOcclusionDebugState();
-        rs.buildDrawCalls(viewport);
+        if (occlusionDebug==0) {
+            this.innerPrimaryWork(viewport, depthTexture);
+        }
+        if (occlusionDebug<=1) {
+            rs.buildDrawCalls(viewport);
+        }
         rs.renderTemporal(viewport);
 
         this.postOpaquePreTranslucent(viewport);
 
-        rs.renderTranslucent(viewport);
+        if (!this.deferTranslucency) {
+            rs.renderTranslucent(viewport);
+        }
 
         this.finish(viewport, sourceFrameBuffer, srcWidth, srcHeight);
         glBindFramebuffer(GL_FRAMEBUFFER, sourceFrameBuffer);
@@ -100,10 +120,18 @@ public abstract class AbstractRenderPipeline extends TrackedObject {
 
     protected void initDepthStencil(int sourceFrameBuffer, int targetFb, int srcWidth, int srcHeight, int width, int height) {
         glClearNamedFramebufferfi(targetFb, GL_DEPTH_STENCIL, 0, 1.0f, 1);
-        glBlitNamedFramebuffer(sourceFrameBuffer, targetFb, 0,0, srcWidth, srcHeight, 0,0, width, height, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
+        // using blit to copy depth from mismatched depth formats is not portable so instead a full screen pass is performed for a depth copy
-
+        // the mismatched formats in this case is the d32 to d24s8
         glBindFramebuffer(GL30.GL_FRAMEBUFFER, targetFb);
 
+        this.depthCopy.bind();
+        int depthTexture = glGetNamedFramebufferAttachmentParameteri(sourceFrameBuffer, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME);
+        glBindTextureUnit(0, depthTexture);
+        glBindSampler(0, DEPTH_SAMPLER);
+        glUniform2f(1,((float)width)/srcWidth, ((float)height)/srcHeight);
+        glColorMask(false,false,false,false);
+        this.depthCopy.blit();
+
         /*
         if (Capabilities.INSTANCE.isMesa){
             glClearStencil(1);
@@ -120,7 +148,6 @@ public abstract class AbstractRenderPipeline extends TrackedObject {
 
         glEnable(GL_DEPTH_TEST);
         glDepthFunc(GL_NOTEQUAL);//If != 1 pass
-        glColorMask(false,false,false,false);
         //We do here
         this.depthMaskBlit.blit();
         glDisable(GL_DEPTH_TEST);
@@ -141,6 +168,9 @@ public abstract class AbstractRenderPipeline extends TrackedObject {
 
     private static final long SCRATCH = MemoryUtil.nmemAlloc(4*4*4);
     protected static void transformBlitDepth(FullscreenBlit blitShader, int srcDepthTex, int dstFB, Viewport<?> viewport, Matrix4f targetTransform) {
+        // at this point the dst frame buffer doesn't have a stencil attachment so we don't need to keep the stencil test on for the blit
+        // in the worst case the dstFB does have a stencil attachment causing this pass to become 'corrupted'
+        glDisable(GL_STENCIL_TEST);
         glBindFramebuffer(GL30.GL_FRAMEBUFFER, dstFB);
 
         blitShader.bind();
@@ -151,7 +181,6 @@ public abstract class AbstractRenderPipeline extends TrackedObject {
         nglUniformMatrix4fv(2, 1, false, SCRATCH);//tooProjection
 
         glEnable(GL_DEPTH_TEST);
-        //We keep the stencil test on with the emitting, only to where non terrain is rendered
         blitShader.blit();
         glDisable(GL_STENCIL_TEST);
         glDisable(GL_DEPTH_TEST);
@@ -181,17 +210,19 @@ public abstract class AbstractRenderPipeline extends TrackedObject {
 
             glMemoryBarrier(GL_FRAMEBUFFER_BARRIER_BIT | GL_PIXEL_BUFFER_BARRIER_BIT);
 
-            TimingStatistics.I.start();
+            TimingStatistics.F.start();
             this.traversal.doTraversal(viewport);
-            TimingStatistics.I.stop();
+            TimingStatistics.F.stop();
         } while (this.frexStillHasWork.getAsBoolean());
     }
 
     @Override
     protected void free0() {
+        this.fb.free();
         this.sectionRenderer.free();
         this.depthMaskBlit.delete();
         this.depthSetBlit.delete();
+        this.depthCopy.delete();
         super.free0();
     }
 

src/main/java/me/cortex/voxy/client/core/IGetVoxyRenderSystem.java

@@ -1,7 +1,15 @@
 package me.cortex.voxy.client.core;
 
+import net.minecraft.client.Minecraft;
+
 public interface IGetVoxyRenderSystem {
     VoxyRenderSystem getVoxyRenderSystem();
     void shutdownRenderer();
     void createRenderer();
+
+    static VoxyRenderSystem getNullable() {
+        var lr = (IGetVoxyRenderSystem)Minecraft.getInstance().levelRenderer;
+        if (lr == null) return null;
+        return lr.getVoxyRenderSystem();
+    }
 }

src/main/java/me/cortex/voxy/client/core/IrisVoxyRenderPipeline.java

@@ -7,7 +7,7 @@ import me.cortex.voxy.client.core.rendering.hierachical.AsyncNodeManager;
 import me.cortex.voxy.client.core.rendering.hierachical.HierarchicalOcclusionTraverser;
 import me.cortex.voxy.client.core.rendering.hierachical.NodeCleaner;
 import me.cortex.voxy.client.core.rendering.post.FullscreenBlit;
-import me.cortex.voxy.client.core.rendering.section.AbstractSectionRenderer;
+import me.cortex.voxy.client.core.rendering.section.backend.AbstractSectionRenderer;
 import me.cortex.voxy.client.core.rendering.util.DepthFramebuffer;
 import me.cortex.voxy.client.core.rendering.util.UploadStream;
 import me.cortex.voxy.client.iris.IrisVoxyRenderPipelineData;
@@ -26,13 +26,12 @@ import static org.lwjgl.opengl.GL45C.*;
 public class IrisVoxyRenderPipeline extends AbstractRenderPipeline {
     private final IrisVoxyRenderPipelineData data;
     private final FullscreenBlit depthBlit = new FullscreenBlit("voxy:post/blit_texture_depth_cutout.frag");
-    public final DepthFramebuffer fb = new DepthFramebuffer(GL_DEPTH24_STENCIL8);
+    public final DepthFramebuffer fbTranslucent = new DepthFramebuffer(this.fb.getFormat());
-    public final DepthFramebuffer fbTranslucent = new DepthFramebuffer(GL_DEPTH24_STENCIL8);
 
     private final GlBuffer shaderUniforms;
 
     public IrisVoxyRenderPipeline(IrisVoxyRenderPipelineData data, AsyncNodeManager nodeManager, NodeCleaner nodeCleaner, HierarchicalOcclusionTraverser traversal, BooleanSupplier frexSupplier) {
-        super(nodeManager, nodeCleaner, traversal, frexSupplier);
+        super(nodeManager, nodeCleaner, traversal, frexSupplier, data.shouldDeferTranslucency());
         this.data = data;
         if (this.data.thePipeline != null) {
             throw new IllegalStateException("Pipeline data already bound");
@@ -79,7 +78,6 @@ public class IrisVoxyRenderPipeline extends AbstractRenderPipeline {
         this.data.thePipeline = null;
 
         this.depthBlit.delete();
-        this.fb.free();
         this.fbTranslucent.free();
 
         if (this.shaderUniforms != null) {
@@ -113,7 +111,7 @@ public class IrisVoxyRenderPipeline extends AbstractRenderPipeline {
             glClear(GL_COLOR_BUFFER_BIT);
         }
 
-        if (this.data.useViewportDims) {
+        if (!this.data.useViewportDims) {
             srcWidth = viewport.width;
             srcHeight = viewport.height;
         }
@@ -144,6 +142,10 @@ public class IrisVoxyRenderPipeline extends AbstractRenderPipeline {
                     this.fbTranslucent.getDepthTex().id, sourceFrameBuffer,
                     viewport, new Matrix4f(viewport.vanillaProjection).mul(viewport.modelView));
             glColorMask(true, true, true, true);
+        } else {
+            // normally disabled by AbstractRenderPipeline but since we are skipping it we do it here
+            glDisable(GL_STENCIL_TEST);
+            glDisable(GL_DEPTH_TEST);
         }
     }
 

src/main/java/me/cortex/voxy/client/core/NormalRenderPipeline.java

@@ -1,6 +1,6 @@
 package me.cortex.voxy.client.core;
 
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.gl.GlFramebuffer;
 import me.cortex.voxy.client.core.gl.GlTexture;
 import me.cortex.voxy.client.core.gl.shader.Shader;
@@ -11,7 +11,7 @@ import me.cortex.voxy.client.core.rendering.hierachical.HierarchicalOcclusionTra
 import me.cortex.voxy.client.core.rendering.hierachical.NodeCleaner;
 import me.cortex.voxy.client.core.rendering.post.FullscreenBlit;
 import me.cortex.voxy.client.core.rendering.util.DepthFramebuffer;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
 import org.joml.Matrix4f;
 import org.lwjgl.system.MemoryStack;
 
@@ -37,7 +37,6 @@ public class NormalRenderPipeline extends AbstractRenderPipeline {
     private GlTexture colourTex;
     private GlTexture colourSSAOTex;
     private final GlFramebuffer fbSSAO = new GlFramebuffer();
-    private final DepthFramebuffer fb = new DepthFramebuffer(GL_DEPTH24_STENCIL8);
 
     private final boolean useEnvFog;
     private final FullscreenBlit finalBlit;
@@ -47,7 +46,7 @@ public class NormalRenderPipeline extends AbstractRenderPipeline {
             .compile();
 
     protected NormalRenderPipeline(AsyncNodeManager nodeManager, NodeCleaner nodeCleaner, HierarchicalOcclusionTraverser traversal, BooleanSupplier frexSupplier) {
-        super(nodeManager, nodeCleaner, traversal, frexSupplier);
+        super(nodeManager, nodeCleaner, traversal, frexSupplier, false);
         this.useEnvFog = VoxyConfig.CONFIG.useEnvironmentalFog;
         this.finalBlit = new FullscreenBlit("voxy:post/blit_texture_depth_cutout.frag",
                 a->a.defineIf("USE_ENV_FOG", this.useEnvFog).define("EMIT_COLOUR"));
@@ -66,7 +65,7 @@ public class NormalRenderPipeline extends AbstractRenderPipeline {
             this.colourSSAOTex = new GlTexture().store(GL_RGBA8, 1, viewport.width, viewport.height);
 
             this.fb.framebuffer.bind(GL_COLOR_ATTACHMENT0, this.colourTex).verify();
-            this.fbSSAO.bind(GL_DEPTH_STENCIL_ATTACHMENT, this.fb.getDepthTex()).bind(GL_COLOR_ATTACHMENT0, this.colourSSAOTex).verify();
+            this.fbSSAO.bind(this.fb.getDepthAttachmentType(), this.fb.getDepthTex()).bind(GL_COLOR_ATTACHMENT0, this.colourSSAOTex).verify();
 
 
             glTextureParameterf(this.colourTex.id, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@@ -108,10 +107,17 @@ public class NormalRenderPipeline extends AbstractRenderPipeline {
         if (this.useEnvFog) {
             float start = viewport.fogParameters.environmentalStart();
             float end = viewport.fogParameters.environmentalEnd();
-            float invEndFogDelta = 1f/(end-start);
+            if (Math.abs(end-start)>1) {
-            float endDistance = MinecraftClient.getInstance().gameRenderer.getViewDistanceBlocks()*1.5f;
+                float invEndFogDelta = 1f / (end - start);
-            glUniform3f(4, endDistance, invEndFogDelta, Math.abs(start)*invEndFogDelta);
+                float endDistance = Math.max(Minecraft.getInstance().gameRenderer.getRenderDistance(), 20*16);//TODO: make this constant a config option
-            glUniform3f(5, viewport.fogParameters.red(), viewport.fogParameters.green(), viewport.fogParameters.blue());
+                endDistance *= (float)Math.sqrt(3);
+                float startDelta = -start * invEndFogDelta;
+                glUniform4f(4, invEndFogDelta, startDelta, Math.clamp(endDistance*invEndFogDelta+startDelta, 0, 1),0);//
+                glUniform4f(5, viewport.fogParameters.red(), viewport.fogParameters.green(), viewport.fogParameters.blue(), viewport.fogParameters.alpha());
+            } else {
+                glUniform4f(4, 0, 0, 0, 0);
+                glUniform4f(5, 0, 0, 0, 0);
+            }
         }
 
         glBindTextureUnit(3, this.colourSSAOTex.id);
@@ -139,7 +145,6 @@ public class NormalRenderPipeline extends AbstractRenderPipeline {
     public void free() {
         this.finalBlit.delete();
         this.ssaoCompute.free();
-        this.fb.free();
         this.fbSSAO.free();
         if (this.colourTex != null) {
             this.colourTex.free();

src/main/java/me/cortex/voxy/client/core/VoxyRenderSystem.java

@@ -4,7 +4,7 @@ import com.mojang.blaze3d.opengl.GlConst;
 import com.mojang.blaze3d.opengl.GlStateManager;
 import me.cortex.voxy.client.TimingStatistics;
 import me.cortex.voxy.client.VoxyClient;
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.gl.Capabilities;
 import me.cortex.voxy.client.core.gl.GlBuffer;
 import me.cortex.voxy.client.core.gl.GlTexture;
@@ -18,8 +18,9 @@ import me.cortex.voxy.client.core.rendering.building.RenderGenerationService;
 import me.cortex.voxy.client.core.rendering.hierachical.AsyncNodeManager;
 import me.cortex.voxy.client.core.rendering.hierachical.HierarchicalOcclusionTraverser;
 import me.cortex.voxy.client.core.rendering.hierachical.NodeCleaner;
-import me.cortex.voxy.client.core.rendering.section.AbstractSectionRenderer;
+import me.cortex.voxy.client.core.rendering.section.IUsesMeshlets;
-import me.cortex.voxy.client.core.rendering.section.MDICSectionRenderer;
+import me.cortex.voxy.client.core.rendering.section.backend.AbstractSectionRenderer;
+import me.cortex.voxy.client.core.rendering.section.backend.mdic.MDICSectionRenderer;
 import me.cortex.voxy.client.core.rendering.section.geometry.BasicSectionGeometryData;
 import me.cortex.voxy.client.core.rendering.section.geometry.IGeometryData;
 import me.cortex.voxy.client.core.rendering.util.DownloadStream;
@@ -28,12 +29,12 @@ import me.cortex.voxy.client.core.rendering.util.UploadStream;
 import me.cortex.voxy.client.core.util.GPUTiming;
 import me.cortex.voxy.client.core.util.IrisUtil;
 import me.cortex.voxy.common.Logger;
-import me.cortex.voxy.common.thread.ServiceThreadPool;
+import me.cortex.voxy.common.thread.ServiceManager;
 import me.cortex.voxy.common.world.WorldEngine;
 import me.cortex.voxy.commonImpl.VoxyCommon;
 import net.caffeinemc.mods.sodium.client.render.chunk.ChunkRenderMatrices;
 import net.caffeinemc.mods.sodium.client.util.FogParameters;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
 import org.joml.Matrix4f;
 import org.joml.Matrix4fc;
 import org.lwjgl.opengl.GL11;
@@ -49,6 +50,9 @@ import static org.lwjgl.opengl.GL33.glBindSampler;
 import static org.lwjgl.opengl.GL43.GL_SHADER_STORAGE_BUFFER;
 import static org.lwjgl.opengl.GL43C.GL_SHADER_STORAGE_BUFFER_BINDING;
 
+import me.cortex.voxy.client.VoxyClientInstance;
+import me.cortex.voxy.common.config.VoxyServerConfig;
+
 public class VoxyRenderSystem {
     private final WorldEngine worldIn;
 
@@ -68,15 +72,20 @@ public class VoxyRenderSystem {
 
     private final AbstractRenderPipeline pipeline;
 
-    private static AbstractSectionRenderer<?,?> createSectionRenderer(AbstractRenderPipeline pipeline, ModelStore modelStore, IGeometryData geometryData) {
+    private static AbstractSectionRenderer.Factory<?,? extends IGeometryData> getRenderBackendFactory() {
         //TODO: need todo a thing where selects optimal section render based on if supports the pipeline and geometry data type
-        return new MDICSectionRenderer(pipeline, modelStore, (BasicSectionGeometryData) geometryData);//We only have MDIC backend... for now
+        return MDICSectionRenderer.FACTORY;
     }
 
-    public VoxyRenderSystem(WorldEngine world, ServiceThreadPool threadPool) {
+    public VoxyRenderSystem(WorldEngine world, ServiceManager sm) {
         //Keep the world loaded, NOTE: this is done FIRST, to keep and ensure that even if the rest of loading takes more
         // than timeout, we keep the world acquired
         world.acquireRef();
+        System.gc();
+
+        if (Minecraft.getInstance().options.getEffectiveRenderDistance()<3) {
+            Logger.warn("Having a vanilla render distance of 2 can cause rare culling near the edge of your screen issues, please use 3 or more");
+        }
 
         //Fking HATE EVERYTHING AAAAAAAAAAAAAAAA
         int[] oldBufferBindings = new int[10];
@@ -92,11 +101,11 @@ public class VoxyRenderSystem {
             this.worldIn = world;
 
             long geometryCapacity = getGeometryBufferSize();
+            var backendFactory = getRenderBackendFactory();
+
             {
-
-
                 this.modelService = new ModelBakerySubsystem(world.getMapper());
-                this.renderGen = new RenderGenerationService(world, this.modelService, threadPool, false, () -> true);
+                this.renderGen = new RenderGenerationService(world, this.modelService, sm, IUsesMeshlets.class.isAssignableFrom(backendFactory.clz()));
 
                 this.geometryData = new BasicSectionGeometryData(1 << 20, geometryCapacity);
 
@@ -114,13 +123,13 @@ public class VoxyRenderSystem {
 
             this.pipeline = RenderPipelineFactory.createPipeline(this.nodeManager, this.nodeCleaner, this.traversal, this::frexStillHasWork);
             this.pipeline.setupExtraModelBakeryData(this.modelService);//Configure the model service
-            var sectionRenderer = createSectionRenderer(this.pipeline, this.modelService.getStore(), this.geometryData);
+            var sectionRenderer = backendFactory.create(this.pipeline, this.modelService.getStore(), this.geometryData);
             this.pipeline.setSectionRenderer(sectionRenderer);
             this.viewportSelector = new ViewportSelector<>(sectionRenderer::createViewport);
 
             {
-                int minSec = MinecraftClient.getInstance().world.getBottomSectionCoord() >> 5;
+                int minSec = Minecraft.getInstance().level.getMinSectionY() >> 5;
-                int maxSec = (MinecraftClient.getInstance().world.getTopSectionCoord() - 1) >> 5;
+                int maxSec = (Minecraft.getInstance().level.getMaxSectionY() - 1) >> 5;
 
                 //Do some very cheeky stuff for MiB
                 if (VoxyCommon.IS_MINE_IN_ABYSS) {//TODO: make this somehow configurable
@@ -134,7 +143,7 @@ public class VoxyRenderSystem {
                         this.nodeManager::addTopLevel,
                         this.nodeManager::removeTopLevel);
 
-                this.renderDistanceTracker.setRenderDistance(VoxyConfig.CONFIG.sectionRenderDistance);
+                this.setRenderDistance(VoxyConfig.CONFIG.sectionRenderDistance);
             }
 
             this.chunkBoundRenderer = new ChunkBoundRenderer(this.pipeline);
@@ -148,6 +157,12 @@ public class VoxyRenderSystem {
         for (int i = 0; i < oldBufferBindings.length; i++) {
             glBindBufferBase(GL_SHADER_STORAGE_BUFFER, i, oldBufferBindings[i]);
         }
+
+        for (int i = 0; i < 12; i++) {
+            GlStateManager._activeTexture(GlConst.GL_TEXTURE0+i);
+            GlStateManager._bindTexture(0);
+            glBindSampler(i, 0);
+        }
     }
 
 
@@ -191,7 +206,10 @@ public class VoxyRenderSystem {
                 .setScreenSize(width, height)
                 .setFogParameters(fogParameters)
                 .update();
-        viewport.frameId++;
+
+        if (VoxyClient.getOcclusionDebugState()==0) {
+            viewport.frameId++;
+        }
 
         return viewport;
     }
@@ -234,7 +252,7 @@ public class VoxyRenderSystem {
         this.pipeline.preSetup(viewport);
 
         TimingStatistics.E.start();
-        if (!IrisUtil.irisShadowActive()) {
+        if ((!VoxyClient.disableSodiumChunkRender())&&!IrisUtil.irisShadowActive()) {
             this.chunkBoundRenderer.render(viewport);
         } else {
             viewport.depthBoundingBuffer.clear(0);
@@ -242,8 +260,10 @@ public class VoxyRenderSystem {
         TimingStatistics.E.stop();
 
 
+        GPUTiming.INSTANCE.marker();
         //The entire rendering pipeline (excluding the chunkbound thing)
         this.pipeline.runPipeline(viewport, boundFB, dims[2], dims[3]);
+        GPUTiming.INSTANCE.marker();
 
 
         TimingStatistics.main.stop();
@@ -257,9 +277,10 @@ public class VoxyRenderSystem {
             UploadStream.INSTANCE.tick();
 
             while (this.renderDistanceTracker.setCenterAndProcess(viewport.cameraX, viewport.cameraZ) && VoxyClient.isFrexActive());//While FF is active, run until everything is processed
-
+            TimingStatistics.H.start();
             //Done here as is allows less gl state resetup
-            this.modelService.tick(Math.max(3_000_000-(System.nanoTime()-startTime), 500_000));
+            do { this.modelService.tick(900_000); } while (VoxyClient.isFrexActive() && !this.modelService.areQueuesEmpty());
+            TimingStatistics.H.stop();
         }
         GPUTiming.INSTANCE.marker();
         TimingStatistics.postDynamic.stop();
@@ -295,6 +316,10 @@ public class VoxyRenderSystem {
 
         TimingStatistics.all.stop();
 
+        //TimingStatistics.I.start();
+        //glFlush();
+        //TimingStatistics.I.stop();
+
         /*
         TimingStatistics.F.start();
         this.postProcessing.setup(viewport.width, viewport.height, boundFB);
@@ -331,12 +356,12 @@ public class VoxyRenderSystem {
         float INCREASE_PER_SECOND = 60;
         float DECREASE_PER_SECOND = 30;
         //Auto fps targeting
-        if (MinecraftClient.getInstance().getCurrentFps() < MIN_FPS) {
+        if (Minecraft.getInstance().getFps() < MIN_FPS) {
-            VoxyConfig.CONFIG.subDivisionSize = Math.min(VoxyConfig.CONFIG.subDivisionSize + INCREASE_PER_SECOND / Math.max(1f, MinecraftClient.getInstance().getCurrentFps()), 256);
+            VoxyConfig.CONFIG.subDivisionSize = Math.min(VoxyConfig.CONFIG.subDivisionSize + INCREASE_PER_SECOND / Math.max(1f, Minecraft.getInstance().getFps()), 256);
         }
 
-        if (MAX_FPS < MinecraftClient.getInstance().getCurrentFps() && canDecreaseSize) {
+        if (MAX_FPS < Minecraft.getInstance().getFps() && canDecreaseSize) {
-            VoxyConfig.CONFIG.subDivisionSize = Math.max(VoxyConfig.CONFIG.subDivisionSize - DECREASE_PER_SECOND / Math.max(1f, MinecraftClient.getInstance().getCurrentFps()), 28);
+            VoxyConfig.CONFIG.subDivisionSize = Math.max(VoxyConfig.CONFIG.subDivisionSize - DECREASE_PER_SECOND / Math.max(1f, Minecraft.getInstance().getFps()), 28);
         }
     }
 
@@ -344,23 +369,30 @@ public class VoxyRenderSystem {
         //TODO: use the existing projection matrix use mulLocal by the inverse of the projection and then mulLocal our projection
 
         var projection = new Matrix4f();
-        var client = MinecraftClient.getInstance();
+        var client = Minecraft.getInstance();
         var gameRenderer = client.gameRenderer;//tickCounter.getTickDelta(true);
 
-        float fov = gameRenderer.getFov(gameRenderer.getCamera(), client.getRenderTickCounter().getTickProgress(true), true);
+        float fov = gameRenderer.getFov(gameRenderer.getMainCamera(), client.getDeltaTracker().getGameTimeDeltaPartialTick(true), true);
 
         projection.setPerspective(fov * 0.01745329238474369f,
-                (float) client.getWindow().getFramebufferWidth() / (float)client.getWindow().getFramebufferHeight(),
+                (float) client.getWindow().getWidth() / (float)client.getWindow().getHeight(),
                 near, far);
         return projection;
     }
 
     //TODO: Make a reverse z buffer
     private static Matrix4f computeProjectionMat(Matrix4fc base) {
+        //THis is a wild and insane problem to have
+        // at short render distances the vanilla terrain doesnt end up covering the 16f near plane voxy uses
+        // meaning that it explodes (due to near plane clipping).. _badly_ with the rastered culling being wrong in rare cases for the immediate
+        // sections rendered after the vanilla render distance
+        float nearVoxy = Minecraft.getInstance().gameRenderer.getRenderDistance()<=32.0f?8f:16f;
+        nearVoxy = VoxyClient.disableSodiumChunkRender()?0.1f:nearVoxy;
+
         return base.mulLocal(
-                makeProjectionMatrix(0.05f, MinecraftClient.getInstance().gameRenderer.getFarPlaneDistance()).invert(),
+                makeProjectionMatrix(0.05f, Minecraft.getInstance().gameRenderer.getDepthFar()).invert(),
                 new Matrix4f()
-        ).mulLocal(makeProjectionMatrix(16, 16*3000));
+        ).mulLocal(makeProjectionMatrix(nearVoxy, 16*3000));
     }
 
     private boolean frexStillHasWork() {
@@ -404,6 +436,15 @@ public class VoxyRenderSystem {
             debug.add("Extra time: " + TimingStatistics.A.pVal() + ", " + TimingStatistics.B.pVal() + ", " + TimingStatistics.C.pVal() + ", " + TimingStatistics.D.pVal());
             debug.add("Extra 2 time: " + TimingStatistics.E.pVal() + ", " + TimingStatistics.F.pVal() + ", " + TimingStatistics.G.pVal() + ", " + TimingStatistics.H.pVal() + ", " + TimingStatistics.I.pVal());
         }
+        debug.add(GPUTiming.INSTANCE.getDebug());
+        
+        if (VoxyCommon.getInstance() instanceof VoxyClientInstance clientInstance) {
+            long lastUpdate = clientInstance.getLastLodUpdate();
+            long timeSince = System.currentTimeMillis() - lastUpdate;
+            debug.add("LOD Updates: " + clientInstance.getLodUpdatesReceived() + " (Last: " + timeSince + "ms ago)");
+            debug.add("Server View Dist: " + clientInstance.getServerViewDistance());
+        }
+        
         PrintfDebugUtil.addToOut(debug);
     }
 

src/main/java/me/cortex/voxy/client/core/gl/Capabilities.java

@@ -1,12 +1,30 @@
 package me.cortex.voxy.client.core.gl;
 
 import me.cortex.voxy.client.core.gl.shader.ShaderType;
+import me.cortex.voxy.common.Logger;
 import org.lwjgl.opengl.GL;
+import org.lwjgl.opengl.GL11C;
 import org.lwjgl.opengl.GL20C;
+import org.lwjgl.opengl.GL30;
+import org.lwjgl.system.MemoryUtil;
 
-import static org.lwjgl.opengl.GL11.*;
+import java.util.Locale;
+import java.util.Random;
+
+import static org.lwjgl.opengl.GL11.GL_NEAREST;
+import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
+import static org.lwjgl.opengl.GL11.GL_TEXTURE_MAG_FILTER;
+import static org.lwjgl.opengl.GL11.GL_UNSIGNED_BYTE;
+import static org.lwjgl.opengl.GL15.glDeleteBuffers;
+import static org.lwjgl.opengl.GL30.GL_DEPTH_STENCIL;
+import static org.lwjgl.opengl.GL30C.GL_MAP_READ_BIT;
 import static org.lwjgl.opengl.GL32.glGetInteger64;
 import static org.lwjgl.opengl.GL43C.GL_MAX_SHADER_STORAGE_BLOCK_SIZE;
+import static org.lwjgl.opengl.GL44.GL_DYNAMIC_STORAGE_BIT;
+import static org.lwjgl.opengl.GL44.GL_MAP_COHERENT_BIT;
+import static org.lwjgl.opengl.GL45.glClearNamedFramebufferfi;
+import static org.lwjgl.opengl.GL45C.*;
+import static org.lwjgl.opengl.GL45C.glCreateFramebuffers;
 import static org.lwjgl.opengl.NVXGPUMemoryInfo.*;
 
 public class Capabilities {
@@ -27,6 +45,9 @@ public class Capabilities {
     public final boolean subgroup;
     public final boolean sparseBuffer;
     public final boolean isNvidia;
+    public final boolean isAmd;
+    public final boolean nvBarryCoords;
+    public final boolean hasBrokenDepthSampler;
 
     public Capabilities() {
         var cap = GL.getCapabilities();
@@ -62,9 +83,11 @@ public class Capabilities {
 
         this.ssboMaxSize = glGetInteger64(GL_MAX_SHADER_STORAGE_BLOCK_SIZE);
 
-        this.isMesa = glGetString(GL_VERSION).toLowerCase().contains("mesa");
+        this.isMesa = glGetString(GL_VERSION).toLowerCase(Locale.ROOT).contains("mesa");
-        this.isIntel = glGetString(GL_VENDOR).toLowerCase().contains("intel");
+        var vendor = glGetString(GL_VENDOR).toLowerCase(Locale.ROOT);
-        this.isNvidia = glGetString(GL_VENDOR).toLowerCase().contains("nvidia");
+        this.isIntel = vendor.contains("intel");
+        this.isNvidia = vendor.contains("nvidia");
+        this.isAmd = vendor.contains("amd")||vendor.contains("radeon");
 
         if (this.canQueryGpuMemory) {
             this.totalDedicatedMemory = glGetInteger64(GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX)*1024;//Since its in Kb
@@ -73,11 +96,106 @@ public class Capabilities {
             this.totalDedicatedMemory = -1;
             this.totalDynamicMemory = -1;
         }
+
+        this.nvBarryCoords = cap.GL_NV_fragment_shader_barycentric;
+
+        if (this.compute&&this.isAmd) {
+            this.hasBrokenDepthSampler = testDepthSampler();
+            if (this.hasBrokenDepthSampler) {
+                throw new IllegalStateException("it bork, amd is bork");
+            }
+        } else {
+            this.hasBrokenDepthSampler = false;
+        }
     }
 
     public static void init() {
     }
 
+    private static boolean testDepthSampler() {
+        String src = """
+                #version 460 core
+                layout(local_size_x=16,local_size_y=16) in;
+                
+                layout(binding = 0) uniform sampler2D depthSampler;
+                layout(binding = 1) buffer OutData {
+                    float[] outData;
+                };
+                
+                layout(location = 2) uniform int dynamicSampleThing;
+                layout(location = 3) uniform float sampleData;
+                
+                void main() {
+                    if (abs(texelFetch(depthSampler, ivec2(gl_GlobalInvocationID.xy), dynamicSampleThing).r-sampleData)>0.000001f) {
+                        outData[0] = 1.0;
+                    }
+                }
+                """;
+        int program = GL20C.glCreateProgram();
+        {
+            int shader = GL20C.glCreateShader(ShaderType.COMPUTE.gl);
+            GL20C.glShaderSource(shader, src);
+            GL20C.glCompileShader(shader);
+            if (GL20C.glGetShaderi(shader, GL20C.GL_COMPILE_STATUS) != 1) {
+                GL20C.glDeleteShader(shader);
+                throw new IllegalStateException("Shader compile fail");
+            }
+            GL20C.glAttachShader(program, shader);
+            GL20C.glLinkProgram(program);
+            glDeleteShader(shader);
+        }
+
+        int buffer = glCreateBuffers();
+        glNamedBufferStorage(buffer, 4096, GL_DYNAMIC_STORAGE_BIT|GL_MAP_READ_BIT);
+
+        int tex = glCreateTextures(GL_TEXTURE_2D);
+        glTextureStorage2D(tex, 2, GL_DEPTH24_STENCIL8, 256, 256);
+        glTextureParameteri(tex, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTextureParameteri(tex, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+        int fb = glCreateFramebuffers();
+        boolean isCorrect = true;
+        for (int lvl = 0; lvl <= 1; lvl++) {
+            glNamedFramebufferTexture(fb, GL_DEPTH_STENCIL_ATTACHMENT, tex, lvl);
+
+            for (int i = 0; i <= 10; i++) {
+                float value = (float) (i / 10.0);
+
+                nglClearNamedBufferSubData(buffer, GL_R32F, 0, 4096, GL_RED, GL_FLOAT, 0);//Zero the buffer
+                glClearNamedFramebufferfi(fb, GL_DEPTH_STENCIL, 0, value, 1);//Set the depth texture
+
+                glUseProgram(program);
+                glUniform1i(2, lvl);
+                glUniform1f(3, value);
+                glBindTextureUnit(0, tex);
+                GL30.glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, buffer);
+
+                glDispatchCompute(256>>(lvl+4), 256>>(lvl+4), 1);
+                glFinish();
+
+                long ptr = nglMapNamedBuffer(buffer, GL_READ_ONLY);
+                float gottenValue = MemoryUtil.memGetFloat(ptr);
+                glUnmapNamedBuffer(buffer);
+
+                glUseProgram(0);
+                glBindTextureUnit(0, 0);
+                glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+
+                boolean localCorrect = gottenValue==0.0f;
+                if (!localCorrect) {
+                    Logger.error("Depth read test failed at value: " + value);
+                }
+                isCorrect &= localCorrect;
+            }
+        }
+
+        glDeleteFramebuffers(fb);
+        glDeleteTextures(tex);
+        glDeleteBuffers(buffer);
+        glDeleteProgram(program);
+        return !isCorrect;
+    }
+
     private static boolean testShaderCompilesOk(ShaderType type, String src) {
         int shader = GL20C.glCreateShader(type.gl);
         GL20C.glShaderSource(shader, src);

src/main/java/me/cortex/voxy/client/core/gl/GlTexture.java

@@ -96,6 +96,11 @@ public class GlTexture extends TrackedObject {
         return this.levels;
     }
 
+    public int getFormat() {
+        this.assertAllocated();
+        return this.format;
+    }
+
     private long getEstimatedSize() {
         this.assertAllocated();
         long elemSize = switch (this.format) {

src/main/java/me/cortex/voxy/client/core/gl/shader/Shader.java

@@ -69,6 +69,7 @@ public class Shader extends TrackedObject {
             J make(Builder<J> builder, int program);
         }
         final Map<String, String> defines = new HashMap<>();
+        final Map<String, String> replacements = new LinkedHashMap<>();
         private final Map<ShaderType, String> sources = new HashMap<>();
         private final IShaderProcessor processor;
         private final IShaderObjectConstructor<T> constructor;
@@ -109,11 +110,21 @@ public class Shader extends TrackedObject {
             return this;
         }
 
+        public Builder<T> define(String name, float value) {
+            this.defines.put(name, Float.toString(value)+"f");
+            return this;
+        }
+
         public Builder<T> define(String name, String value) {
             this.defines.put(name, value);
             return this;
         }
 
+        public Builder<T> replace(String value, String replacement) {
+            this.defines.put(value, replacement);
+            return this;
+        }
+
         public Builder<T> add(ShaderType type, String id) {
             this.addSource(type, ShaderLoader.parse(id));
             return this;
@@ -139,6 +150,10 @@ public class Shader extends TrackedObject {
                             defs
                             + src.substring(src.indexOf('\n')+1);
 
+                    for (var replacement : this.replacements.entrySet()) {
+                        src = src.replace(replacement.getKey(), replacement.getValue());
+                    }
+
                     shaders[i++] = createShader(entry.getKey(), src);
                 }
             }

src/main/java/me/cortex/voxy/client/core/model/MipGen.java

@@ -0,0 +1,128 @@
+package me.cortex.voxy.client.core.model;
+
+import it.unimi.dsi.fastutil.bytes.ByteArrayFIFOQueue;
+import me.cortex.voxy.common.util.MemoryBuffer;
+import net.caffeinemc.mods.sodium.client.util.color.ColorSRGB;
+import org.lwjgl.system.MemoryUtil;
+
+import java.util.Arrays;
+
+import static me.cortex.voxy.client.core.model.ModelFactory.LAYERS;
+import static me.cortex.voxy.client.core.model.ModelFactory.MODEL_TEXTURE_SIZE;
+
+public class MipGen {
+    static {
+        if (MODEL_TEXTURE_SIZE>16) throw new IllegalStateException("TODO: THIS MUST BE UPDATED, IT CURRENTLY ASSUMES 16 OR SMALLER SIZE");
+    }
+    private static final short[] SCRATCH = new short[MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE];
+    private static final ByteArrayFIFOQueue QUEUE = new ByteArrayFIFOQueue(MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE);
+
+    private static long getOffset(int bx, int by, int i) {
+        bx += i&(MODEL_TEXTURE_SIZE-1);
+        by += i/MODEL_TEXTURE_SIZE;
+        return bx+by*MODEL_TEXTURE_SIZE*3;
+    }
+
+    private static void solidify(long baseAddr, byte msk) {
+        for (int idx = 0; idx < 6; idx++) {
+            if (((msk>>idx)&1)==0) continue;
+            int bx = (idx>>1)*MODEL_TEXTURE_SIZE;
+            int by = (idx&1)*MODEL_TEXTURE_SIZE;
+            long cAddr = baseAddr + (long)(bx+by*MODEL_TEXTURE_SIZE*3)*4;
+            Arrays.fill(SCRATCH, (short) -1);
+            for (int y = 0; y<MODEL_TEXTURE_SIZE;y++) {
+                for (int x = 0; x<MODEL_TEXTURE_SIZE;x++) {
+                    int colour = MemoryUtil.memGetInt(cAddr+(x+y*MODEL_TEXTURE_SIZE*3)*4);
+                    if ((colour&0xFF000000)!=0) {
+                        int pos = x+y*MODEL_TEXTURE_SIZE;
+                        SCRATCH[pos] = ((short)pos);
+                        QUEUE.enqueue((byte) pos);
+                    }
+                }
+            }
+
+            while (!QUEUE.isEmpty()) {
+                int pos = Byte.toUnsignedInt(QUEUE.dequeueByte());
+                int x = pos&(MODEL_TEXTURE_SIZE-1);
+                int y = pos/MODEL_TEXTURE_SIZE;//this better be turned into a bitshift
+                short newVal = (short) (SCRATCH[pos]+(short) 0x0100);
+                for (int D = 3; D!=-1; D--) {
+                    int d = 2*(D&1)-1;
+                    int x2 = x+(((D&2)==2)?d:0);
+                    int y2 = y+(((D&2)==0)?d:0);
+                    if (x2<0||x2>=MODEL_TEXTURE_SIZE||y2<0||y2>=MODEL_TEXTURE_SIZE) continue;
+                    int pos2 = x2+y2*MODEL_TEXTURE_SIZE;
+                    if ((newVal&0xFF00)<(SCRATCH[pos2]&0xFF00)) {
+                        SCRATCH[pos2] = newVal;
+                        QUEUE.enqueue((byte) pos2);
+                    }
+                }
+            }
+
+            for (int i = 0; i < MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE; i++) {
+                int d = Short.toUnsignedInt(SCRATCH[i]);
+                if ((d&0xFF00)!=0) {
+                    int c = MemoryUtil.memGetInt(baseAddr+getOffset(bx, by, d&0xFF)*4)&0x00FFFFFF;
+                    MemoryUtil.memPutInt(baseAddr+getOffset(bx, by, i)*4, c);
+                }
+            }
+        }
+    }
+
+    public static void putTextures(boolean darkened, ColourDepthTextureData[] textures, MemoryBuffer into) {
+        //if (MODEL_TEXTURE_SIZE != 16) {throw new IllegalStateException("THIS METHOD MUST BE REDONE IF THIS CONST CHANGES");}
+
+        //TODO: need to use a write mask to see what pixels must be used to contribute to mipping
+        // as in, using the depth/stencil info, check if pixel was written to, if so, use that pixel when blending, else dont
+
+        final long addr = into.address;
+        final int LENGTH_B = MODEL_TEXTURE_SIZE*3;
+        byte solidMsk = 0;
+        for (int i = 0; i < 6; i++) {
+            int x = (i>>1)*MODEL_TEXTURE_SIZE;
+            int y = (i&1)*MODEL_TEXTURE_SIZE;
+            int j = 0;
+            boolean anyTransparent = false;
+            for (int t : textures[i].colour()) {
+                int o = ((y+(j>>LAYERS))*LENGTH_B + ((j&(MODEL_TEXTURE_SIZE-1))+x))*4; j++;//LAYERS here is just cause faster
+                //t = ((t&0xFF000000)==0)?0x00_FF_00_FF:t;//great for testing
+                MemoryUtil.memPutInt(addr+o, t);
+                anyTransparent |= ((t&0xFF000000)==0);
+            }
+            solidMsk |= (anyTransparent?1:0)<<i;
+        }
+
+        if (!darkened) {
+            solidify(addr, solidMsk);
+        }
+
+
+        //Mip the scratch
+        long dAddr = addr;
+        for (int i = 0; i < LAYERS-1; i++) {
+            long sAddr = dAddr;
+            dAddr += (MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE*3*2*4)>>(i<<1);//is.. i*2 because shrink both MODEL_TEXTURE_SIZE by >>i so is 2*i total shift
+            int width = (MODEL_TEXTURE_SIZE*3)>>(i+1);
+            int sWidth = (MODEL_TEXTURE_SIZE*3)>>i;
+            int height = (MODEL_TEXTURE_SIZE*2)>>(i+1);
+            //TODO: OPTIMZIE THIS
+            for (int px = 0; px < width; px++) {
+                for (int py = 0; py < height; py++) {
+                    long bp = sAddr + (px*2 + py*2*sWidth)*4;
+                    int C00 = MemoryUtil.memGetInt(bp);
+                    int C01 = MemoryUtil.memGetInt(bp+sWidth*4);
+                    int C10 = MemoryUtil.memGetInt(bp+4);
+                    int C11 = MemoryUtil.memGetInt(bp+sWidth*4+4);
+                    MemoryUtil.memPutInt(dAddr + (px+py*width) * 4L, TextureUtils.mipColours(darkened, C00, C01, C10, C11));
+                }
+            }
+        }
+
+        /*
+         */
+    }
+
+    public static void generateMipmaps(long[] textures, int size) {
+
+    }
+}

src/main/java/me/cortex/voxy/client/core/model/ModelBakerySubsystem.java

@@ -4,10 +4,6 @@ package me.cortex.voxy.client.core.model;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
 import me.cortex.voxy.common.Logger;
 import me.cortex.voxy.common.world.other.Mapper;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.registry.RegistryKeys;
-import net.minecraft.util.Identifier;
-
 import java.util.List;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -27,49 +23,31 @@ public class ModelBakerySubsystem {
     private final Mapper mapper;
     private final AtomicInteger blockIdCount = new AtomicInteger();
     private final ConcurrentLinkedDeque<Integer> blockIdQueue = new ConcurrentLinkedDeque<>();//TODO: replace with custom DS
-    private final ConcurrentLinkedDeque<Mapper.BiomeEntry> biomeQueue = new ConcurrentLinkedDeque<>();
 
+    private final Thread processingThread;
+    private volatile boolean isRunning = true;
     public ModelBakerySubsystem(Mapper mapper) {
         this.mapper = mapper;
         this.factory = new ModelFactory(mapper, this.storage);
+        this.processingThread = new Thread(()->{//TODO replace this with something good/integrate it into the async processor so that we just have less threads overall
+            while (this.isRunning) {
+                this.factory.processAllThings();
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }, "Model factory processor");
+        this.processingThread.start();
     }
 
     public void tick(long totalBudget) {
-        //Upload all biomes
+        long start = System.nanoTime();
-        while (!this.biomeQueue.isEmpty()) {
+        this.factory.tickAndProcessUploads();
-            var biome = this.biomeQueue.poll();
+        //Always do 1 iteration minimum
-            var biomeReg = MinecraftClient.getInstance().world.getRegistryManager().getOrThrow(RegistryKeys.BIOME);
+        Integer i = this.blockIdQueue.poll();
-            this.factory.addBiome(biome.id, biomeReg.get(Identifier.of(biome.biome)));
+        if (i != null) {
-        }
-
-
-        /*
-        //There should be a method to access the frame time IIRC, if the user framecap is unlimited lock it to like 60 fps for computation
-        int BUDGET = 16;//TODO: make this computed based on the remaining free time in a frame (and like div by 2 to reduce overhead) (with a min of 1)
-        if (!this.blockIdQueue.isEmpty()) {
-            int[] est = new int[Math.min(this.blockIdQueue.size(), BUDGET)];
-            int i = 0;
-            synchronized (this.blockIdQueue) {
-                for (;i < est.length && !this.blockIdQueue.isEmpty(); i++) {
-                    int blockId = this.blockIdQueue.removeFirstInt();
-                    if (blockId == -1) {
-                        i--;
-                        continue;
-                    }
-                    est[i] = blockId;
-                }
-            }
-
-            for (int j = 0; j < i; j++) {
-                this.factory.addEntry(est[j]);
-            }
-        }*/
-        //TimingStatistics.modelProcess.start();
-        if (this.blockIdCount.get() != 0) {
-            long budget = Math.min(totalBudget-150_000, totalBudget-(this.factory.resultJobs.size()*10_000L))-150_000;
-
-            //Always do 1 iteration minimum
-            Integer i = this.blockIdQueue.poll();
             int j = 0;
             if (i != null) {
                 int fbBinding = glGetInteger(GL_FRAMEBUFFER_BINDING);
@@ -77,7 +55,7 @@ public class ModelBakerySubsystem {
                 do {
                     this.factory.addEntry(i);
                     j++;
-                    if (24<j)//budget<(System.nanoTime() - start)+1000
+                    if (4<j&&(totalBudget<(System.nanoTime() - start)+50_000))//20<j||
                         break;
                     i = this.blockIdQueue.poll();
                 } while (i != null);
@@ -87,18 +65,17 @@ public class ModelBakerySubsystem {
             this.blockIdCount.addAndGet(-j);
         }
 
-        this.factory.tick();
-
-        long start = System.nanoTime();
-        while (!this.factory.resultJobs.isEmpty()) {
-            this.factory.resultJobs.poll().run();
-            if (totalBudget<(System.nanoTime()-start))
-                break;
-        }
         //TimingStatistics.modelProcess.stop();
     }
 
     public void shutdown() {
+        this.isRunning = false;
+        try {
+            this.processingThread.join();
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
         this.factory.free();
         this.storage.free();
     }
@@ -122,7 +99,7 @@ public class ModelBakerySubsystem {
     }
 
     public void addBiome(Mapper.BiomeEntry biomeEntry) {
-        this.biomeQueue.add(biomeEntry);
+        this.factory.addBiome(biomeEntry);
     }
 
     public void addDebugData(List<String> debug) {
@@ -134,7 +111,7 @@ public class ModelBakerySubsystem {
     }
 
     public boolean areQueuesEmpty() {
-        return this.blockIdCount.get()==0 && this.factory.getInflightCount() == 0 && this.biomeQueue.isEmpty();
+        return this.blockIdCount.get()==0 && this.factory.getInflightCount() == 0;
     }
 
     public int getProcessingCount() {

src/main/java/me/cortex/voxy/client/core/model/ModelFactory.java

@@ -6,37 +6,44 @@ import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
 import it.unimi.dsi.fastutil.objects.ObjectSet;
 import me.cortex.voxy.client.core.gl.Capabilities;
+import me.cortex.voxy.client.core.gl.GlBuffer;
+import me.cortex.voxy.client.core.gl.GlTexture;
 import me.cortex.voxy.client.core.model.bakery.ModelTextureBakery;
 import me.cortex.voxy.client.core.rendering.util.RawDownloadStream;
 import me.cortex.voxy.client.core.rendering.util.UploadStream;
 import me.cortex.voxy.common.Logger;
 import me.cortex.voxy.common.util.MemoryBuffer;
+import me.cortex.voxy.common.util.Pair;
 import me.cortex.voxy.common.world.other.Mapper;
-import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
-import net.minecraft.block.BlockState;
+import net.minecraft.client.color.block.BlockColor;
-import net.minecraft.block.FluidBlock;
+import net.minecraft.client.renderer.ItemBlockRenderTypes;
-import net.minecraft.block.LeavesBlock;
+import net.minecraft.client.renderer.chunk.ChunkSectionLayer;
-import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.core.BlockPos;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.core.Direction;
-import net.minecraft.client.color.block.BlockColorProvider;
+import net.minecraft.core.registries.BuiltInRegistries;
-import net.minecraft.client.render.BlockRenderLayer;
+import net.minecraft.core.registries.Registries;
-import net.minecraft.client.render.RenderLayers;
+import net.minecraft.resources.Identifier;
-import net.minecraft.fluid.FluidState;
+import net.minecraft.world.level.BlockAndTintGetter;
-import net.minecraft.registry.Registries;
+import net.minecraft.world.level.ColorResolver;
-import net.minecraft.registry.RegistryKeys;
+import net.minecraft.world.level.LightLayer;
-import net.minecraft.util.Pair;
+import net.minecraft.world.level.biome.Biome;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.level.biome.Biomes;
-import net.minecraft.util.math.Direction;
+import net.minecraft.world.level.block.Block;
-import net.minecraft.world.BlockRenderView;
+import net.minecraft.world.level.block.Blocks;
-import net.minecraft.world.LightType;
+import net.minecraft.world.level.block.LeavesBlock;
-import net.minecraft.world.biome.Biome;
+import net.minecraft.world.level.block.LiquidBlock;
-import net.minecraft.world.biome.BiomeKeys;
+import net.minecraft.world.level.block.entity.BlockEntity;
-import net.minecraft.world.biome.ColorResolver;
+import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.chunk.light.LightingProvider;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+import net.minecraft.world.level.material.FluidState;
 import org.jetbrains.annotations.Nullable;
 import org.lwjgl.system.MemoryUtil;
 
+import java.lang.invoke.VarHandle;
 import java.util.*;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.locks.ReentrantLock;
 
 import static me.cortex.voxy.client.core.model.ModelStore.MODEL_SIZE;
 import static org.lwjgl.opengl.ARBDirectStateAccess.nglTextureSubImage2D;
@@ -56,16 +63,17 @@ import static org.lwjgl.opengl.GL11.*;
 // this _quarters_ the memory requirements for the texture atlas!!! WHICH IS HUGE saving
 public class ModelFactory {
     public static final int MODEL_TEXTURE_SIZE = 16;
+    public static final int LAYERS = Integer.numberOfTrailingZeros(MODEL_TEXTURE_SIZE);
 
     //TODO: replace the fluid BlockState with a client model id integer of the fluidState, requires looking up
     // the fluid state in the mipper
-    private record ModelEntry(ColourDepthTextureData down, ColourDepthTextureData up, ColourDepthTextureData north, ColourDepthTextureData south, ColourDepthTextureData west, ColourDepthTextureData east, int fluidBlockStateId) {
+    private record ModelEntry(ColourDepthTextureData down, ColourDepthTextureData up, ColourDepthTextureData north, ColourDepthTextureData south, ColourDepthTextureData west, ColourDepthTextureData east, int fluidBlockStateId, int tintingColour) {
-        public ModelEntry(ColourDepthTextureData[] textures, int fluidBlockStateId) {
+        public ModelEntry(ColourDepthTextureData[] textures, int fluidBlockStateId, int tintingColour) {
-            this(textures[0], textures[1], textures[2], textures[3], textures[4], textures[5], fluidBlockStateId);
+            this(textures[0], textures[1], textures[2], textures[3], textures[4], textures[5], fluidBlockStateId, tintingColour);
         }
     }
 
-    private final Biome DEFAULT_BIOME = MinecraftClient.getInstance().world.getRegistryManager().getOrThrow(RegistryKeys.BIOME).get(BiomeKeys.PLAINS);
+    private final Biome DEFAULT_BIOME = Minecraft.getInstance().level.registryAccess().lookupOrThrow(Registries.BIOME).getValue(Biomes.PLAINS);
 
     public final ModelTextureBakery bakery;
 
@@ -107,6 +115,7 @@ public class ModelFactory {
     //Contains the set of all block ids that are currently inflight/being baked
     // this is required due to "async" nature of gpu feedback
     private final IntOpenHashSet blockStatesInFlight = new IntOpenHashSet();
+    private final ReentrantLock blockStatesInFlightLock = new ReentrantLock();
 
     private final List<Biome> biomes = new ArrayList<>();
     private final List<Pair<Integer, BlockState>> modelsRequiringBiomeColours = new ArrayList<>();
@@ -117,7 +126,9 @@ public class ModelFactory {
     private final ModelStore storage;
     private final RawDownloadStream downstream = new RawDownloadStream(8*1024*1024);//8mb downstream
 
-    public final Deque<Runnable> resultJobs = new ArrayDeque<>();
+    private final ConcurrentLinkedDeque<RawBakeResult> rawBakeResults = new ConcurrentLinkedDeque<>();
+
+    private final ConcurrentLinkedDeque<ResultUploader> uploadResults = new ConcurrentLinkedDeque<>();
 
     private Object2IntMap<BlockState> customBlockStateIdMapping;
 
@@ -138,15 +149,34 @@ public class ModelFactory {
         this.addEntry(0);//Add air as the first entry
     }
 
-
-    public void tick() {
-        this.downstream.tick();
-    }
-
     public void setCustomBlockStateMapping(Object2IntMap<BlockState> mapping) {
         this.customBlockStateIdMapping = mapping;
     }
 
+    private static final class RawBakeResult {
+        private final int blockId;
+        private final BlockState blockState;
+        private final MemoryBuffer rawData;
+
+        public boolean isShaded;
+        public boolean hasDarkenedTextures;
+
+        public RawBakeResult(int blockId, BlockState blockState, MemoryBuffer rawData) {
+            this.blockId = blockId;
+            this.blockState = blockState;
+            this.rawData = rawData;
+        }
+
+        public RawBakeResult(int blockId, BlockState blockState) {
+            this(blockId, blockState, new MemoryBuffer(MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE*2*4*6));
+        }
+
+        public RawBakeResult cpyBuf(long ptr) {
+            this.rawData.cpyFrom(ptr);
+            return this;
+        }
+    }
+
     public boolean addEntry(int blockId) {
         if (this.idMappings[blockId] != -1) {
             return false;
@@ -154,19 +184,29 @@ public class ModelFactory {
         //We are (probably) going to be baking the block id
         // check that it is currently not inflight, if it is, return as its already being baked
         // else add it to the flight as it is going to be baked
+        this.blockStatesInFlightLock.lock();
         if (!this.blockStatesInFlight.add(blockId)) {
+            this.blockStatesInFlightLock.unlock();
             //Block baking is already in-flight
             return false;
         }
+        this.blockStatesInFlightLock.unlock();
+
+        VarHandle.loadLoadFence();
+
+        //We need to get it twice cause of threading
+        if (this.idMappings[blockId] != -1) {
+            return false;
+        }
 
         var blockState = this.mapper.getBlockStateFromBlockId(blockId);
 
         //Before we enqueue the baking of this blockstate, we must check if it has a fluid state associated with it
         // if it does, we must ensure that it is (effectivly) baked BEFORE we bake this blockstate
-        boolean isFluid = blockState.getBlock() instanceof FluidBlock;
+        boolean isFluid = blockState.getBlock() instanceof LiquidBlock;
         if ((!isFluid) && (!blockState.getFluidState().isEmpty())) {
             //Insert into the fluid LUT
-            var fluidState = blockState.getFluidState().getBlockState();
+            var fluidState = blockState.getFluidState().createLegacyBlock();
 
             int fluidStateId = this.mapper.getIdForBlockState(fluidState);
 
@@ -179,44 +219,144 @@ public class ModelFactory {
             }
         }
 
-        int TOTAL_FACES_TEXTURE_SIZE = MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE*2*4*6;// since both depth and colour are packed together, 6 faces, 4 bytes per pixel
+        RawBakeResult result = new RawBakeResult(blockId, blockState);
-        int allocation = this.downstream.download(TOTAL_FACES_TEXTURE_SIZE, ptr -> {
+        int allocation = this.downstream.download(MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE*2*4*6, ptr -> this.rawBakeResults.add(result.cpyBuf(ptr)));
-            ColourDepthTextureData[] textureData = new ColourDepthTextureData[6];
+        int flags = this.bakery.renderToStream(blockState, this.downstream.getBufferId(), allocation);
-            final int FACE_SIZE = MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE;
+        result.hasDarkenedTextures = (flags&2)!=0;
+        result.isShaded = (flags&1)!=0;
+        return true;
+    }
+
+    private boolean processModelResult() {
+        var result = this.rawBakeResults.poll();
+        if (result == null) return false;
+        ColourDepthTextureData[] textureData = new ColourDepthTextureData[6];
+        {//Create texture data
+            long ptr = result.rawData.address;
+            final int FACE_SIZE = MODEL_TEXTURE_SIZE * MODEL_TEXTURE_SIZE;
             for (int face = 0; face < 6; face++) {
-                long faceDataPtr = ptr + (FACE_SIZE*4)*face*2;
+                long faceDataPtr = ptr + (FACE_SIZE * 4) * face * 2;
                 int[] colour = new int[FACE_SIZE];
                 int[] depth = new int[FACE_SIZE];
 
                 //Copy out colour
                 for (int i = 0; i < FACE_SIZE; i++) {
                     //De-interpolate results
-                    colour[i] = MemoryUtil.memGetInt(faceDataPtr+ (i*4*2));
+                    colour[i] = MemoryUtil.memGetInt(faceDataPtr + (i * 4 * 2));
-                    depth[i] = MemoryUtil.memGetInt(faceDataPtr+ (i*4*2)+4);
+                    depth[i] = MemoryUtil.memGetInt(faceDataPtr + (i * 4 * 2) + 4);
                 }
-
                 textureData[face] = new ColourDepthTextureData(colour, depth, MODEL_TEXTURE_SIZE, MODEL_TEXTURE_SIZE);
             }
-            this.resultJobs.add(()->processTextureBakeResult(blockId, blockState, textureData));
+        }
-        });
+        result.rawData.free();
-        this.bakery.renderToStream(blockState, this.downstream.getBufferId(), allocation);
+        var bakeResult = this.processTextureBakeResult(result.blockId, result.blockState, textureData, result.isShaded, result.hasDarkenedTextures);
-        return true;
+        if (bakeResult!=null) {
+            this.uploadResults.add(bakeResult);
+        }
+        return !this.rawBakeResults.isEmpty();
     }
 
+    private final ConcurrentLinkedDeque<Mapper.BiomeEntry> biomeQueue = new ConcurrentLinkedDeque<>();
+    public void addBiome(Mapper.BiomeEntry biome) {
+        this.biomeQueue.add(biome);
+    }
 
+    public void processAllThings() {
+        var biomeEntry = this.biomeQueue.poll();
+        while (biomeEntry != null) {
+            var biomeRegistry = Minecraft.getInstance().level.registryAccess().lookupOrThrow(Registries.BIOME);
+            var res = this.addBiome0(biomeEntry.id, biomeRegistry.getValue(Identifier.parse(biomeEntry.biome)));
+            if (res != null) {
+                this.uploadResults.add(res);
+            }
+            biomeEntry = this.biomeQueue.poll();
+        }
 
-    //This is
+        while (this.processModelResult());
-    private void processTextureBakeResult(int blockId, BlockState blockState, ColourDepthTextureData[] textureData) {
+    }
+
+    public void tickAndProcessUploads() {
+        this.downstream.tick();
+
+        var upload = this.uploadResults.poll();
+        if (upload==null) return;
+
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+        glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+        glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
+        do {
+            upload.upload(this.storage);
+            upload.free();
+            upload = this.uploadResults.poll();
+        } while (upload != null);
+        UploadStream.INSTANCE.commit();
+    }
+
+    private interface ResultUploader {
+        void upload(ModelStore store);
+        void free();
+    }
+
+    private static final class ModelBakeResultUpload implements ResultUploader {
+        private final MemoryBuffer model = new MemoryBuffer(MODEL_SIZE).zero();
+        private final MemoryBuffer texture = new MemoryBuffer((2L*3*computeSizeWithMips(MODEL_TEXTURE_SIZE))*4);
+
+        public int modelId = -1;
+
+        public int biomeUploadIndex = -1;
+        public @Nullable MemoryBuffer biomeUpload;
+
+        public void upload(ModelStore store) {//Uploads and resets for reuse
+            this.upload(store.modelBuffer, store.modelColourBuffer, store.textures);
+        }
+
+        public void upload(GlBuffer modelBuffer, GlBuffer colourBuffer, GlTexture atlas) {//Uploads and resets for reuse
+            this.model.cpyTo(UploadStream.INSTANCE.upload(modelBuffer, (long) this.modelId * MODEL_SIZE, MODEL_SIZE));
+            if (this.biomeUploadIndex != -1) {
+                this.biomeUpload.cpyTo(UploadStream.INSTANCE.upload(colourBuffer, this.biomeUploadIndex * 4L, this.biomeUpload.size));
+                this.biomeUploadIndex = -1;
+                this.biomeUpload.free();
+                this.biomeUpload = null;
+            }
+
+            int X = (this.modelId&0xFF) * MODEL_TEXTURE_SIZE*3;
+            int Y = ((this.modelId>>8)&0xFF) * MODEL_TEXTURE_SIZE*2;
+
+            long cAddr = this.texture.address;
+            for (int lvl = 0; lvl < LAYERS; lvl++) {
+                nglTextureSubImage2D(atlas.id, lvl, X >> lvl, Y >> lvl, (MODEL_TEXTURE_SIZE*3) >> lvl, (MODEL_TEXTURE_SIZE*2) >> lvl, GL_RGBA, GL_UNSIGNED_BYTE, cAddr);
+                cAddr += (MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE*3*2*4)>>(lvl<<1);
+            }
+
+            this.modelId = -1;
+        }
+
+        public void free() {
+            this.model.free();
+            this.texture.free();
+            if (this.biomeUpload != null) {
+                this.biomeUpload.free();
+            }
+        }
+    }
+
+    private ModelBakeResultUpload processTextureBakeResult(int blockId, BlockState blockState, ColourDepthTextureData[] textureData, boolean isShaded, boolean darkenedTinting) {
         if (this.idMappings[blockId] != -1) {
             //This should be impossible to reach as it means that multiple bakes for the same blockId happened and where inflight at the same time!
             throw new IllegalStateException("Block id already added: " + blockId + " for state: " + blockState);
         }
 
+        this.blockStatesInFlightLock.lock();
         if (!this.blockStatesInFlight.contains(blockId)) {
+            this.blockStatesInFlightLock.unlock();
             throw new IllegalStateException("processing a texture bake result but the block state was not in flight!!");
         }
+        this.blockStatesInFlightLock.unlock();
 
-        boolean isFluid = blockState.getBlock() instanceof FluidBlock;
+        //TODO: add thing for `blockState.hasEmissiveLighting()` and `blockState.getLuminance()`
+
+        boolean isFluid = blockState.getBlock() instanceof LiquidBlock;
         int modelId = -1;
 
 
@@ -224,7 +364,7 @@ public class ModelFactory {
 
         if ((!isFluid) && (!blockState.getFluidState().isEmpty())) {
             //Insert into the fluid LUT
-            var fluidState = blockState.getFluidState().getBlockState();
+            var fluidState = blockState.getFluidState().createLegacyBlock();
 
             int fluidStateId = this.mapper.getIdForBlockState(fluidState);
 
@@ -234,17 +374,28 @@ public class ModelFactory {
             }
         }
 
+        var colourProvider = getColourProvider(blockState.getBlock());
+
+        boolean isBiomeColourDependent = false;
+        if (colourProvider != null) {
+            isBiomeColourDependent = isBiomeDependentColour(colourProvider, blockState);
+        }
+
+        ModelEntry entry;
         {//Deduplicate same entries
-            var entry = new ModelEntry(textureData, clientFluidStateId);
+            entry = new ModelEntry(textureData, clientFluidStateId, isBiomeColourDependent||colourProvider==null?-1:captureColourConstant(colourProvider, blockState, DEFAULT_BIOME)|0xFF000000);
             int possibleDuplicate = this.modelTexture2id.getInt(entry);
             if (possibleDuplicate != -1) {//Duplicate found
                 this.idMappings[blockId] = possibleDuplicate;
                 modelId = possibleDuplicate;
                 //Remove from flight
+                this.blockStatesInFlightLock.lock();
                 if (!this.blockStatesInFlight.remove(blockId)) {
+                    this.blockStatesInFlightLock.unlock();
                     throw new IllegalStateException();
                 }
-                return;
+                this.blockStatesInFlightLock.unlock();
+                return null;
             } else {//Not a duplicate so create a new entry
                 modelId = this.modelTexture2id.size();
                 //NOTE: we set the mapping at the very end so that race conditions with this and getMetadata dont occur
@@ -259,33 +410,30 @@ public class ModelFactory {
             this.fluidStateLUT[modelId] = clientFluidStateId;
         }
 
-        BlockRenderLayer blockRenderLayer = null;
+        ChunkSectionLayer blockRenderLayer = null;
-        if (blockState.getBlock() instanceof FluidBlock) {
+        if (blockState.getBlock() instanceof LiquidBlock) {
-            blockRenderLayer = RenderLayers.getFluidLayer(blockState.getFluidState());
+            blockRenderLayer = ItemBlockRenderTypes.getRenderLayer(blockState.getFluidState());
         } else {
             if (blockState.getBlock() instanceof LeavesBlock) {
-                blockRenderLayer = BlockRenderLayer.SOLID;
+                blockRenderLayer = ChunkSectionLayer.SOLID;
             } else {
-                blockRenderLayer = RenderLayers.getBlockLayer(blockState);
+                blockRenderLayer = ItemBlockRenderTypes.getChunkRenderType(blockState);
             }
         }
 
 
-        int checkMode = blockRenderLayer==BlockRenderLayer.SOLID?TextureUtils.WRITE_CHECK_STENCIL:TextureUtils.WRITE_CHECK_ALPHA;
+        int checkMode = blockRenderLayer==ChunkSectionLayer.SOLID?TextureUtils.WRITE_CHECK_STENCIL:TextureUtils.WRITE_CHECK_ALPHA;
 
 
-        var colourProvider = getColourProvider(blockState.getBlock());
 
 
-        long uploadPtr = UploadStream.INSTANCE.upload(this.storage.modelBuffer, (long) modelId * MODEL_SIZE, MODEL_SIZE);
+        ModelBakeResultUpload uploadResult = new ModelBakeResultUpload();
-
+        uploadResult.modelId = modelId;
+        long uploadPtr = uploadResult.model.address;
 
         //TODO: implement;
         // TODO: if it has a constant colour instead... idk why (apparently for things like spruce leaves)?? but premultiply the texture data by the constant colour
-        boolean isBiomeColourDependent = false;
+
-        if (colourProvider != null) {
-            isBiomeColourDependent = isBiomeDependentColour(colourProvider, blockState);
-        }
         //If it contains fluid but isnt a fluid
         if ((!isFluid) && (!blockState.getFluidState().isEmpty()) && clientFluidStateId != -1) {
 
@@ -298,12 +446,12 @@ public class ModelFactory {
         //TODO: special case stuff like vines and glow lichen, where it can be represented by a single double sided quad
         // since that would help alot with perf of lots of vines, can be done by having one of the faces just not exist and the other be in no occlusion mode
 
-        var sizes = this.computeModelDepth(textureData, checkMode);
+        var depths = this.computeModelDepth(textureData, checkMode);
 
         //TODO: THIS, note this can be tested for in 2 ways, re render the model with quad culling disabled and see if the result
         // is the same, (if yes then needs double sided quads)
         // another way to test it is if e.g. up and down havent got anything rendered but the sides do (e.g. all plants etc)
-        boolean needsDoubleSidedQuads = (sizes[0] < -0.1 && sizes[1] < -0.1) || (sizes[2] < -0.1 && sizes[3] < -0.1) || (sizes[4] < -0.1 && sizes[5] < -0.1);
+        boolean needsDoubleSidedQuads = (depths[0] < -0.1 && depths[1] < -0.1) || (depths[2] < -0.1 && depths[3] < -0.1) || (depths[4] < -0.1 && depths[5] < -0.1);
 
 
         boolean cullsSame = false;
@@ -314,7 +462,7 @@ public class ModelFactory {
             boolean allFalse = true;
             //Guestimation test for if the block culls itself
             for (var dir : Direction.values()) {
-                if (blockState.isSideInvisible(blockState, dir)) {
+                if (blockState.skipRendering(blockState, dir)) {
                     allFalse = false;
                 } else {
                     allTrue = false;
@@ -336,7 +484,7 @@ public class ModelFactory {
         //Each face gets 1 byte, with the top 2 bytes being for whatever
         long metadata = 0;
         metadata |= isBiomeColourDependent?1:0;
-        metadata |= blockRenderLayer == BlockRenderLayer.TRANSLUCENT?2:0;
+        metadata |= blockRenderLayer == ChunkSectionLayer.TRANSLUCENT?2:0;
         metadata |= needsDoubleSidedQuads?4:0;
         metadata |= ((!isFluid) && !blockState.getFluidState().isEmpty())?8:0;//Has a fluid state accosiacted with it and is not itself a fluid
         metadata |= isFluid?16:0;//Is a fluid
@@ -351,7 +499,7 @@ public class ModelFactory {
         for (int face = 5; face != -1; face--) {//In reverse order to make indexing into the metadata long easier
             long faceUploadPtr = uploadPtr + 4L * face;//Each face gets 4 bytes worth of data
             metadata <<= 8;
-            float offset = sizes[face];
+            float offset = depths[face];
             if (offset < -0.1) {//Face is empty, so ignore
                 metadata |= 0xFF;//Mark the face as non-existent
                 //Set to -1 as safepoint
@@ -372,7 +520,7 @@ public class ModelFactory {
 
             //TODO: add alot of config options for the following
             boolean occludesFace = true;
-            occludesFace &= blockRenderLayer != BlockRenderLayer.TRANSLUCENT;//If its translucent, it doesnt occlude
+            occludesFace &= blockRenderLayer != ChunkSectionLayer.TRANSLUCENT;//If its translucent, it doesnt occlude
 
             //TODO: make this an option, basicly if the face is really close, it occludes otherwise it doesnt
             occludesFace &= offset < 0.1;//If the face is rendered far away from the other face, then it doesnt occlude
@@ -392,7 +540,7 @@ public class ModelFactory {
             metadata |= canBeOccluded?4:0;
 
             //Face uses its own lighting if its not flat against the adjacent block & isnt traslucent
-            metadata |= (offset > 0.01 || blockRenderLayer == BlockRenderLayer.TRANSLUCENT)?0b1000:0;
+            metadata |= (offset > 0.01 || blockRenderLayer == ChunkSectionLayer.TRANSLUCENT)?0b1000:0;
 
 
 
@@ -408,18 +556,18 @@ public class ModelFactory {
             //Change the scale from 0->1 (ends inclusive)
             // this is cursed also warning stuff at 63 (i.e half a pixel from the end will be clamped to the end)
             int enc = Math.round(offset*64);
-            faceModelData |= Math.min(enc,63)<<16;
+            faceModelData |= Math.min(enc,62)<<16;
             //Still have 11 bits free
 
             //Stuff like fences are solid, however they have extra side piece that mean it needs to have discard on
             int area = (faceSize[1]-faceSize[0]+1) * (faceSize[3]-faceSize[2]+1);
             boolean needsAlphaDiscard = ((float)writeCount)/area<0.9;//If the amount of area covered by written pixels is less than a threashold, disable discard as its not needed
 
-            needsAlphaDiscard |= blockRenderLayer != BlockRenderLayer.SOLID;
+            needsAlphaDiscard |= blockRenderLayer != ChunkSectionLayer.SOLID;
-            needsAlphaDiscard &= blockRenderLayer != BlockRenderLayer.TRANSLUCENT;//Translucent doesnt have alpha discard
+            needsAlphaDiscard &= blockRenderLayer != ChunkSectionLayer.TRANSLUCENT;//Translucent doesnt have alpha discard
             faceModelData |= needsAlphaDiscard?1<<22:0;
 
-            faceModelData |= ((!faceCoversFullBlock)&&blockRenderLayer != BlockRenderLayer.TRANSLUCENT)?1<<23:0;//Alpha discard override, translucency doesnt have alpha discard
+            faceModelData |= ((!faceCoversFullBlock)&&blockRenderLayer != ChunkSectionLayer.TRANSLUCENT)?1<<23:0;//Alpha discard override, translucency doesnt have alpha discard
 
             //Bits 24,25 are tint metadata
             if (colourProvider!=null) {//We have a tint
@@ -447,8 +595,11 @@ public class ModelFactory {
         int modelFlags = 0;
         modelFlags |= colourProvider != null?1:0;
         modelFlags |= isBiomeColourDependent?2:0;//Basicly whether to use the next int as a colour or as a base index/id into a colour buffer for biome dependent colours
-        modelFlags |= blockRenderLayer == BlockRenderLayer.TRANSLUCENT?4:0;//Is translucent
+        modelFlags |= blockRenderLayer == ChunkSectionLayer.TRANSLUCENT?4:0;//Is translucent
-        modelFlags |= blockRenderLayer == BlockRenderLayer.CUTOUT?0:8;//Dont use mipmaps (AND ALSO FKING SPECIFIES IF IT HAS AO, WHY??? GREAT QUESTION, TODO FIXE THIS)
+
+
+        //TODO: THIS
+        modelFlags |= isShaded?8:0;//model has AO and shade
 
         //modelFlags |= blockRenderLayer == RenderLayer.getSolid()?0:1;// should discard alpha
         MemoryUtil.memPutInt(uploadPtr, modelFlags); uploadPtr += 4;
@@ -458,15 +609,15 @@ public class ModelFactory {
         if (colourProvider == null) {
             MemoryUtil.memPutInt(uploadPtr, -1);//Set the default to nothing so that its faster on the gpu
         } else if (!isBiomeColourDependent) {
-            MemoryUtil.memPutInt(uploadPtr, captureColourConstant(colourProvider, blockState, DEFAULT_BIOME)|0xFF000000);
+            MemoryUtil.memPutInt(uploadPtr, entry.tintingColour);
         } else if (!this.biomes.isEmpty()) {
             //Populate the list of biomes for the model state
             int biomeIndex = this.modelsRequiringBiomeColours.size() * this.biomes.size();
             MemoryUtil.memPutInt(uploadPtr, biomeIndex);
             this.modelsRequiringBiomeColours.add(new Pair<>(modelId, blockState));
-            //NOTE: UploadStream.INSTANCE is called _after_ uploadPtr is finished being used, this is cause the upload pointer
+
-            // may be invalidated as soon as another upload stream is invoked
+            uploadResult.biomeUploadIndex = biomeIndex;
-            long clrUploadPtr = UploadStream.INSTANCE.upload(this.storage.modelColourBuffer, biomeIndex * 4L, 4L * this.biomes.size());
+            long clrUploadPtr = (uploadResult.biomeUpload = new MemoryBuffer(4L * this.biomes.size())).address;
             for (var biome : this.biomes) {
                 MemoryUtil.memPutInt(clrUploadPtr, captureColourConstant(colourProvider, blockState, biome)|0xFF000000); clrUploadPtr += 4;
             }
@@ -489,23 +640,58 @@ public class ModelFactory {
         //TODO callback to inject extra data into the model data
 
 
-        this.putTextures(modelId, textureData);
+        MipGen.putTextures(darkenedTinting, textureData, uploadResult.texture);
 
         //glGenerateTextureMipmap(this.textures.id);
 
         //Set the mapping at the very end
         this.idMappings[blockId] = modelId;
 
+        this.blockStatesInFlightLock.lock();
         if (!this.blockStatesInFlight.remove(blockId)) {
+            this.blockStatesInFlightLock.unlock();
             throw new IllegalStateException("processing a texture bake result but the block state was not in flight!!");
         }
+        this.blockStatesInFlightLock.unlock();
 
-        //Upload/commit stream
+        return uploadResult;
-        //TODO maybe dont do it for every uploaded block?? try to batch it
-        UploadStream.INSTANCE.commit();
     }
 
-    public void addBiome(int id, Biome biome) {
+    private static final class BiomeUploadResult implements ResultUploader {
+        private final MemoryBuffer biomeColourBuffer;
+        private final MemoryBuffer modelBiomeIndexPairs;
+        private BiomeUploadResult(int biomes, int models) {
+            this.biomeColourBuffer = new MemoryBuffer(biomes*models*4);
+            this.modelBiomeIndexPairs = new MemoryBuffer(models*8);
+        }
+
+        public void upload(ModelStore store) {
+            this.upload(store.modelBuffer, store.modelColourBuffer);
+        }
+
+        public void upload(GlBuffer modelBuffer, GlBuffer modelColourBuffer) {
+            this.biomeColourBuffer.cpyTo(UploadStream.INSTANCE.upload(modelColourBuffer, 0, this.biomeColourBuffer.size));
+
+            //TODO: optimize this to like a compute scatter update or something
+            long ptr = this.modelBiomeIndexPairs.address;
+            for (long offset = 0; offset < this.modelBiomeIndexPairs.size; offset += 8) {
+                long v = MemoryUtil.memGetLong(ptr);ptr += 8;
+                MemoryUtil.memPutInt(UploadStream.INSTANCE.upload(modelBuffer, (MODEL_SIZE*(v&((1L<<32)-1)))+ 4*6 + 4, 4), (int) (v>>>32));
+            }
+
+            this.biomeColourBuffer.free();
+            this.modelBiomeIndexPairs.free();
+        }
+
+        public void free() {
+            if (!this.biomeColourBuffer.isFreed()) {
+                this.biomeColourBuffer.free();
+                this.modelBiomeIndexPairs.free();
+            }
+        }
+    }
+
+    private BiomeUploadResult addBiome0(int id, Biome biome) {
         for (int i = this.biomes.size(); i <= id; i++) {
             this.biomes.add(null);
         }
@@ -518,53 +704,58 @@ public class ModelFactory {
             Logger.error("Biome added was a duplicate");
         }
 
+        if (this.modelsRequiringBiomeColours.isEmpty()) return null;
+
+        var result = new BiomeUploadResult(this.biomes.size(), this.modelsRequiringBiomeColours.size());
+
         int i = 0;
+        long modelUpPtr = result.modelBiomeIndexPairs.address;
         for (var entry : this.modelsRequiringBiomeColours) {
-            var colourProvider = getColourProvider(entry.getRight().getBlock());
+            var colourProvider = getColourProvider(entry.right().getBlock());
             if (colourProvider == null) {
                 throw new IllegalStateException();
             }
             //Populate the list of biomes for the model state
             int biomeIndex = (i++) * this.biomes.size();
-            MemoryUtil.memPutInt(UploadStream.INSTANCE.upload(this.storage.modelBuffer, (entry.getLeft()* MODEL_SIZE)+ 4*6 + 4, 4), biomeIndex);
+            MemoryUtil.memPutLong(modelUpPtr, Integer.toUnsignedLong(entry.left())|(Integer.toUnsignedLong(biomeIndex)<<32));modelUpPtr+=8;
-            long clrUploadPtr = UploadStream.INSTANCE.upload(this.storage.modelColourBuffer, biomeIndex * 4L, 4L * this.biomes.size());
+            long clrUploadPtr = result.biomeColourBuffer.address + biomeIndex * 4L;
             for (var biomeE : this.biomes) {
                 if (biomeE == null) {
                     continue;//If null, ignore
                 }
-                MemoryUtil.memPutInt(clrUploadPtr, captureColourConstant(colourProvider, entry.getRight(), biomeE)|0xFF000000); clrUploadPtr += 4;
+                MemoryUtil.memPutInt(clrUploadPtr, captureColourConstant(colourProvider, entry.right(), biomeE)|0xFF000000); clrUploadPtr += 4;
             }
         }
 
-        UploadStream.INSTANCE.commit();
+        return result;
     }
 
-    private static BlockColorProvider getColourProvider(Block block) {
+    private static BlockColor getColourProvider(Block block) {
-        return MinecraftClient.getInstance().getBlockColors().providers.get(Registries.BLOCK.getRawId(block));
+        return Minecraft.getInstance().getBlockColors().blockColors.byId(BuiltInRegistries.BLOCK.getId(block));
     }
 
     //TODO: add a method to detect biome dependent colours (can do by detecting if getColor is ever called)
     // if it is, need to add it to a list and mark it as biome colour dependent or something then the shader
     // will either use the uint as an index or a direct colour multiplier
-    private static int captureColourConstant(BlockColorProvider colorProvider, BlockState state, Biome biome) {
+    private static int captureColourConstant(BlockColor colorProvider, BlockState state, Biome biome) {
-        return colorProvider.getColor(state, new BlockRenderView() {
+        var getter = new BlockAndTintGetter() {
             @Override
-            public float getBrightness(Direction direction, boolean shaded) {
+            public float getShade(Direction direction, boolean shaded) {
                 return 0;
             }
 
             @Override
-            public int getLightLevel(LightType type, BlockPos pos) {
+            public int getBrightness(LightLayer type, BlockPos pos) {
                 return 0;
             }
 
             @Override
-            public LightingProvider getLightingProvider() {
+            public LevelLightEngine getLightEngine() {
                 return null;
             }
 
             @Override
-            public int getColor(BlockPos pos, ColorResolver colorResolver) {
+            public int getBlockTint(BlockPos pos, ColorResolver colorResolver) {
                 return colorResolver.getColor(biome, 0, 0);
             }
 
@@ -590,32 +781,36 @@ public class ModelFactory {
             }
 
             @Override
-            public int getBottomY() {
+            public int getMinY() {
                 return 0;
             }
-        }, BlockPos.ORIGIN, 0);
+        };
+        //Multiple layer bs to do with flower beds
+        int c = colorProvider.getColor(state, getter, BlockPos.ZERO, 0);
+        if (c!=-1) return c;
+        return colorProvider.getColor(state, getter, BlockPos.ZERO, 1);
     }
 
-    private static boolean isBiomeDependentColour(BlockColorProvider colorProvider, BlockState state) {
+    private static boolean isBiomeDependentColour(BlockColor colorProvider, BlockState state) {
         boolean[] biomeDependent = new boolean[1];
-        colorProvider.getColor(state, new BlockRenderView() {
+        var getter = new BlockAndTintGetter() {
             @Override
-            public float getBrightness(Direction direction, boolean shaded) {
+            public float getShade(Direction direction, boolean shaded) {
                 return 0;
             }
 
             @Override
-            public int getLightLevel(LightType type, BlockPos pos) {
+            public int getBrightness(LightLayer type, BlockPos pos) {
                 return 0;
             }
 
             @Override
-            public LightingProvider getLightingProvider() {
+            public LevelLightEngine getLightEngine() {
                 return null;
             }
 
             @Override
-            public int getColor(BlockPos pos, ColorResolver colorResolver) {
+            public int getBlockTint(BlockPos pos, ColorResolver colorResolver) {
                 biomeDependent[0] = true;
                 return 0;
             }
@@ -642,17 +837,19 @@ public class ModelFactory {
             }
 
             @Override
-            public int getBottomY() {
+            public int getMinY() {
                 return 0;
             }
-        }, BlockPos.ORIGIN, 0);
+        };
+        colorProvider.getColor(state, getter, BlockPos.ZERO, 0);
+        colorProvider.getColor(state, getter, BlockPos.ZERO, 1);
         return biomeDependent[0];
     }
 
-    private float[] computeModelDepth(ColourDepthTextureData[] textures, int checkMode) {
+    private static float[] computeModelDepth(ColourDepthTextureData[] textures, int checkMode) {
         float[] res = new float[6];
         for (var dir : Direction.values()) {
-            var data = textures[dir.getIndex()];
+            var data = textures[dir.get3DDataValue()];
             float fd = TextureUtils.computeDepth(data, TextureUtils.DEPTH_MODE_AVG, checkMode);//Compute the min float depth, smaller means closer to the camera, range 0-1
             //int depth = Math.round(fd * MODEL_TEXTURE_SIZE);
             //If fd is -1, it means that there was nothing rendered on that face and it should be discarded
@@ -694,73 +891,15 @@ public class ModelFactory {
     }
 
 
-    private static int computeSizeWithMips(int size) {
-        int total = 0;
-        for (;size!=0;size>>=1) total += size*size;
-        return total;
-    }
-    private static final MemoryBuffer SCRATCH_TEX = new MemoryBuffer((2L*3*computeSizeWithMips(MODEL_TEXTURE_SIZE))*4);
-    private static final int LAYERS = Integer.numberOfTrailingZeros(MODEL_TEXTURE_SIZE);
-    //TODO: redo to batch blit, instead of 6 seperate blits, and also fix mipping
-    private void putTextures(int id, ColourDepthTextureData[] textures) {
-        //if (MODEL_TEXTURE_SIZE != 16) {throw new IllegalStateException("THIS METHOD MUST BE REDONE IF THIS CONST CHANGES");}
-
-        //TODO: need to use a write mask to see what pixels must be used to contribute to mipping
-        // as in, using the depth/stencil info, check if pixel was written to, if so, use that pixel when blending, else dont
-
-        //Copy all textures into scratch
-        final long addr = SCRATCH_TEX.address;
-        final int LENGTH_B = MODEL_TEXTURE_SIZE*3;
-        for (int i = 0; i < 6; i++) {
-            int x = (i>>1)*MODEL_TEXTURE_SIZE;
-            int y = (i&1)*MODEL_TEXTURE_SIZE;
-            int j = 0;
-            for (int t : textures[i].colour()) {
-                int o = ((y+(j>>LAYERS))*LENGTH_B + ((j&(MODEL_TEXTURE_SIZE-1))+x))*4; j++;//LAYERS here is just cause faster
-                MemoryUtil.memPutInt(addr+o, t);
-            }
-        }
-
-        //Mip the scratch
-        long dAddr = addr;
-        for (int i = 0; i < LAYERS-1; i++) {
-            long sAddr = dAddr;
-            dAddr += (MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE*3*2*4)>>(i<<1);//is.. i*2 because shrink both MODEL_TEXTURE_SIZE by >>i so is 2*i total shift
-            int width = (MODEL_TEXTURE_SIZE*3)>>(i+1);
-            int sWidth = (MODEL_TEXTURE_SIZE*3)>>i;
-            int height = (MODEL_TEXTURE_SIZE*2)>>(i+1);
-            //TODO: OPTIMZIE THIS
-            for (int px = 0; px < width; px++) {
-                for (int py = 0; py < height; py++) {
-                    long bp = sAddr + (px*2 + py*2*sWidth)*4;
-                    int C00 = MemoryUtil.memGetInt(bp);
-                    int C01 = MemoryUtil.memGetInt(bp+sWidth*4);
-                    int C10 = MemoryUtil.memGetInt(bp+4);
-                    int C11 = MemoryUtil.memGetInt(bp+sWidth*4+4);
-                    MemoryUtil.memPutInt(dAddr + (px+py*width) * 4L, TextureUtils.mipColours(C00, C01, C10, C11));
-                }
-            }
-        }
-
-
-        int X = (id&0xFF) * MODEL_TEXTURE_SIZE*3;
-        int Y = ((id>>8)&0xFF) * MODEL_TEXTURE_SIZE*2;
-
-        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-        glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-        glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-        glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
-
-        long cAddr = addr;
-        for (int lvl = 0; lvl < LAYERS; lvl++) {
-            nglTextureSubImage2D(this.storage.textures.id, lvl, X >> lvl, Y >> lvl, (MODEL_TEXTURE_SIZE*3) >> lvl, (MODEL_TEXTURE_SIZE*2) >> lvl, GL_RGBA, GL_UNSIGNED_BYTE, cAddr);
-            cAddr += (MODEL_TEXTURE_SIZE*MODEL_TEXTURE_SIZE*3*2*4)>>(lvl<<1);
-        }
-    }
-
     public void free() {
-        this.downstream.free();
         this.bakery.free();
+        this.downstream.free();
+        while (!this.rawBakeResults.isEmpty()) {
+            this.rawBakeResults.poll().rawData.free();
+        }
+        while (!this.uploadResults.isEmpty()) {
+            this.uploadResults.poll().free();
+        }
     }
 
     public int getBakedCount() {
@@ -768,6 +907,17 @@ public class ModelFactory {
     }
 
     public int getInflightCount() {
-        return this.blockStatesInFlight.size();
+        //TODO replace all of this with an atomic?
+        int size = this.blockStatesInFlight.size();
+        size += this.uploadResults.size();
+        size += this.biomeQueue.size();
+        return size;
+    }
+
+
+    private static int computeSizeWithMips(int size) {
+        int total = 0;
+        for (;size!=0;size>>=1) total += size*size;
+        return total;
     }
 }

src/main/java/me/cortex/voxy/client/core/model/ModelStore.java

@@ -2,9 +2,9 @@ package me.cortex.voxy.client.core.model;
 
 import me.cortex.voxy.client.core.gl.GlBuffer;
 import me.cortex.voxy.client.core.gl.GlTexture;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
-import net.minecraft.client.texture.SpriteAtlasTexture;
+import net.minecraft.client.renderer.texture.TextureAtlas;
-import net.minecraft.util.Identifier;
+import net.minecraft.resources.Identifier;
 
 import static org.lwjgl.opengl.GL11.*;
 import static org.lwjgl.opengl.GL11C.GL_NEAREST;
@@ -31,9 +31,9 @@ public class ModelStore {
 
 
         //Limit the mips of the texture to match that of the terrain atlas
-        int mipLvl = ((SpriteAtlasTexture) MinecraftClient.getInstance().getTextureManager()
+        int mipLvl = ((TextureAtlas) Minecraft.getInstance().getTextureManager()
-                .getTexture(Identifier.of("minecraft", "textures/atlas/blocks.png")))
+                .getTexture(Identifier.fromNamespaceAndPath("minecraft", "textures/atlas/blocks.png")))
-                .mipLevel;
+                .maxMipLevel;
 
         glSamplerParameteri(this.blockSampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
         glSamplerParameteri(this.blockSampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

src/main/java/me/cortex/voxy/client/core/model/TextureUtils.java

@@ -1,7 +1,8 @@
 package me.cortex.voxy.client.core.model;
 
 import net.caffeinemc.mods.sodium.client.util.color.ColorSRGB;
-import net.minecraft.client.texture.MipmapHelper;
+import net.minecraft.client.renderer.texture.MipmapGenerator;
+import net.minecraft.util.ARGB;
 
 //Texturing utils to manipulate data from the model bakery
 public class TextureUtils {
@@ -9,14 +10,14 @@ public class TextureUtils {
     public static int getWrittenPixelCount(ColourDepthTextureData texture, int checkMode) {
         int count = 0;
         for (int i = 0; i < texture.colour().length; i++) {
-            count += wasPixelWritten(texture, checkMode, i)?1:0;
+            count += wasPixelWritten(texture, checkMode, i) ? 1 : 0;
         }
         return count;
     }
 
     public static boolean isSolid(ColourDepthTextureData texture) {
         for (int pixel : texture.colour()) {
-            if (((pixel>>24)&0xFF) != 255) {
+            if (((pixel >> 24) & 0xFF) != 255) {
                 return false;
             }
         }
@@ -26,14 +27,15 @@ public class TextureUtils {
     public static final int WRITE_CHECK_STENCIL = 1;
     public static final int WRITE_CHECK_DEPTH = 2;
     public static final int WRITE_CHECK_ALPHA = 3;
+
     private static boolean wasPixelWritten(ColourDepthTextureData data, int mode, int index) {
         if (mode == WRITE_CHECK_STENCIL) {
-            return (data.depth()[index]&0xFF)!=0;
+            return (data.depth()[index] & 0xFF) != 0;
         } else if (mode == WRITE_CHECK_DEPTH) {
-            return (data.depth()[index]>>>8)!=((1<<24)-1);
+            return (data.depth()[index] >>> 8) != ((1 << 24) - 1);
         } else if (mode == WRITE_CHECK_ALPHA) {
             //TODO:FIXME: for some reason it has an alpha of 1 even if its ment to be 0
-            return ((data.colour()[index]>>>24)&0xff)>1;
+            return ((data.colour()[index] >>> 24) & 0xff) > 1;
         }
         throw new IllegalArgumentException();
     }
@@ -54,10 +56,10 @@ public class TextureUtils {
             if (!wasPixelWritten(texture, checkMode, i)) {
                 continue;
             }
-            if ((colourData[i]&0xFFFFFF) == 0 || (colourData[i]>>>24)==0) {//If the pixel is fully black (or translucent)
+            if ((colourData[i] & 0xFFFFFF) == 0 || (colourData[i] >>> 24) == 0) {//If the pixel is fully black (or translucent)
                 continue;
             }
-            boolean pixelTinited = (depthData[i]&(1<<7))!=0;
+            boolean pixelTinited = (depthData[i] & (1 << 7)) != 0;
             wasWriten |= true;
             allTinted &= pixelTinited;
             someTinted |= pixelTinited;
@@ -66,7 +68,7 @@ public class TextureUtils {
         if (!wasWriten) {
             return 0;
         }
-        return someTinted?(allTinted?3:2):1;
+        return someTinted ? (allTinted ? 3 : 2) : 1;
     }
 
     public static final int DEPTH_MODE_AVG = 1;
@@ -90,7 +92,7 @@ public class TextureUtils {
             if (!wasPixelWritten(texture, checkMode, i)) {
                 continue;
             }
-            int depth = depthData[i]>>>8;
+            int depth = depthData[i] >>> 8;
             if (mode == DEPTH_MODE_AVG) {
                 a++;
                 b += depth;
@@ -105,7 +107,7 @@ public class TextureUtils {
             if (a == 0) {
                 return -1;
             }
-            return u2fdepth((int) (b/a));
+            return u2fdepth((int) (b / a));
         } else if (mode == DEPTH_MODE_MAX) {
             if (a == Long.MIN_VALUE) {
                 return -1;
@@ -121,7 +123,7 @@ public class TextureUtils {
     }
 
     private static float u2fdepth(int depth) {
-        float depthF = (float) ((double)depth/((1<<24)-1));
+        float depthF = (float) ((double) depth / ((1 << 24) - 1));
         //https://registry.khronos.org/OpenGL-Refpages/gl4/html/glDepthRange.xhtml
         // due to this and the unsigned bullshit, believe the depth value needs to get multiplied by 2
 
@@ -137,7 +139,6 @@ public class TextureUtils {
 
     //NOTE: data goes from bottom left to top right (x first then y)
     public static int[] computeBounds(ColourDepthTextureData data, int checkMode) {
-        final var depth = data.depth();
         //Compute x bounds first
         int minX = 0;
         minXCheck:
@@ -151,10 +152,10 @@ public class TextureUtils {
             minX++;
         } while (minX != data.width());
 
-        int maxX = data.width()-1;
+        int maxX = data.width() - 1;
         maxXCheck:
         do {
-            for (int y = data.height()-1; y!=-1; y--) {
+            for (int y = data.height() - 1; y != -1; y--) {
                 int idx = maxX + (y * data.width());
                 if (wasPixelWritten(data, checkMode, idx)) {
                     break maxXCheck;//pixel was written too so break from loop
@@ -179,10 +180,10 @@ public class TextureUtils {
         } while (minY != data.height());
 
 
-        int maxY = data.height()-1;
+        int maxY = data.height() - 1;
         maxYCheck:
         do {
-            for (int x = data.width()-1; x!=-1; x--) {
+            for (int x = data.width() - 1; x != -1; x--) {
                 int idx = (maxY * data.height()) + x;
                 if (wasPixelWritten(data, checkMode, idx)) {
                     break maxYCheck;//pixel was written too so break from loop
@@ -196,63 +197,42 @@ public class TextureUtils {
     }
 
 
-
+    public static int mipColours(boolean darkend, int C00, int C01, int C10, int C11) {
-
+        darkend = !darkend;//Invert to make it easier
-
+        float r = 0.0f;
-
+        float g = 0.0f;
-
+        float b = 0.0f;
-
+        float a = 0.0f;
-
+        if (darkend || (C00 >>> 24) != 0) {
-
+            r += ColorSRGB.srgbToLinear((C00 >> 0) & 0xFF);
-
+            g += ColorSRGB.srgbToLinear((C00 >> 8) & 0xFF);
-
+            b += ColorSRGB.srgbToLinear((C00 >> 16) & 0xFF);
-
+            a += darkend ? (C00 >>> 24) : ColorSRGB.srgbToLinear(C00 >>> 24);
-
-    public static int mipColours(int one, int two, int three, int four) {
-        if (true) {
-            return MipmapHelper.blend(one, two, three, four, false);
-        } else {
-            return weightedAverageColor(weightedAverageColor(one, two), weightedAverageColor(three, four));
         }
+        if (darkend || (C01 >>> 24) != 0) {
+            r += ColorSRGB.srgbToLinear((C01 >> 0) & 0xFF);
+            g += ColorSRGB.srgbToLinear((C01 >> 8) & 0xFF);
+            b += ColorSRGB.srgbToLinear((C01 >> 16) & 0xFF);
+            a += darkend ? (C01 >>> 24) : ColorSRGB.srgbToLinear(C01 >>> 24);
+        }
+        if (darkend || (C10 >>> 24) != 0) {
+            r += ColorSRGB.srgbToLinear((C10 >> 0) & 0xFF);
+            g += ColorSRGB.srgbToLinear((C10 >> 8) & 0xFF);
+            b += ColorSRGB.srgbToLinear((C10 >> 16) & 0xFF);
+            a += darkend ? (C10 >>> 24) : ColorSRGB.srgbToLinear(C10 >>> 24);
+        }
+        if (darkend || (C11 >>> 24) != 0) {
+            r += ColorSRGB.srgbToLinear((C11 >> 0) & 0xFF);
+            g += ColorSRGB.srgbToLinear((C11 >> 8) & 0xFF);
+            b += ColorSRGB.srgbToLinear((C11 >> 16) & 0xFF);
+            a += darkend ? (C11 >>> 24) : ColorSRGB.srgbToLinear(C11 >>> 24);
+        }
+
+        return ColorSRGB.linearToSrgb(
+                r / 4,
+                g / 4,
+                b / 4,
+                darkend ? ((int) a) / 4 : ARGB.linearToSrgbChannel(a / 4)
+        );
     }
-
+}
-    //TODO: FIXME!!! ITS READING IT AS ABGR??? isnt the format RGBA??
-    private static int weightedAverageColor(int a, int b) {
-        //We specifically want the entire other component if the alpha is zero
-        // this prevents black mips from generating due to A) non filled colours, and B) when the sampler samples everything it doesnt detonate
-        if ((a&0xFF000000) == 0) {
-            return b;
-        }
-        if ((b&0xFF000000) == 0) {
-            return a;
-        }
-
-        if (((a^b)&0xFF000000)==0) {
-            return ColorSRGB.linearToSrgb(
-                    addHalfLinear(0, a,b),
-                    addHalfLinear(8, a,b),
-                    addHalfLinear(16, a,b),
-                    a>>>24);
-        }
-
-        {
-            int A = (a>>>24);
-            int B = (a>>>24);
-            float mul = 1.0F / (float)(A+B);
-            float wA = A * mul;
-            float wB = B * mul;
-            return ColorSRGB.linearToSrgb(
-                    addMulLinear(0, a,b,wA,wB),
-                    addMulLinear(8, a,b,wA,wB),
-                    addMulLinear(16, a,b,wA,wB)
-                    , (A + B)/2);
-        }
-    }
-
-    private static float addHalfLinear(int shift, int a, int b) {
-        return addMulLinear(shift, a, b, 0.5f, 0.5f);
-    }
-    private static float addMulLinear(int shift, int a, int b, float mulA, float mulB) {
-        return Math.fma(ColorSRGB.srgbToLinear((a>>shift)&0xFF),mulA, ColorSRGB.srgbToLinear((b>>shift)&0xFF)*mulB);
-    }
-}

src/main/java/me/cortex/voxy/client/core/model/bakery/BakedBlockEntityModel.java

@@ -1,15 +1,17 @@
+/*
 package me.cortex.voxy.client.core.model.bakery;
 
 import me.cortex.voxy.common.Logger;
-import net.minecraft.block.BlockEntityProvider;
+import net.minecraft.client.Minecraft;
-import net.minecraft.block.BlockState;
+import net.minecraft.client.model.Model;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.renderer.SubmitNodeStorage;
-import net.minecraft.client.render.RenderLayer;
+import net.minecraft.core.BlockPos;
-import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.resources.Identifier;
-import net.minecraft.util.Identifier;
+import net.minecraft.world.level.block.EntityBlock;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.util.math.Vec3d;
+import org.jetbrains.annotations.Nullable;
 import org.joml.Matrix4f;
+import org.joml.Quaternionf;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -17,7 +19,8 @@ import java.util.List;
 import java.util.Map;
 
 public class BakedBlockEntityModel {
-    private record LayerConsumer(RenderLayer layer, ReuseVertexConsumer consumer) {}
+
+    private record LayerConsumer(RenderType layer, ReuseVertexConsumer consumer) {}
     private final List<LayerConsumer> layers;
     private BakedBlockEntityModel(List<LayerConsumer> layers) {
         this.layers = layers;
@@ -26,12 +29,12 @@ public class BakedBlockEntityModel {
     public void render(Matrix4f matrix, int texId) {
         for (var layer : this.layers) {
             if (layer.consumer.isEmpty()) continue;
-            if (layer.layer instanceof RenderLayer.MultiPhase mp) {
+            if (layer.layer instanceof RenderType.CompositeRenderType mp) {
-                Identifier textureId = mp.phases.texture.getId().orElse(null);
+                Identifier textureId = mp.state.textureState.cutoutTexture().orElse(null);
                 if (textureId == null) {
                     Logger.error("ERROR: Empty texture id for layer: " + layer);
                 } else {
-                    texId = ((net.minecraft.client.texture.GlTexture)MinecraftClient.getInstance().getTextureManager().getTexture(textureId).getGlTexture()).getGlId();
+                    texId = ((com.mojang.blaze3d.opengl.GlTexture)Minecraft.getInstance().getTextureManager().getTexture(textureId).getTexture()).glId();
                 }
             }
             if (texId == 0) continue;
@@ -44,15 +47,15 @@ public class BakedBlockEntityModel {
         this.layers.forEach(layer->layer.consumer.free());
     }
 
-    private static int getMetaFromLayer(RenderLayer layer) {
+    private static int getMetaFromLayer(RenderType layer) {
-        boolean hasDiscard = layer == RenderLayer.getCutout() ||
+        boolean hasDiscard = layer == RenderType.cutout() ||
-                layer == RenderLayer.getCutoutMipped() ||
+                layer == RenderType.cutoutMipped() ||
-                layer == RenderLayer.getTripwire();
+                layer == RenderType.tripwire();
 
-        boolean isMipped = layer == RenderLayer.getCutoutMipped() ||
+        boolean isMipped = layer == RenderType.cutoutMipped() ||
-                layer == RenderLayer.getSolid() ||
+                layer == RenderType.solid() ||
-                layer.isTranslucent() ||
+                layer.sortOnUpload() ||
-                layer == RenderLayer.getTripwire();
+                layer == RenderType.tripwire();
 
         int meta = hasDiscard?1:0;
         meta |= isMipped?2:0;
@@ -60,21 +63,30 @@ public class BakedBlockEntityModel {
     }
 
     public static BakedBlockEntityModel bake(BlockState state) {
-        Map<RenderLayer, LayerConsumer> map = new HashMap<>();
+        Map<RenderType, LayerConsumer> map = new HashMap<>();
-        var entity = ((BlockEntityProvider)state.getBlock()).createBlockEntity(BlockPos.ORIGIN, state);
+        var entity = ((EntityBlock)state.getBlock()).newBlockEntity(BlockPos.ZERO, state);
         if (entity == null) {
             return null;
         }
-        var renderer = MinecraftClient.getInstance().getBlockEntityRenderDispatcher().get(entity);
+        var renderer = Minecraft.getInstance().getBlockEntityRenderDispatcher().getRenderer(entity);
-        entity.setWorld(MinecraftClient.getInstance().world);
+        entity.setLevel(Minecraft.getInstance().level);
         if (renderer != null) {
             try {
-                renderer.render(entity, 0.0f, new MatrixStack(), layer->map.computeIfAbsent(layer, rl -> new LayerConsumer(rl, new ReuseVertexConsumer().setDefaultMeta(getMetaFromLayer(rl)))).consumer, 0, 0, new Vec3d(0,0,0));
+                var rt = renderer.createRenderState();
+                renderer.extractRenderState(entity, rt, 0.0f, new Vec3d(0,0,0), null);
+
+                //TODO: FIXME: FINISH
+                var cstate = new CameraRenderState();
+                var queue = new SubmitNodeStorage();
+                renderer.submit(rt, new MatrixStack(), queue, cstate);
+                var qq = queue.order(0);
+                qq.
+                //renderer.render(entity, 0.0f, new MatrixStack(), layer->map.computeIfAbsent(layer, rl -> new LayerConsumer(rl, new ReuseVertexConsumer().setDefaultMeta(getMetaFromLayer(rl)))).consumer, 0, 0, new Vec3d(0,0,0));
             } catch (Exception e) {
                 Logger.error("Unable to bake block entity: " + entity, e);
             }
         }
-        entity.markRemoved();
+        entity.setRemoved();
         if (map.isEmpty()) {
             return null;
         }
@@ -90,3 +102,4 @@ public class BakedBlockEntityModel {
         return new BakedBlockEntityModel(new ArrayList<>(map.values()));
     }
 }
+*/

src/main/java/me/cortex/voxy/client/core/model/bakery/BudgetBufferRenderer.java

@@ -2,14 +2,13 @@ package me.cortex.voxy.client.core.model.bakery;
 
 import com.mojang.blaze3d.systems.RenderSystem;
 import com.mojang.blaze3d.textures.GpuTexture;
+import com.mojang.blaze3d.vertex.MeshData;
 import com.mojang.blaze3d.vertex.VertexFormat;
 import me.cortex.voxy.client.core.gl.GlBuffer;
 import me.cortex.voxy.client.core.gl.GlVertexArray;
 import me.cortex.voxy.client.core.gl.shader.Shader;
 import me.cortex.voxy.client.core.gl.shader.ShaderType;
 import me.cortex.voxy.client.core.rendering.util.UploadStream;
-import net.minecraft.client.gl.GlGpuBuffer;
-import net.minecraft.client.render.BuiltBuffer;
 import org.joml.Matrix4f;
 import org.lwjgl.system.MemoryUtil;
 
@@ -29,9 +28,9 @@ public class BudgetBufferRenderer {
     public static void init(){}
     private static final GlBuffer indexBuffer;
     static {
-        var i = RenderSystem.getSequentialBuffer(VertexFormat.DrawMode.QUADS);
+        var i = RenderSystem.getSequentialBuffer(VertexFormat.Mode.QUADS);
-        int id = ((GlGpuBuffer) i.getIndexBuffer(4096*3*2)).id;
+        int id = ((com.mojang.blaze3d.opengl.GlBuffer) i.getBuffer(4096*3*2)).handle;
-        if (i.getIndexType() != VertexFormat.IndexType.SHORT) {
+        if (i.type() != VertexFormat.IndexType.SHORT) {
             throw new IllegalStateException();
         }
         indexBuffer = new GlBuffer(3*2*2*4096);
@@ -47,18 +46,18 @@ public class BudgetBufferRenderer {
 
     private static GlBuffer immediateBuffer;
     private static int quadCount;
-    public static void drawFast(BuiltBuffer buffer, GpuTexture tex, Matrix4f matrix) {
+    public static void drawFast(MeshData buffer, GpuTexture tex, Matrix4f matrix) {
-        if (buffer.getDrawParameters().mode() != VertexFormat.DrawMode.QUADS) {
+        if (buffer.drawState().mode() != VertexFormat.Mode.QUADS) {
             throw new IllegalStateException("Fast only supports quads");
         }
 
-        var buff = buffer.getBuffer();
+        var buff = buffer.vertexBuffer();
         int size = buff.remaining();
         if (size%STRIDE != 0) throw new IllegalStateException();
         size /= STRIDE;
         if (size%4 != 0) throw new IllegalStateException();
         size /= 4;
-        setup(MemoryUtil.memAddress(buff), size, ((net.minecraft.client.texture.GlTexture)tex).getGlId());
+        setup(MemoryUtil.memAddress(buff), size, ((com.mojang.blaze3d.opengl.GlTexture)tex).glId());
         buffer.close();
 
         render(matrix);

src/main/java/me/cortex/voxy/client/core/model/bakery/GlViewCapture.java

@@ -49,6 +49,9 @@ public class GlViewCapture {
         glTextureParameteri(this.metaTex.id, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         glTextureParameteri(this.metaTex.id, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
+        glTextureParameteri(this.depthTex.id, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTextureParameteri(this.depthTex.id, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
         this.copyOutShader = Shader.makeAuto()
                 .define("WIDTH", width)
                 .define("HEIGHT", height)

src/main/java/me/cortex/voxy/client/core/model/bakery/ModelTextureBakery.java

@@ -1,31 +1,38 @@
 package me.cortex.voxy.client.core.model.bakery;
 
-import net.minecraft.block.*;
+import net.minecraft.client.Minecraft;
-import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.client.renderer.ItemBlockRenderTypes;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.renderer.chunk.ChunkSectionLayer;
-import net.minecraft.client.render.BlockRenderLayer;
+import net.minecraft.core.BlockPos;
-import net.minecraft.client.render.RenderLayers;
+import net.minecraft.core.Direction;
-import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.resources.Identifier;
-import net.minecraft.fluid.FluidState;
+import net.minecraft.world.level.BlockAndTintGetter;
-import net.minecraft.util.Identifier;
+import net.minecraft.world.level.ColorResolver;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.level.LightLayer;
-import net.minecraft.util.math.Direction;
+import net.minecraft.world.level.block.Blocks;
-import net.minecraft.util.math.random.LocalRandom;
+import net.minecraft.world.level.block.LeavesBlock;
-import net.minecraft.world.BlockRenderView;
+import net.minecraft.world.level.block.LiquidBlock;
-import net.minecraft.world.LightType;
+import net.minecraft.world.level.block.RenderShape;
-import net.minecraft.world.biome.ColorResolver;
+import net.minecraft.world.level.block.entity.BlockEntity;
-import net.minecraft.world.chunk.light.LightingProvider;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.SingleThreadedRandomSource;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+import net.minecraft.world.level.material.FluidState;
 import org.jetbrains.annotations.Nullable;
 import org.joml.Matrix4f;
 import org.joml.Quaternionf;
 import org.joml.Vector3f;
+import org.lwjgl.opengl.ARBDrawBuffersBlend;
 import org.lwjgl.opengl.GL14;
 
 import static org.lwjgl.opengl.GL11.*;
 import static org.lwjgl.opengl.GL14C.glBlendFuncSeparate;
 import static org.lwjgl.opengl.GL30.*;
+import static org.lwjgl.opengl.GL40.glBlendFuncSeparatei;
 import static org.lwjgl.opengl.GL45.glTextureBarrier;
 
+import com.mojang.blaze3d.vertex.PoseStack;
+
 public class ModelTextureBakery {
     //Note: the first bit of metadata is if alpha discard is enabled
     private static final Matrix4f[] VIEWS = new Matrix4f[6];
@@ -41,44 +48,43 @@ public class ModelTextureBakery {
         this.height = height;
     }
 
-    public static int getMetaFromLayer(BlockRenderLayer layer) {
+    public static int getMetaFromLayer(ChunkSectionLayer layer) {
-        boolean hasDiscard = layer == BlockRenderLayer.CUTOUT ||
+        boolean hasDiscard = layer == ChunkSectionLayer.CUTOUT ||
-                layer == BlockRenderLayer.CUTOUT_MIPPED ||
+                layer == ChunkSectionLayer.TRANSLUCENT||
-                layer == BlockRenderLayer.TRIPWIRE;
+                layer == ChunkSectionLayer.TRIPWIRE;
 
-        boolean isMipped = layer == BlockRenderLayer.CUTOUT_MIPPED ||
+        boolean isMipped = layer == ChunkSectionLayer.SOLID ||
-                layer == BlockRenderLayer.SOLID ||
+                layer == ChunkSectionLayer.TRANSLUCENT ||
-                layer == BlockRenderLayer.TRANSLUCENT ||
+                layer == ChunkSectionLayer.TRIPWIRE;
-                layer == BlockRenderLayer.TRIPWIRE;
 
         int meta = hasDiscard?1:0;
-        meta |= isMipped?2:0;
+        meta |= true?2:0;
         return meta;
     }
 
-    private void bakeBlockModel(BlockState state, BlockRenderLayer layer) {
+    private void bakeBlockModel(BlockState state, ChunkSectionLayer layer) {
-        if (state.getRenderType() == BlockRenderType.INVISIBLE) {
+        if (state.getRenderShape() == RenderShape.INVISIBLE) {
             return;//Dont bake if invisible
         }
-        var model = MinecraftClient.getInstance()
+        var model = Minecraft.getInstance()
-                .getBakedModelManager()
+                .getModelManager()
-                .getBlockModels()
+                .getBlockModelShaper()
-                .getModel(state);
+                .getBlockModel(state);
 
         int meta = getMetaFromLayer(layer);
 
-        for (var part : model.getParts(new LocalRandom(42L))) {
+        for (var part : model.collectParts(new SingleThreadedRandomSource(42L))) {
             for (Direction direction : new Direction[]{Direction.DOWN, Direction.UP, Direction.NORTH, Direction.SOUTH, Direction.WEST, Direction.EAST, null}) {
                 var quads = part.getQuads(direction);
                 for (var quad : quads) {
-                    this.vc.quad(quad, meta|(quad.hasTint()?4:0));
+                    this.vc.quad(quad, meta|(quad.isTinted()?4:0));
                 }
             }
         }
     }
 
 
-    private void bakeFluidState(BlockState state, BlockRenderLayer layer, int face) {
+    private void bakeFluidState(BlockState state, ChunkSectionLayer layer, int face) {
         {
             //TODO: somehow set the tint flag per quad or something?
             int metadata = getMetaFromLayer(layer);
@@ -87,24 +93,24 @@ public class ModelTextureBakery {
             metadata |= 4;//Has tint
             this.vc.setDefaultMeta(metadata);//Set the meta while baking
         }
-        MinecraftClient.getInstance().getBlockRenderManager().renderFluid(BlockPos.ORIGIN, new BlockRenderView() {
+        Minecraft.getInstance().getBlockRenderer().renderLiquid(BlockPos.ZERO, new BlockAndTintGetter() {
             @Override
-            public float getBrightness(Direction direction, boolean shaded) {
+            public float getShade(Direction direction, boolean shaded) {
                 return 0;
             }
 
             @Override
-            public LightingProvider getLightingProvider() {
+            public LevelLightEngine getLightEngine() {
                 return null;
             }
 
             @Override
-            public int getLightLevel(LightType type, BlockPos pos) {
+            public int getBrightness(LightLayer type, BlockPos pos) {
                 return 0;
             }
 
             @Override
-            public int getColor(BlockPos pos, ColorResolver colorResolver) {
+            public int getBlockTint(BlockPos pos, ColorResolver colorResolver) {
                 return 0;
             }
 
@@ -117,7 +123,7 @@ public class ModelTextureBakery {
             @Override
             public BlockState getBlockState(BlockPos pos) {
                 if (shouldReturnAirForFluid(pos, face)) {
-                    return Blocks.AIR.getDefaultState();
+                    return Blocks.AIR.defaultBlockState();
                 }
 
                 //Fixme:
@@ -135,7 +141,7 @@ public class ModelTextureBakery {
             @Override
             public FluidState getFluidState(BlockPos pos) {
                 if (shouldReturnAirForFluid(pos, face)) {
-                    return Blocks.AIR.getDefaultState().getFluidState();
+                    return Blocks.AIR.defaultBlockState().getFluidState();
                 }
 
                 return state.getFluidState();
@@ -147,15 +153,15 @@ public class ModelTextureBakery {
             }
 
             @Override
-            public int getBottomY() {
+            public int getMinY() {
                 return 0;
             }
-        }, this.    vc, state, state.getFluidState());
+        }, this.vc, state, state.getFluidState());
         this.vc.setDefaultMeta(0);//Reset default meta
     }
 
     private static boolean shouldReturnAirForFluid(BlockPos pos, int face) {
-        var fv = Direction.byIndex(face).getVector();
+        var fv = Direction.from3DDataValue(face).getUnitVec3i();
         int dot = fv.getX()*pos.getX() + fv.getY()*pos.getY() + fv.getZ()*pos.getZ();
         return dot >= 1;
     }
@@ -166,25 +172,25 @@ public class ModelTextureBakery {
     }
 
 
-    public void renderToStream(BlockState state, int streamBuffer, int streamOffset) {
+    public int renderToStream(BlockState state, int streamBuffer, int streamOffset) {
         this.capture.clear();
         boolean isBlock = true;
-        BlockRenderLayer layer;
+        ChunkSectionLayer layer;
-        if (state.getBlock() instanceof FluidBlock) {
+        if (state.getBlock() instanceof LiquidBlock) {
-            layer = RenderLayers.getFluidLayer(state.getFluidState());
+            layer = ItemBlockRenderTypes.getRenderLayer(state.getFluidState());
             isBlock = false;
         } else {
             if (state.getBlock() instanceof LeavesBlock) {
-                layer = BlockRenderLayer.SOLID;
+                layer = ChunkSectionLayer.SOLID;
             } else {
-                layer = RenderLayers.getBlockLayer(state);
+                layer = ItemBlockRenderTypes.getChunkRenderType(state);
             }
         }
 
         //TODO: support block model entities
-        BakedBlockEntityModel bbem = null;
+        //BakedBlockEntityModel bbem = null;
         if (state.hasBlockEntity()) {
-            bbem = BakedBlockEntityModel.bake(state);
+            //bbem = BakedBlockEntityModel.bake(state);
         }
 
         //Setup GL state
@@ -195,9 +201,10 @@ public class ModelTextureBakery {
             glEnable(GL_STENCIL_TEST);
             glEnable(GL_DEPTH_TEST);
             glEnable(GL_CULL_FACE);
-            if (layer == BlockRenderLayer.TRANSLUCENT) {
+            if (layer == ChunkSectionLayer.TRANSLUCENT) {
-                glEnable(GL_BLEND);
+                glEnablei(GL_BLEND, 0);
-                glBlendFuncSeparate(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+                glDisablei(GL_BLEND, 1);
+                ARBDrawBuffersBlend.glBlendFuncSeparateiARB(0, GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
             } else {
                 glDisable(GL_BLEND);//FUCK YOU INTEL (screams), for _some reason_ discard or something... JUST DOESNT WORK??
                 //glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ONE);
@@ -212,14 +219,17 @@ public class ModelTextureBakery {
             //Bind the capture framebuffer
             glBindFramebuffer(GL_FRAMEBUFFER, this.capture.framebuffer.id);
 
-            var tex = MinecraftClient.getInstance().getTextureManager().getTexture(Identifier.of("minecraft", "textures/atlas/blocks.png")).getGlTexture();
+            var tex = Minecraft.getInstance().getTextureManager().getTexture(Identifier.fromNamespaceAndPath("minecraft", "textures/atlas/blocks.png")).getTexture();
-            blockTextureId = ((net.minecraft.client.texture.GlTexture)tex).getGlId();
+            blockTextureId = ((com.mojang.blaze3d.opengl.GlTexture)tex).glId();
         }
 
-        //TODO: fastpath for blocks
+        boolean isAnyShaded = false;
+        boolean isAnyDarkend = false;
         if (isBlock) {
             this.vc.reset();
             this.bakeBlockModel(state, layer);
+            isAnyShaded |= this.vc.anyShaded;
+            isAnyDarkend |= this.vc.anyDarkendTex;
             if (!this.vc.isEmpty()) {//only render if there... is shit to render
 
                 //Setup for continual emission
@@ -248,7 +258,7 @@ public class ModelTextureBakery {
             glBindVertexArray(0);
         } else {//Is fluid, slow path :(
 
-            if (!(state.getBlock() instanceof FluidBlock)) throw new IllegalStateException();
+            if (!(state.getBlock() instanceof LiquidBlock)) throw new IllegalStateException();
 
             var mat = new Matrix4f();
             for (int i = 0; i < VIEWS.length; i++) {
@@ -261,6 +271,8 @@ public class ModelTextureBakery {
                 this.vc.reset();
                 this.bakeFluidState(state, layer, i);
                 if (this.vc.isEmpty()) continue;
+                isAnyShaded |= this.vc.anyShaded;
+                isAnyDarkend |= this.vc.anyDarkendTex;
                 BudgetBufferRenderer.setup(this.vc.getAddress(), this.vc.quadCount(), blockTextureId);
 
                 glViewport((i % 3) * this.width, (i / 3) * this.height, this.width, this.height);
@@ -278,6 +290,7 @@ public class ModelTextureBakery {
         }
 
         //Render block model entity data if it exists
+        /*
         if (bbem != null) {
             //Rerender everything again ;-; but is ok (is not)
 
@@ -303,7 +316,7 @@ public class ModelTextureBakery {
             glBindVertexArray(0);
 
             bbem.release();
-        }
+        }*/
 
 
 
@@ -319,10 +332,12 @@ public class ModelTextureBakery {
         glBindFramebuffer(GL_FRAMEBUFFER, this.capture.framebuffer.id);
         glClearDepth(1);
         glClear(GL_DEPTH_BUFFER_BIT);
-        if (layer == BlockRenderLayer.TRANSLUCENT) {
+        if (layer == ChunkSectionLayer.TRANSLUCENT) {
             //reset the blend func
             GL14.glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
         }
+
+        return (isAnyShaded?1:0)|(isAnyDarkend?2:0);
     }
 
 
@@ -341,14 +356,14 @@ public class ModelTextureBakery {
     }
 
     private static void addView(int i, float pitch, float yaw, float rotation, int flip) {
-        var stack = new MatrixStack();
+        var stack = new PoseStack();
         stack.translate(0.5f,0.5f,0.5f);
-        stack.multiply(makeQuatFromAxisExact(new Vector3f(0,0,1), rotation));
+        stack.mulPose(makeQuatFromAxisExact(new Vector3f(0,0,1), rotation));
-        stack.multiply(makeQuatFromAxisExact(new Vector3f(1,0,0), pitch));
+        stack.mulPose(makeQuatFromAxisExact(new Vector3f(1,0,0), pitch));
-        stack.multiply(makeQuatFromAxisExact(new Vector3f(0,1,0), yaw));
+        stack.mulPose(makeQuatFromAxisExact(new Vector3f(0,1,0), yaw));
-        stack.multiplyPositionMatrix(new Matrix4f().scale(1-2*(flip&1), 1-(flip&2), 1-((flip>>1)&2)));
+        stack.mulPose(new Matrix4f().scale(1-2*(flip&1), 1-(flip&2), 1-((flip>>1)&2)));
         stack.translate(-0.5f,-0.5f,-0.5f);
-        VIEWS[i] = new Matrix4f(stack.peek().getPositionMatrix());
+        VIEWS[i] = new Matrix4f(stack.last().pose());
     }
 
     private static Quaternionf makeQuatFromAxisExact(Vector3f vec, float angle) {

src/main/java/me/cortex/voxy/client/core/model/bakery/ReuseVertexConsumer.java

@@ -2,18 +2,24 @@ package me.cortex.voxy.client.core.model.bakery;
 
 
 import me.cortex.voxy.common.util.MemoryBuffer;
-import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.model.geom.builders.UVPair;
-import net.minecraft.client.render.model.BakedQuad;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.texture.MipmapStrategy;
 import org.lwjgl.system.MemoryUtil;
 
 import static me.cortex.voxy.client.core.model.bakery.BudgetBufferRenderer.VERTEX_FORMAT_SIZE;
 
+import com.mojang.blaze3d.vertex.VertexConsumer;
+
 public final class ReuseVertexConsumer implements VertexConsumer {
     private MemoryBuffer buffer = new MemoryBuffer(8192);
     private long ptr;
     private int count;
     private int defaultMeta;
 
+    public boolean anyShaded;
+    public boolean anyDarkendTex;
+
     public ReuseVertexConsumer() {
         this.reset();
     }
@@ -24,7 +30,7 @@ public final class ReuseVertexConsumer implements VertexConsumer {
     }
 
     @Override
-    public ReuseVertexConsumer vertex(float x, float y, float z) {
+    public ReuseVertexConsumer addVertex(float x, float y, float z) {
         this.ensureCanPut();
         this.ptr += VERTEX_FORMAT_SIZE; this.count++; //Goto next vertex
         this.meta(this.defaultMeta);
@@ -40,43 +46,51 @@ public final class ReuseVertexConsumer implements VertexConsumer {
     }
 
     @Override
-    public ReuseVertexConsumer color(int red, int green, int blue, int alpha) {
+    public ReuseVertexConsumer setColor(int red, int green, int blue, int alpha) {
         return this;
     }
 
     @Override
-    public ReuseVertexConsumer texture(float u, float v) {
+    public VertexConsumer setColor(int i) {
+        return this;
+    }
+
+    @Override
+    public ReuseVertexConsumer setUv(float u, float v) {
         MemoryUtil.memPutFloat(this.ptr + 16, u);
         MemoryUtil.memPutFloat(this.ptr + 20, v);
         return this;
     }
 
     @Override
-    public ReuseVertexConsumer overlay(int u, int v) {
+    public ReuseVertexConsumer setUv1(int u, int v) {
         return this;
     }
 
     @Override
-    public ReuseVertexConsumer light(int u, int v) {
+    public ReuseVertexConsumer setUv2(int u, int v) {
         return this;
     }
 
     @Override
-    public ReuseVertexConsumer normal(float x, float y, float z) {
+    public ReuseVertexConsumer setNormal(float x, float y, float z) {
         return this;
     }
 
+    @Override
+    public VertexConsumer setLineWidth(float f) {
+        return null;
+    }
+
     public ReuseVertexConsumer quad(BakedQuad quad, int metadata) {
+        this.anyShaded |= quad.shade();
+        this.anyDarkendTex |= quad.sprite().contents().mipmapStrategy == MipmapStrategy.DARK_CUTOUT;
         this.ensureCanPut();
-        int[] data = quad.vertexData();
         for (int i = 0; i < 4; i++) {
-            float x = Float.intBitsToFloat(data[i * 8]);
+            var pos = quad.position(i);
-            float y = Float.intBitsToFloat(data[i * 8 + 1]);
+            this.addVertex(pos.x(), pos.y(), pos.z());
-            float z = Float.intBitsToFloat(data[i * 8 + 2]);
+            long puv = quad.packedUV(i);
-            this.vertex(x,y,z);
+            this.setUv(UVPair.unpackU(puv),UVPair.unpackV(puv));
-            float u = Float.intBitsToFloat(data[i * 8 + 4]);
-            float v = Float.intBitsToFloat(data[i * 8 + 5]);
-            this.texture(u,v);
 
             this.meta(metadata);
         }
@@ -97,6 +111,8 @@ public final class ReuseVertexConsumer implements VertexConsumer {
     }
 
     public ReuseVertexConsumer reset() {
+        this.anyShaded = false;
+        this.anyDarkendTex = false;
         this.defaultMeta = 0;//RESET THE DEFAULT META
         this.count = 0;
         this.ptr = this.buffer.address - VERTEX_FORMAT_SIZE;//the thing is first time this gets incremented by FORMAT_STRIDE

src/main/java/me/cortex/voxy/client/core/rendering/ChunkBoundRenderer.java

@@ -12,8 +12,7 @@ import me.cortex.voxy.client.core.gl.shader.ShaderType;
 import me.cortex.voxy.client.core.rendering.util.SharedIndexBuffer;
 import me.cortex.voxy.client.core.rendering.util.UploadStream;
 import me.cortex.voxy.common.Logger;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
-import net.minecraft.util.math.MathHelper;
 import org.joml.Matrix4f;
 import org.joml.Vector3f;
 import org.joml.Vector3i;
@@ -91,22 +90,22 @@ public class ChunkBoundRenderer {
         long ptr = UploadStream.INSTANCE.upload(this.uniformBuffer, 0, 128);
         long matPtr = ptr; ptr += 4*4*4;
 
-        final float renderDistance = MinecraftClient.getInstance().options.getClampedViewDistance()*16;//In blocks
+        final float renderDistance = Minecraft.getInstance().options.getEffectiveRenderDistance()*16;//In blocks
 
         {//This is recomputed to be in chunk section space not worldsection
-            int sx = MathHelper.floor(viewport.cameraX) >> 4;
+            int sx = (int)(viewport.cameraX);
-            int sy = MathHelper.floor(viewport.cameraY) >> 4;
+            int sy = (int)(viewport.cameraY);
-            int sz = MathHelper.floor(viewport.cameraZ) >> 4;
+            int sz = (int)(viewport.cameraZ);
             new Vector3i(sx, sy, sz).getToAddress(ptr); ptr += 4*4;
 
             var negInnerSec = new Vector3f(
-                    -(float) (viewport.cameraX - (sx << 4)),
+                    (float) (viewport.cameraX - sx),
-                    -(float) (viewport.cameraY - (sy << 4)),
+                    (float) (viewport.cameraY - sy),
-                    -(float) (viewport.cameraZ - (sz << 4)));
+                    (float) (viewport.cameraZ - sz));
 
-            viewport.MVP.translate(negInnerSec, new Matrix4f()).getToAddress(matPtr);
 
             negInnerSec.getToAddress(ptr); ptr += 4*3;
+            viewport.MVP.translate(negInnerSec.negate(), new Matrix4f()).getToAddress(matPtr);
             MemoryUtil.memPutFloat(ptr, renderDistance); ptr += 4;
         }
         UploadStream.INSTANCE.commit();
@@ -131,7 +130,7 @@ public class ChunkBoundRenderer {
 
         //Batch the draws into groups of size 32
         int count = this.chunk2idx.size();
-        if (count > 32) {
+        if (count >= 32) {
             glDrawElementsInstanced(GL_TRIANGLES, 6 * 2 * 3 * 32, GL_UNSIGNED_BYTE, 0, count/32);
         }
         if (count%32 != 0) {

src/main/java/me/cortex/voxy/client/core/rendering/Viewport.java

@@ -4,7 +4,7 @@ import me.cortex.voxy.client.core.gl.GlBuffer;
 import me.cortex.voxy.client.core.rendering.util.DepthFramebuffer;
 import me.cortex.voxy.client.core.rendering.util.HiZBuffer;
 import net.caffeinemc.mods.sodium.client.util.FogParameters;
-import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.Mth;
 import org.joml.*;
 
 import java.lang.reflect.Field;
@@ -101,9 +101,9 @@ public abstract class Viewport <A extends Viewport<A>> {
         this.frustum.set(this.MVP, false);
 
         //Translation vectors
-        int sx = MathHelper.floor(this.cameraX)>>5;
+        int sx = Mth.floor(this.cameraX)>>5;
-        int sy = MathHelper.floor(this.cameraY)>>5;
+        int sy = Mth.floor(this.cameraY)>>5;
-        int sz = MathHelper.floor(this.cameraZ)>>5;
+        int sz = Mth.floor(this.cameraZ)>>5;
         this.section.set(sx, sy, sz);
 
         this.innerTranslation.set(

src/main/java/me/cortex/voxy/client/core/rendering/ViewportSelector.java

@@ -2,18 +2,20 @@ package me.cortex.voxy.client.core.rendering;
 
 import me.cortex.voxy.client.core.util.IrisUtil;
 import net.fabricmc.loader.api.FabricLoader;
-import org.vivecraft.client_vr.ClientDataHolderVR;
+import org.vivecraft.api.client.VRRenderingAPI;
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Supplier;
 
+import static org.vivecraft.api.client.data.RenderPass.VANILLA;
+
 public class ViewportSelector <T extends Viewport<?>> {
     public static final boolean VIVECRAFT_INSTALLED = FabricLoader.getInstance().isModLoaded("vivecraft");
 
     private final Supplier<T> creator;
     private final T defaultViewport;
-    private final Map<Object, T> extraViewports = new HashMap<>();
+    private final Map<Object, T> extraViewports = new HashMap<>();//TODO should maybe be a weak hashmap with value cleanup queue thing?
 
     public ViewportSelector(Supplier<T> viewportCreator) {
         this.creator = viewportCreator;
@@ -25,24 +27,28 @@ public class ViewportSelector <T extends Viewport<?>> {
     }
 
     private T getVivecraftViewport() {
-        var cdh = ClientDataHolderVR.getInstance();
+        var pass = VRRenderingAPI.instance().getCurrentRenderPass();
-        var pass = cdh.currentPass;
+        if (pass == null || pass == VANILLA) {
-        if (pass == null) {
+            return null;
-            return this.defaultViewport;
         }
         return this.getOrCreate(pass);
     }
 
     private static final Object IRIS_SHADOW_OBJECT = new Object();
     public T getViewport() {
-        if (VIVECRAFT_INSTALLED) {
+        T viewport = null;
-            return getVivecraftViewport();
+        if (viewport == null && VIVECRAFT_INSTALLED) {
+            viewport = getVivecraftViewport();
         }
 
-        if (IrisUtil.irisShadowActive()) {
+        if (viewport == null && IrisUtil.irisShadowActive()) {
-            return this.getOrCreate(IRIS_SHADOW_OBJECT);
+            viewport = this.getOrCreate(IRIS_SHADOW_OBJECT);
         }
-        return this.defaultViewport;
+
+        if (viewport == null) {
+            viewport = this.defaultViewport;
+        }
+        return viewport;
     }
 
     public void free() {

src/main/java/me/cortex/voxy/client/core/rendering/building/BuiltSection.java

@@ -13,9 +13,10 @@ public final class BuiltSection {
     public final int aabb;
     public final MemoryBuffer geometryBuffer;
     public final int[] offsets;
+    public final MemoryBuffer occupancy;
 
     private BuiltSection(long position, byte children) {
-        this(position, children, -1, null, null);
+        this(position, children, -1, null, null, null);
     }
 
     public static BuiltSection empty(long position) {
@@ -25,7 +26,7 @@ public final class BuiltSection {
         return new BuiltSection(position, children);
     }
 
-    public BuiltSection(long position, byte childExistence, int aabb, MemoryBuffer geometryBuffer, int[] offsets) {
+    public BuiltSection(long position, byte childExistence, int aabb, MemoryBuffer geometryBuffer, int[] offsets, MemoryBuffer occupancy) {
         this.position = position;
         this.childExistence = childExistence;
         this.aabb = aabb;
@@ -39,16 +40,20 @@ public final class BuiltSection {
                 }
             }
         }
+        this.occupancy = occupancy;
     }
 
     public BuiltSection clone() {
-        return new BuiltSection(this.position, this.childExistence, this.aabb, this.geometryBuffer!=null?this.geometryBuffer.copy():null, this.offsets!=null?Arrays.copyOf(this.offsets, this.offsets.length):null);
+        return new BuiltSection(this.position, this.childExistence, this.aabb, this.geometryBuffer!=null?this.geometryBuffer.copy():null, this.offsets!=null?Arrays.copyOf(this.offsets, this.offsets.length):null, this.occupancy!=null?this.occupancy.copy():null);
     }
 
     public void free() {
         if (this.geometryBuffer != null) {
             this.geometryBuffer.free();
         }
+        if (this.occupancy != null) {
+            this.occupancy.free();
+        }
     }
 
     public boolean isEmpty() {

src/main/java/me/cortex/voxy/client/core/rendering/building/OccupancySet.java

@@ -0,0 +1,105 @@
+package me.cortex.voxy.client.core.rendering.building;
+
+import org.lwjgl.system.MemoryUtil;
+
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Random;
+
+//Block occupancy, 2 lvl compacted bitset for occluding block existance
+// TODO: need to add neighboring chunk data aswell? or somehow do a linking thing where this is stored in a secondary storage
+//  where we can link them together (or store the neighbor faces seperately or something) might be out of scope for this class
+public class OccupancySet {
+    private long topLvl;//4x4x4
+    private final long[] bottomLvl = new long[(4*4*4)*8];
+    public void set(final int pos) {
+        final long topBit = 1L<<Integer.compress(pos, 0b11000_11000_11000);
+        final int  botIdx =     Integer.compress(pos, 0b00111_00111_00111);
+
+        int baseBotIdx = Long.bitCount(this.topLvl&(topBit-1))*8;
+        if ((this.topLvl & topBit) == 0) {
+            //we need to shuffle up all the bottomlvl
+            long toMove = this.topLvl & (~((topBit << 1) - 1));
+            if (toMove != 0) {
+                int base = baseBotIdx+8;//+8 cause were bubbling
+                int count = Long.bitCount(toMove);
+                for (int i = base+count*8-1; base<=i; i--) {
+                    this.bottomLvl[i] = this.bottomLvl[i-8];
+                }
+                for (int i = baseBotIdx; i<baseBotIdx+8; i++) {
+                    this.bottomLvl[i] = 0;
+                }
+            }
+
+            this.topLvl |= topBit;
+        }
+
+        this.bottomLvl[baseBotIdx+(botIdx>>6)] |= 1L<<(botIdx&63);
+    }
+
+    private boolean get(int pos) {
+        final long topBit = 1L<<Integer.compress(pos, 0b11000_11000_11000);
+        final int  botIdx =     Integer.compress(pos, 0b00111_00111_00111);
+        if ((this.topLvl & topBit) == 0) {
+            return false;
+        }
+        int baseBotIdx = Long.bitCount(this.topLvl&(topBit-1))*8;
+
+        return (this.bottomLvl[baseBotIdx+(botIdx>>6)]&(1L<<(botIdx&63)))!=0;
+    }
+
+    public void reset() {
+        if (this.topLvl != 0) {
+            Arrays.fill(this.bottomLvl, 0);
+        }
+        this.topLvl = 0;
+    }
+
+    public int writeSize() {
+        return 8+Long.bitCount(this.topLvl)*8*8;
+    }
+
+    public boolean isEmpty() {
+        return this.topLvl == 0;
+    }
+
+    public void write(long ptr, boolean asLongs) {
+        if (asLongs) {
+            MemoryUtil.memPutLong(ptr, this.topLvl); ptr += 8;
+            int cnt = Long.bitCount(this.topLvl);
+            for (int i = 0; i < cnt; i++) {
+                for (int j = 0; j < 8; j++) {
+                    MemoryUtil.memPutLong(ptr, this.bottomLvl[i*8+j]); ptr += 8;
+                }
+            }
+        } else {
+            MemoryUtil.memPutInt(ptr, (int) (this.topLvl>>>32)); ptr += 4;
+            MemoryUtil.memPutInt(ptr, (int) this.topLvl); ptr += 4;
+            int cnt = Long.bitCount(this.topLvl);
+            for (int i = 0; i < cnt; i++) {
+                for (int j = 0; j < 8; j++) {
+                    long v = this.bottomLvl[i*8+j];
+                    MemoryUtil.memPutInt(ptr, (int) (v>>>32)); ptr += 4;
+                    MemoryUtil.memPutInt(ptr, (int) v); ptr += 4;
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        for (int q = 0; q < 1000; q++) {
+            var o = new OccupancySet();
+            var r = new Random(12523532643L*q);
+            var bs = new BitSet(32 * 32 * 32);
+            for (int i = 0; i < 5000; i++) {
+                int p = r.nextInt(32 * 32 * 32);
+                o.set(p);
+                bs.set(p);
+
+                for (int j = 0; j < 32 * 32 * 32; j++) {
+                    if (o.get(j) != bs.get(j)) throw new IllegalStateException();
+                }
+            }
+        }
+    }
+}

src/main/java/me/cortex/voxy/client/core/rendering/building/RenderDataFactory.java

@@ -17,6 +17,8 @@ import java.util.Arrays;
 
 
 public class RenderDataFactory {
+    private static final boolean BUILD_OCCUPANCY_SET = false;
+
     private static final boolean CHECK_NEIGHBOR_FACE_OCCLUSION = true;
     private static final boolean DISABLE_CULL_SAME_OCCLUDES = false;//TODO: FIX TRANSLUCENTS (e.g. stained glass) breaking on chunk boarders with this set to false (it might be something else????)
 
@@ -60,6 +62,8 @@ public class RenderDataFactory {
 
     private int quadCount = 0;
 
+    private final OccupancySet occupancy = new OccupancySet();
+
     //Wont work for double sided quads
     private final class Mesher extends ScanMesher2D {
         public int auxiliaryPosition = 0;
@@ -191,15 +195,16 @@ public class RenderDataFactory {
             boolean a = ModelQueries.isTranslucent(metadata);
             boolean b = ModelQueries.isDoubleSided(metadata);
             //Pre shift by 1
-            type = a|b?0:4;
+            //type = a|b?0:4;
-            type |= b?2:0;
+            //type |= b&!a?2:0;
+            type = a?0:(b?2:4);
         }
         return type;
     }
 
     private static long packPartialQuadData(int modelId, long state, long metadata) {
         //This uses hardcoded data to shuffle things
-        long lightAndBiome =  (state&((0x1FFL<<47)|(0xFFL<<56)))>>1;
+        long lightAndBiome =  (state&((0x1FFL<<47)|(0xFFL<<56)))>>>1;
         lightAndBiome &= ModelQueries.isBiomeColoured(metadata)?-1:~(0x1FFL<<46);//46 not 47 because is already shifted by 1 THIS WASTED 4 HOURS ;-; aaaaaAAAAAA
         lightAndBiome &= ModelQueries.isFullyOpaque(metadata)?~(0xFFL<<55):-1;//If its fully opaque it always uses neighbor light?
 
@@ -217,11 +222,11 @@ public class RenderDataFactory {
         long pureFluid = 0;
         long partialFluid = 0;
 
-        int neighborAcquireMsk = 0;//-+x, -+z, -+y
+        int neighborAcquireMskAndFlags = 0;//-+x, -+z, -+y
         for (int i = 0; i < 32*32*32;) {
             long block = rawSectionData[i];//Get the block mapping
             if (Mapper.isAir(block)) {//If it is air, just emit lighting
-                sectionData[i * 2] = (block&(0xFFL<<56))>>1;
+                sectionData[i * 2] = (block&(0xFFL<<56))>>>1;
                 sectionData[i * 2 + 1] = 0;
             } else {
                 int modelId = rawModelIds[Mapper.getBlockId(block)];
@@ -257,17 +262,17 @@ public class RenderDataFactory {
 
                 int neighborMsk = 0;
                 //-+x
-                neighborMsk |= packedEmpty&1;//-x
+                neighborMsk += packedEmpty&1;//-x
-                neighborMsk |= (packedEmpty>>>30)&0b10;//+x
+                neighborMsk += (packedEmpty>>>30)&0b10;//+x
 
                 //notEmpty = (notEmpty != 0)?1:0;
-                neighborMsk |= ((((i - 1) >> 10) == 0) ? 0b100 : 0)*(packedEmpty!=0?1:0);//-y
+                neighborMsk += ((((i - 1) >> 10) == 0) ? 0b100 : 0)*(packedEmpty!=0?1:0);//-y
-                neighborMsk |= ((((i - 1) >> 10) == 31) ? 0b1000 : 0)*(packedEmpty!=0?1:0);//+y
+                neighborMsk += ((((i - 1) >> 10) == 31) ? 0b1000 : 0)*(packedEmpty!=0?1:0);//+y
-                neighborMsk |= (((((i - 33) >> 5) & 0x1F) == 0) ? 0b10000 : 0)*(((int)notEmpty)!=0?1:0);//-z
+                neighborMsk += (((((i - 33) >> 5) & 0x1F) == 0) ? 0b10000 : 0)*(((int)notEmpty)!=0?1:0);//-z
-                neighborMsk |= (((((i - 1) >> 5) & 0x1F) == 31) ? 0b100000 : 0)*((notEmpty>>>32)!=0?1:0);//+z
+                neighborMsk += (((((i - 1) >> 5) & 0x1F) == 31) ? 0b100000 : 0)*((notEmpty>>>32)!=0?1:0);//+z
-
-                neighborAcquireMsk |= neighborMsk;
 
+                neighborAcquireMskAndFlags |= neighborMsk;
+                neighborAcquireMskAndFlags |= opaque!=0?(1<<6):0;
 
                 opaque = 0;
                 notEmpty = 0;
@@ -275,7 +280,7 @@ public class RenderDataFactory {
                 partialFluid = 0;
             }
         }
-        return neighborAcquireMsk;
+        return neighborAcquireMskAndFlags;
     }
 
     private void acquireNeighborData(WorldSection section, int msk) {
@@ -343,8 +348,8 @@ public class RenderDataFactory {
     private static boolean shouldMeshNonOpaqueBlockFace(int face, long quad, long meta, long neighborQuad, long neighborMeta) {
         if (((quad^neighborQuad)&(0xFFFFL<<26))==0 && (DISABLE_CULL_SAME_OCCLUDES || (ModelQueries.cullsSame(meta)||ModelQueries.faceOccludes(meta, face)))) return false;//This is a hack, if the neigbor and this are the same, dont mesh the face// TODO: FIXME
         if (!ModelQueries.faceExists(meta, face)) return false;//Dont mesh if no face
-        //if (ModelQueries.faceCanBeOccluded(meta, face)) //TODO: maybe enable this
+        if (ModelQueries.faceCanBeOccluded(meta, face)) //TODO: maybe enable this
-            if (ModelQueries.faceOccludes(neighborMeta, face^1)) return false;
+          if (ModelQueries.faceOccludes(neighborMeta, face^1)) return false;
         return true;
     }
 
@@ -461,7 +466,8 @@ public class RenderDataFactory {
 
                         int nib = Mapper.getBlockId(neighborId);
                         if (nib != 0) {//Not air
-                            long meta = this.modelMan.getModelMetadataFromClientId(this.modelMan.getModelId(Mapper.getBlockId(neighborId)));
+                            int cid = this.modelMan.getModelId(nib);
+                            long meta = this.modelMan.getModelMetadataFromClientId(cid);
                             if (ModelQueries.isFullyOpaque(meta)) {//Dont mesh this face
                                 this.blockMesher.skip(1);
                                 continue;
@@ -471,7 +477,7 @@ public class RenderDataFactory {
                             //TODO:FIXME, when non opaque geometry is added
                             if (CHECK_NEIGHBOR_FACE_OCCLUSION) {
                                 boolean culls = false;
-                                culls |= nib==((A>>26)&0xFFFF)&&ModelQueries.cullsSame(meta);
+                                culls |= cid==((A>>26)&0xFFFF)&&ModelQueries.cullsSame(meta);
                                 culls |= ModelQueries.faceOccludes(meta, (axis << 1) | (1 - side));
                                 if (culls) {
                                     this.blockMesher.skip(1);
@@ -484,7 +490,7 @@ public class RenderDataFactory {
 
                         this.blockMesher.putNext(((side == 0) ? 0L : 1L) |
                                 (A&~LM) |
-                                ((neighborId & (0xFFL << 56)) >> 1)
+                                ((neighborId & (0xFFL << 56)) >>> 1)
                         );
                     }
                 }
@@ -561,7 +567,7 @@ public class RenderDataFactory {
                             A &= ~0b110L; A |= getQuadTyping(Am);
                         }
 
-                        long lighter = A;
+                        long lighter = this.sectionData[bi];
                         //if (!ModelQueries.faceUsesSelfLighting(Am, facingForward|(axis*2))) {//TODO: check this is right
                         //    lighter = this.sectionData[bi];
                         //}
@@ -650,7 +656,7 @@ public class RenderDataFactory {
 
                         this.blockMesher.putNext((side == 0 ? 0L : 1L) |
                                 (A&~LM) |
-                                ((neighborId&(0xFFL<<56))>>1)
+                                ((neighborId&(0xFFL<<56))>>>1)
                         );
                     }
                 }
@@ -762,7 +768,9 @@ public class RenderDataFactory {
                         //Check and test if can cull W.R.T neighbor
                         if (Mapper.getBlockId(neighborId) != 0) {//Not air
                             int modelId = this.modelMan.getModelId(Mapper.getBlockId(neighborId));
-                            if (modelId == ((A>>26)&0xFFFF)) {//TODO: FIXME, this technically isnt correct as need to check self occulsion, thinks?
+
+
+                            if (ModelQueries.cullsSame(B) && modelId == ((A>>26)&0xFFFF)) {//TODO: FIXME, this technically isnt correct as need to check self occulsion, thinks?
                                 //TODO: check self occlsuion in the if statment
                                 fail = true;
                             } else {
@@ -777,7 +785,9 @@ public class RenderDataFactory {
                         long nA = this.sectionData[(idx+skipAmount) * 2];
                         long nB = this.sectionData[(idx+skipAmount) * 2 + 1];
                         boolean failB = false;
-                        if ((nA&(0xFFFFL<<26)) == (A&(0xFFFFL<<26))) {//TODO: FIXME, this technically isnt correct as need to check self occulsion, thinks?
+                        //TODO: check self occlusion
+
+                        if (ModelQueries.cullsSame(nB) && (nA&(0xFFFFL<<26)) == (A&(0xFFFFL<<26))) {//TODO: FIXME, this technically isnt correct as need to check self occulsion, thinks?
                             //TODO: check self occlsuion in the if statment
                             failB = true;
                         } else {
@@ -1017,7 +1027,7 @@ public class RenderDataFactory {
                         long A = this.sectionData[(i<<5) * 2];
                         ma.putNext(0L |
                                 (A&~LM) |
-                                ((neighborId&(0xFFL<<56))>>1)
+                                ((neighborId&(0xFFL<<56))>>>1)
                         );
                     } else {skipA++;}
                 } else {skipA++;}
@@ -1039,7 +1049,7 @@ public class RenderDataFactory {
                         long A = this.sectionData[(i*32+31) * 2];
                         mb.putNext(1L |
                                 (A&~LM) |
-                                ((neighborId&(0xFFL<<56))>>1)
+                                ((neighborId&(0xFFL<<56))>>>1)
                         );
                     } else {skipB++;}
                 } else {skipB++;}
@@ -1157,7 +1167,7 @@ public class RenderDataFactory {
                             A &= ~0b110L; A |= getQuadTyping(Am);
                         }
 
-                        long lighter = A;
+                        long lighter = this.sectionData[bi];
                         //if (!ModelQueries.faceUsesSelfLighting(Am, facingForward|(axis*2))) {//TODO: check this is right
                         //    lighter = this.sectionData[bi];
                         //}
@@ -1261,7 +1271,7 @@ public class RenderDataFactory {
                         ma.skip(skipA); skipA = 0;
 
                         //TODO: LIGHTING
-                        long lightData = ((neighborId&(0xFFL<<56))>>1);//A;
+                        long lightData = ((neighborId&(0xFFL<<56))>>>1);//A;
                         //if (!ModelQueries.faceUsesSelfLighting(Am, facingForward|(axis*2))) {//TODO: check this is right
                         //    lighter = this.sectionData[bi];
                         //}
@@ -1322,7 +1332,7 @@ public class RenderDataFactory {
                         mb.skip(skipB); skipB = 0;
 
                         //TODO: LIGHTING
-                        long lightData = ((neighborId&(0xFFL<<56))>>1);//A;
+                        long lightData = ((neighborId&(0xFFL<<56))>>>1);//A;
                         //if (!ModelQueries.faceUsesSelfLighting(Am, facingForward|(axis*2))) {//TODO: check this is right
                         //    lighter = this.sectionData[bi];
                         //}
@@ -1487,6 +1497,7 @@ public class RenderDataFactory {
                 int msk = this.nonOpaqueMasks[i];
                 if ((msk & 1) != 0) {//-x
                     long neighborId = this.neighboringFaces[i];
+                    //TODO also check self occlusion
 
                     int sidx = (i<<5) * 2;
                     long A = this.sectionData[sidx];
@@ -1507,6 +1518,8 @@ public class RenderDataFactory {
 
                 if ((msk & (1<<31)) != 0) {//+x
                     long neighborId = this.neighboringFaces[i+32*32];
+                    //TODO also check self occlusion
+
 
                     int sidx = (i*32+31) * 2;
                     long A = this.sectionData[sidx];
@@ -1559,6 +1572,29 @@ public class RenderDataFactory {
         }
     }
 
+    //Build the occupancy set (used for AO) from the set of fully opaque blocks (atm, this can change in the future if needed to a special occupancy bitset)
+    private final void buildOccupancy() {
+        //We basicly want to record all the points where we go from air to solid or solid to air (this is to just get better compression)
+        for (int i = 0; i < 32*32; i++) {
+            int occ = 0;
+            int msk = this.opaqueMasks[i];
+            //x
+            occ |= msk^(msk>>1);
+            occ |= msk^(msk<<1);
+            //y
+            occ |= i<32*31?msk^this.opaqueMasks[i+32]:0;
+            occ |= 31<i   ?msk^this.opaqueMasks[i-32]:0;
+            //z
+            occ |= (i&31)<31?msk^this.opaqueMasks[i+1]:0;
+            occ |= 0< (i&31)?msk^this.opaqueMasks[i-1]:0;
+
+            //We now have our occlusion mask, fill in our occupancy set
+            for (;occ!=0;occ&=~Integer.lowestOneBit(occ)) {
+                this.occupancy.set(i*32+Integer.numberOfTrailingZeros(occ));
+            }
+        }
+    }
+
     //section is already acquired and gets released by the parent
     public BuiltSection generateMesh(WorldSection section) {
         //TODO: FIXME: because of the exceptions that are thrown when aquiring modelId
@@ -1589,6 +1625,8 @@ public class RenderDataFactory {
             }
         }
 
+        this.occupancy.reset();
+
         this.minX = Integer.MAX_VALUE;
         this.minY = Integer.MAX_VALUE;
         this.minZ = Integer.MAX_VALUE;
@@ -1602,10 +1640,12 @@ public class RenderDataFactory {
         Arrays.fill(this.fluidMasks, 0);
 
         //Prepare everything
-        int neighborMsk = this.prepareSectionData(section._unsafeGetRawDataArray());
+        int neighborMskAndFlags = this.prepareSectionData(section._unsafeGetRawDataArray());
-        if (neighborMsk>>31!=0) {//We failed to get everything so throw exception
+        if ((neighborMskAndFlags&(1<<31))!=0) {//We failed to get everything so throw exception
-            throw new IdNotYetComputedException(neighborMsk&(~(1<<31)), true);
+            throw new IdNotYetComputedException(neighborMskAndFlags&((1<<20)-1), true);
         }
+        int neighborMsk = neighborMskAndFlags&0b11_11_11;
+        int flags = neighborMskAndFlags>>>6;
         if (CHECK_NEIGHBOR_FACE_OCCLUSION) {
             this.acquireNeighborData(section, neighborMsk);
         }
@@ -1619,6 +1659,11 @@ public class RenderDataFactory {
             throw e;
         }
 
+        //We only care if we have quads
+        if (BUILD_OCCUPANCY_SET && this.quadCount != 0 && (flags&1) != 0) {
+            this.buildOccupancy();
+        }
+
         //TODO:NOTE! when doing face culling of translucent blocks,
         // if the connecting type of the translucent block is the same AND the face is full, discard it
         // this stops e.g. multiple layers of glass (and ocean) from having 3000 layers of quads etc
@@ -1653,7 +1698,13 @@ public class RenderDataFactory {
         aabb |= (this.maxY-this.minY-1)<<20;
         aabb |= (this.maxZ-this.minZ-1)<<25;
 
-        return new BuiltSection(section.key, section.getNonEmptyChildren(), aabb, buff, offsets);
+        MemoryBuffer occupancy = null;
+        if (BUILD_OCCUPANCY_SET && !this.occupancy.isEmpty()) {
+            occupancy = new MemoryBuffer(this.occupancy.writeSize());
+            this.occupancy.write(occupancy.address, false);
+        }
+
+        return new BuiltSection(section.key, section.getNonEmptyChildren(), aabb, buff, offsets, occupancy);
     }
 
     public void free() {

src/main/java/me/cortex/voxy/client/core/rendering/building/RenderGenerationService.java

@@ -4,8 +4,8 @@ import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
 import me.cortex.voxy.client.core.model.IdNotYetComputedException;
 import me.cortex.voxy.client.core.model.ModelBakerySubsystem;
-import me.cortex.voxy.common.thread.ServiceSlice;
+import me.cortex.voxy.common.thread.Service;
-import me.cortex.voxy.common.thread.ServiceThreadPool;
+import me.cortex.voxy.common.thread.ServiceManager;
 import me.cortex.voxy.common.util.Pair;
 import me.cortex.voxy.common.world.WorldEngine;
 import me.cortex.voxy.common.world.WorldSection;
@@ -15,7 +15,6 @@ import java.util.List;
 import java.util.concurrent.PriorityBlockingQueue;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.StampedLock;
-import java.util.function.BooleanSupplier;
 import java.util.function.Consumer;
 
 //TODO: Add a render cache
@@ -60,26 +59,27 @@ public class RenderGenerationService {
     private Consumer<BuiltSection> resultConsumer;
     private final boolean emitMeshlets;
 
-    private final ServiceSlice threads;
+    private final Service service;
 
 
-    public RenderGenerationService(WorldEngine world, ModelBakerySubsystem modelBakery, ServiceThreadPool serviceThreadPool, boolean emitMeshlets) {
+    /*
-        this(world, modelBakery, serviceThreadPool, emitMeshlets, ()->true);
+    public RenderGenerationService(WorldEngine world, ModelBakerySubsystem modelBakery, ServiceManager sm, boolean emitMeshlets) {
-    }
+        this(world, modelBakery, sm, emitMeshlets, ()->true);
+    }*/
 
-    public RenderGenerationService(WorldEngine world, ModelBakerySubsystem modelBakery, ServiceThreadPool serviceThreadPool, boolean emitMeshlets, BooleanSupplier taskLimiter) {
+    public RenderGenerationService(WorldEngine world, ModelBakerySubsystem modelBakery, ServiceManager sm, boolean emitMeshlets) {
         this.emitMeshlets = emitMeshlets;
         this.world = world;
         this.modelBakery = modelBakery;
 
-        this.threads = serviceThreadPool.createService("Section mesh generation service", 100, ()->{
+        this.service = sm.createService(()->{
             //Thread local instance of the factory
             var factory = new RenderDataFactory(this.world, this.modelBakery.factory, this.emitMeshlets);
             IntOpenHashSet seenMissed = new IntOpenHashSet(128);
             return new Pair<>(() -> {
                 this.processJob(factory, seenMissed);
             }, factory::free);
-        }, taskLimiter);
+        }, 10, "Section mesh generation service", ()->modelBakery.getProcessingCount()<400||RenderGenerationService.MESH_FAILED_COUNTER.get()<500);
     }
 
     public void setResultConsumer(Consumer<BuiltSection> consumer) {
@@ -258,8 +258,8 @@ public class RenderGenerationService {
                 this.taskQueue.add(task);
                 this.taskQueueCount.incrementAndGet();
 
-                if (this.threads.isAlive()) {//Only execute if were not dead
+                if (this.service.isLive()) {//Only execute if were not dead
-                    this.threads.execute();//Since we put in queue, release permit
+                    this.service.execute();//Since we put in queue, release permit
                 }
             }
         }
@@ -282,7 +282,7 @@ public class RenderGenerationService {
 
 
     public void enqueueTask(long pos) {
-        if (!this.threads.isAlive()) {
+        if (!this.service.isLive()) {
             return;
         }
         boolean[] isOurs = new boolean[1];
@@ -298,7 +298,7 @@ public class RenderGenerationService {
             task.updatePriority();
             this.taskQueue.add(task);
             this.taskQueueCount.incrementAndGet();
-            this.threads.execute();
+            this.service.execute();
         }
     }
 
@@ -310,8 +310,8 @@ public class RenderGenerationService {
 
     public void shutdown() {
         //Steal and free as much work as possible
-        while (this.threads.hasJobs()) {
+        while (this.service.numJobs() != 0) {
-            int i = this.threads.drain();
+            int i = this.service.drain();
             if (i == 0) break;
             {
                 long stamp = this.taskMapLock.writeLock();
@@ -331,7 +331,7 @@ public class RenderGenerationService {
         }
 
         //Shutdown the threads
-        this.threads.shutdown();
+        this.service.shutdown();
 
         //Cleanup any remaining data
         while (!this.taskQueue.isEmpty()) {
@@ -354,14 +354,12 @@ public class RenderGenerationService {
     }
 
     private long lastChangedTime = 0;
-    private int failedCounter = 0;
     public void addDebugData(List<String> debug) {
-        if (System.currentTimeMillis()-this.lastChangedTime > 1000) {
+        if (System.currentTimeMillis()-this.lastChangedTime > 100) {
-            this.failedCounter = 0;
+            MESH_FAILED_COUNTER.set(0);
             this.lastChangedTime = System.currentTimeMillis();
         }
-        this.failedCounter += MESH_FAILED_COUNTER.getAndSet(0);
+        debug.add("RSSQ/TFC: " + this.taskQueueCount.get() + "/" + MESH_FAILED_COUNTER.get());//render section service queue, Task Fail Counter
-        debug.add("RSSQ/TFC: " + this.taskQueueCount.get() + "/" + this.failedCounter);//render section service queue, Task Fail Counter
 
     }
 

src/main/java/me/cortex/voxy/client/core/rendering/hierachical/AsyncNodeManager.java

@@ -249,7 +249,7 @@ public class AsyncNodeManager {
 
         //Limit uploading as well as by geometry capacity being available
         // must have 50 mb of free geometry space to upload
-        for (int limit = 0; limit < 200 && ((this.geometryCapacity-this.geometryManager.getGeometryUsedBytes())>50_000_000L); limit++) {
+        for (int limit = 0; limit < 300 && ((this.geometryCapacity-this.geometryManager.getGeometryUsedBytes())>50_000_000L); limit++) {
             var job = this.geometryUpdateQueue.poll();
             if (job == null)
                 break;
@@ -478,7 +478,10 @@ public class AsyncNodeManager {
         results.usedGeometry = this.geometryManager.getGeometryUsedBytes();
         results.currentMaxNodeId = this.manager.getCurrentMaxNodeId();
 
-        this.needsWaitForSync |= results.geometryUpload.currentElemCopyAmount*8L > 4L<<20;//4mb limit per frame
+        this.needsWaitForSync |= results.geometryUpload.currentElemCopyAmount*8L > 2L<<20;//2mb limit per frame
+        this.needsWaitForSync |= results.cleanerOperations.size() > 1024;
+        this.needsWaitForSync |= results.scatterWriteLocationMap.size() > 4096;
+        this.needsWaitForSync |= results.tlnDelta.size() > 10;
 
         if (!RESULT_HANDLE.compareAndSet(this, null, results)) {
             throw new IllegalArgumentException("Should always have null");

src/main/java/me/cortex/voxy/client/core/rendering/hierachical/DebugRenderer.java

@@ -7,7 +7,7 @@ import me.cortex.voxy.client.core.gl.shader.ShaderType;
 import me.cortex.voxy.client.core.rendering.Viewport;
 import me.cortex.voxy.client.core.rendering.util.SharedIndexBuffer;
 import me.cortex.voxy.client.core.rendering.util.UploadStream;
-import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.Mth;
 import org.joml.Matrix4f;
 import org.joml.Vector3f;
 import org.lwjgl.opengl.GL15;
@@ -38,9 +38,9 @@ public class DebugRenderer {
 
     private void uploadUniform(Viewport<?> viewport) {
         long ptr = UploadStream.INSTANCE.upload(this.uniformBuffer, 0, 1024);
-        int sx = MathHelper.floor(viewport.cameraX)>>5;
+        int sx = Mth.floor(viewport.cameraX)>>5;
-        int sy = MathHelper.floor(viewport.cameraY)>>5;
+        int sy = Mth.floor(viewport.cameraY)>>5;
-        int sz = MathHelper.floor(viewport.cameraZ)>>5;
+        int sz = Mth.floor(viewport.cameraZ)>>5;
 
         new Matrix4f(viewport.projection).mul(viewport.modelView).getToAddress(ptr); ptr += 4*4*4;
 

src/main/java/me/cortex/voxy/client/core/rendering/hierachical/HierarchicalOcclusionTraverser.java

@@ -2,7 +2,7 @@ package me.cortex.voxy.client.core.rendering.hierachical;
 
 import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
 import me.cortex.voxy.client.RenderStatistics;
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.gl.GlBuffer;
 import me.cortex.voxy.client.core.gl.shader.AutoBindingShader;
 import me.cortex.voxy.client.core.gl.shader.Shader;

src/main/java/me/cortex/voxy/client/core/rendering/hierachical/NodeManager.java

@@ -136,7 +136,7 @@ public class NodeManager {
         z <<= lvl;
         long p2 = WorldEngine.getWorldSectionId(0, x, y, z);
         if (WorldEngine.getLevel(p2) != 0 || WorldEngine.getX(p2) != x || WorldEngine.getY(p2) != y || WorldEngine.getZ(p2) != z) {
-            throw new IllegalStateException("Position not valid at all levels");
+            throw new IllegalStateException("Position not valid at all levels: " + pos + "-"+WorldEngine.pprintPos(pos) + ":"+WorldEngine.pprintPos(p2));
         }
     }
 

src/main/java/me/cortex/voxy/client/core/rendering/hierachical/TestNodeManager.java

@@ -39,9 +39,15 @@ public class TestNodeManager {
                 this.removeSection(oldId);
             }
             int newId = this.allocation.allocateNext();
+            if (newId == -1) {
+                Logger.error("Allocator full: "+this.allocation.getCount()+" " +section, new Throwable());
+                section.free();
+                return -1;
+            }
             var entry = new Entry(section.position, section.geometryBuffer.size);
-            if (this.sections.put(newId, entry) != null) {
+            var old = this.sections.put(newId, entry);
-                throw new IllegalStateException();
+            if (old != null) {
+                throw new IllegalStateException(oldId + ","+newId+" "+old+","+entry);
             }
             this.memoryInUse += entry.size;
             section.free();
@@ -186,7 +192,7 @@ public class TestNodeManager {
             if (geometrySize != 0) {
                 buff = new MemoryBuffer(geometrySize);
             }
-            var builtGeometry = new BuiltSection(pos, (byte) childExistence, -2, buff, null);
+            var builtGeometry = new BuiltSection(pos, (byte) childExistence, -2, buff, null, null);
             this.nodeManager.processGeometryResult(builtGeometry);
         }
 
@@ -282,22 +288,24 @@ public class TestNodeManager {
         int ITER_COUNT = 5_000;
         int INNER_ITER_COUNT = 1_000_000;
         boolean GEO_REM = true;
+        boolean LIMIT_REQUEST_SEC_ALLOCATION = true;
 
         AtomicInteger finished = new AtomicInteger();
         HashSet<List<StackTraceElement>> seenTraces = new HashSet<>();
 
+        Logger.SHUTUP_INFO = true;
         Logger.SHUTUP = true;
 
-        if (true) {
+        if (false) {
             for (int q = 0; q < ITER_COUNT; q++) {
                 //Logger.info("Iteration "+ q);
-                if (runTest(INNER_ITER_COUNT, q, seenTraces, GEO_REM)) {
+                if (runTest(INNER_ITER_COUNT, q, seenTraces, GEO_REM, LIMIT_REQUEST_SEC_ALLOCATION)) {
                     finished.incrementAndGet();
                 }
             }
         } else {
             IntStream.range(0, ITER_COUNT).parallel().forEach(i->{
-                if (runTest(INNER_ITER_COUNT, i, seenTraces, GEO_REM)) {
+                if (runTest(INNER_ITER_COUNT, i, seenTraces, GEO_REM, LIMIT_REQUEST_SEC_ALLOCATION)) {
                     finished.incrementAndGet();
                 }
             });
@@ -314,7 +322,7 @@ public class TestNodeManager {
         return WorldEngine.getWorldSectionId(lvl, r.nextInt(bound)+(WorldEngine.getX(top)<<4), r.nextInt(bound)+(WorldEngine.getY(top)<<4), r.nextInt(bound)+(WorldEngine.getZ(top)<<4));
     }
 
-    private static boolean runTest(int ITERS, int testIdx, Set<List<StackTraceElement>> traces, boolean geoRemoval) {
+    private static boolean runTest(int ITERS, int testIdx, Set<List<StackTraceElement>> traces, boolean geoRemoval, boolean requestLimiter) {
         Random r = new Random(testIdx * 1234L);
         try {
             var test = new TestBase();
@@ -334,7 +342,7 @@ public class TestNodeManager {
             //Fuzzy bruteforce everything
             for (int x = -R; x<=R; x++) {
                 for (int z = -R; z<=R; z++) {
-                    for (int y = -8; y<=7; y++) {
+                    for (int y = -1; y<=0; y++) {
                         tops.add(WorldEngine.getWorldSectionId(4, x, y, z));
                     }
                 }
@@ -351,28 +359,29 @@ public class TestNodeManager {
                 long pos = rPos(r, tops);
                 int op = r.nextInt(5);
                 int extra = r.nextInt(256);
+                boolean geoAddOk = ((!requestLimiter)||(test.geometryManager.allocation.getLimit()-test.geometryManager.allocation.getCount())>1000);
                 boolean hasGeometry = r.nextBoolean();
                 boolean addRemTLN = r.nextInt(64) == 0;
                 boolean extraBool = r.nextBoolean();
                 if (op == 0 && addRemTLN) {
-                    pos = WorldEngine.getWorldSectionId(4, r.nextInt(5)-2, r.nextInt(32)-16, r.nextInt(5)-2);
+                    pos = WorldEngine.getWorldSectionId(4, r.nextInt(5)-2, r.nextInt(2)-1, r.nextInt(5)-2);//r.nextInt(16)-8//for y
                     boolean cont = tops.contains(pos);
                     if (cont&&extraBool&&tops.size()>1) {
                         extraBool = true;
                         test.remTopPos(pos);
                         tops.rem(pos);
-                    } else if (!cont) {
+                    } else if ((!cont)&&geoAddOk) {
                         extraBool = false;
                         test.putTopPos(pos);
                         tops.add(pos);
                     }
-                } else if (op == 0) {
+                } else if (op == 0&&geoAddOk) {
                     test.request(pos);
                 }
                 if (op == 1) {
                     test.childUpdate(pos, extra);
                 }
-                if (op == 2) {
+                if (op == 2&&((!hasGeometry)||geoAddOk)) {
                     test.meshUpdate(pos, extra, hasGeometry ? 100 : 0);
                 }
                 if (op == 3 && geoRemoval) {
@@ -592,10 +601,9 @@ public class TestNodeManager {
         test.printNodeChanges();
         Logger.info("\n\n");
 
-        var positions = new ArrayList<>(aa.keySet().stream().filter(k->{
+        var positions = new ArrayList<>(aa.keySet().longStream().filter(k->{
             return WorldEngine.getLevel(k)!=0;
-        }).toList());
+        }).sorted().mapToObj(Long::valueOf).toList());
-        positions.sort(Long::compareTo);
         Collections.shuffle(positions, r);
 
         Logger.info("Removing", WorldEngine.pprintPos(positions.get(0)));

src/main/java/me/cortex/voxy/client/core/rendering/section/AbstractSectionRenderer.java

@@ -1,31 +0,0 @@
-package me.cortex.voxy.client.core.rendering.section;
-
-
-import me.cortex.voxy.client.core.model.ModelStore;
-import me.cortex.voxy.client.core.rendering.Viewport;
-import me.cortex.voxy.client.core.rendering.section.geometry.IGeometryData;
-
-import java.util.List;
-
-//Takes in mesh ids from the hierachical traversal and may perform more culling then renders it
-public abstract class AbstractSectionRenderer <T extends Viewport<T>, J extends IGeometryData> {
-    protected final J geometryManager;
-    protected final ModelStore modelStore;
-    protected AbstractSectionRenderer(ModelStore modelStore, J geometryManager) {
-        this.geometryManager = geometryManager;
-        this.modelStore = modelStore;
-    }
-
-    public abstract void renderOpaque(T viewport);
-    public abstract void buildDrawCalls(T viewport);
-    public abstract void renderTemporal(T viewport);
-    public abstract void renderTranslucent(T viewport);
-    public abstract T createViewport();
-    public abstract void free();
-
-    public J getGeometryManager() {
-        return this.geometryManager;
-    }
-
-    public void addDebug(List<String> lines) {}
-}

src/main/java/me/cortex/voxy/client/core/rendering/section/backend/AbstractSectionRenderer.java

@@ -0,0 +1,104 @@
+package me.cortex.voxy.client.core.rendering.section.backend;
+
+
+import me.cortex.voxy.client.core.AbstractRenderPipeline;
+import me.cortex.voxy.client.core.gl.shader.Shader;
+import me.cortex.voxy.client.core.gl.shader.ShaderType;
+import me.cortex.voxy.client.core.model.ModelStore;
+import me.cortex.voxy.client.core.rendering.Viewport;
+import me.cortex.voxy.client.core.rendering.section.geometry.BasicSectionGeometryData;
+import me.cortex.voxy.client.core.rendering.section.geometry.IGeometryData;
+import me.cortex.voxy.common.Logger;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.dimension.DimensionType;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+
+//Takes in mesh ids from the hierachical traversal and may perform more culling then renders it
+public abstract class AbstractSectionRenderer <T extends Viewport<T>, J extends IGeometryData> {
+    public interface FactoryConstructor<VIEWPORT extends Viewport<VIEWPORT>, GEODATA extends IGeometryData> {
+        AbstractSectionRenderer<VIEWPORT, GEODATA> create(AbstractRenderPipeline pipeline, ModelStore modelStore, GEODATA geometryData);
+    }
+
+    public record Factory<VIEWPORT extends Viewport<VIEWPORT>, GEODATA extends IGeometryData>(Class<? extends AbstractSectionRenderer<VIEWPORT, GEODATA>> clz, FactoryConstructor<VIEWPORT, GEODATA> constructor) {
+        public AbstractSectionRenderer<VIEWPORT, GEODATA> create(AbstractRenderPipeline pipeline, ModelStore store, IGeometryData geometryData) {
+            return this.constructor.create(pipeline, store, (GEODATA) geometryData);
+        }
+
+        public static <VIEWPORT2 extends Viewport<VIEWPORT2>, GEODATA2 extends IGeometryData> Factory<VIEWPORT2, GEODATA2> create(Class<? extends AbstractSectionRenderer<VIEWPORT2, GEODATA2>> clz) {
+            var constructors = clz.getConstructors();
+            if (constructors.length != 1) {
+                Logger.error("Render backend " + clz.getCanonicalName() + " had more then 1 constructor");
+                return null;
+            }
+            var constructor = constructors[0];
+            var params = constructor.getParameterTypes();
+            if (params.length != 3 || params[0] != AbstractRenderPipeline.class || params[1] != ModelStore.class || !IGeometryData.class.isAssignableFrom(params[2])) {
+                Logger.error("Render backend " + clz.getCanonicalName() + " had invalid constructor");
+                return null;
+            }
+            return new Factory<>(clz, (a,b,c)-> {
+                try {
+                    return (AbstractSectionRenderer<VIEWPORT2, GEODATA2>) constructor.newInstance(a,b,c);
+                } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }
+    }
+
+
+    protected final J geometryManager;
+    protected final ModelStore modelStore;
+    protected AbstractSectionRenderer(ModelStore modelStore, J geometryManager) {
+        this.geometryManager = geometryManager;
+        this.modelStore = modelStore;
+    }
+
+    public abstract void renderOpaque(T viewport);
+    public abstract void buildDrawCalls(T viewport);
+    public abstract void renderTemporal(T viewport);
+    public abstract void renderTranslucent(T viewport);
+    public abstract T createViewport();
+    public abstract void free();
+
+    public J getGeometryManager() {
+        return this.geometryManager;
+    }
+
+    public void addDebug(List<String> lines) {}
+
+    protected static void addDirectionalFaceTint(Shader.Builder<?> builder, ClientLevel cl) {
+        builder.define("NO_SHADE_FACE_TINT", cl.getShade(Direction.UP, false));
+        builder.define("UP_FACE_TINT", cl.getShade(Direction.UP, true));
+        builder.define("DOWN_FACE_TINT", cl.getShade(Direction.DOWN, true));
+        builder.define("Z_AXIS_FACE_TINT", cl.getShade(Direction.NORTH, true));//assumed here that Direction.SOUTH returns the same value
+        builder.define("X_AXIS_FACE_TINT", cl.getShade(Direction.EAST, true));//assumed here that Direction.WEST returns the same value
+        /*
+        //TODO: generate the tinting table here and use the replacement feature
+        float[] tints = new float[7];
+        tints[6] = cl.getShade(Direction.UP, false);
+        for (Direction direction : Direction.values()) {
+            tints[direction.get3DDataValue()] = cl.getShade(direction, true);
+        }*/
+    }
+
+    protected static Shader tryCompilePatchedOrNormal(Shader.Builder<?> builder, String shader, String original) {
+        boolean patched = shader != original;//This is the correct comparison type (reference)
+        try {
+            return builder.clone()
+                    .defineIf("PATCHED_SHADER", patched)
+                    .addSource(ShaderType.FRAGMENT, shader)
+                    .compile();
+        } catch (RuntimeException e) {
+            if (patched) {
+                Logger.error("Failed to compile shader patch, using normal pipeline to prevent errors", e);
+                return tryCompilePatchedOrNormal(builder, original, original);
+            } else {
+                throw e;
+            }
+        }
+    }
+}

src/main/java/me/cortex/voxy/client/core/rendering/section/backend/mdic/MDICSectionRenderer.java

@@ -1,7 +1,8 @@
-package me.cortex.voxy.client.core.rendering.section;
+package me.cortex.voxy.client.core.rendering.section.backend.mdic;
 
 
 import me.cortex.voxy.client.RenderStatistics;
+import me.cortex.voxy.client.VoxyClient;
 import me.cortex.voxy.client.core.AbstractRenderPipeline;
 import me.cortex.voxy.client.core.gl.Capabilities;
 import me.cortex.voxy.client.core.gl.GlBuffer;
@@ -10,6 +11,7 @@ import me.cortex.voxy.client.core.gl.shader.Shader;
 import me.cortex.voxy.client.core.gl.shader.ShaderLoader;
 import me.cortex.voxy.client.core.gl.shader.ShaderType;
 import me.cortex.voxy.client.core.model.ModelStore;
+import me.cortex.voxy.client.core.rendering.section.backend.AbstractSectionRenderer;
 import me.cortex.voxy.client.core.rendering.section.geometry.BasicSectionGeometryData;
 import me.cortex.voxy.client.core.rendering.util.DownloadStream;
 import me.cortex.voxy.client.core.rendering.util.LightMapHelper;
@@ -17,7 +19,8 @@ import me.cortex.voxy.client.core.rendering.util.SharedIndexBuffer;
 import me.cortex.voxy.client.core.rendering.util.UploadStream;
 import me.cortex.voxy.common.Logger;
 import me.cortex.voxy.common.world.WorldEngine;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
+import net.minecraft.core.Direction;
 import org.joml.Matrix4f;
 import org.lwjgl.system.MemoryUtil;
 
@@ -40,6 +43,8 @@ import static org.lwjgl.opengl.NVRepresentativeFragmentTest.GL_REPRESENTATIVE_FR
 
 //Uses MDIC to render the sections
 public class MDICSectionRenderer extends AbstractSectionRenderer<MDICViewport, BasicSectionGeometryData> {
+    public static final Factory<MDICViewport, BasicSectionGeometryData> FACTORY = AbstractSectionRenderer.Factory.create(MDICSectionRenderer.class);
+
     private static final int TRANSLUCENT_OFFSET = 400_000;//in draw calls
     private static final int TEMPORAL_OFFSET = 500_000;//in draw calls
     private static final int STATISTICS_BUFFER_BINDING = 8;
@@ -95,7 +100,7 @@ public class MDICSectionRenderer extends AbstractSectionRenderer<MDICViewport, B
         this.pipeline = pipeline;
         //The pipeline can be used to transform the renderer in abstract ways
 
-        String vertex = ShaderLoader.parse("voxy:lod/gl46/quads2.vert");
+        String vertex = ShaderLoader.parse("voxy:lod/gl46/quads3.vert");
         String taa = pipeline.taaFunction("taaShift");
         if (taa != null) {
             vertex += "\n"+taa;//inject it at the end
@@ -104,10 +109,13 @@ public class MDICSectionRenderer extends AbstractSectionRenderer<MDICViewport, B
                 .defineIf("TAA_PATCH", taa != null)
                 .defineIf("DEBUG_RENDER", false)
 
-                .defineIf("DARKENED_TINTING", MinecraftClient.getInstance().world.getDimensionEffects().isDarkened())//TODO: FIXME: this is really jank atm
+                //.defineIf("USE_NV_BARRY", Capabilities.INSTANCE.nvBarryCoords)
 
                 .addSource(ShaderType.VERTEX, vertex);
 
+        //Apply per face tinting
+        addDirectionalFaceTint(builder, Minecraft.getInstance().level);
+
         String frag = ShaderLoader.parse("voxy:lod/gl46/quads.frag");
 
         String opaqueFrag = pipeline.patchOpaqueShader(this, frag);
@@ -117,28 +125,9 @@ public class MDICSectionRenderer extends AbstractSectionRenderer<MDICViewport, B
         this.terrainShader = tryCompilePatchedOrNormal(builder, opaqueFrag, frag);
 
         String translucentFrag = pipeline.patchTranslucentShader(this, frag);
-        if (translucentFrag != null) {
+        translucentFrag = translucentFrag==null?frag:translucentFrag;
-            this.translucentTerrainShader = tryCompilePatchedOrNormal(builder, translucentFrag, frag);
-        } else {
-            this.translucentTerrainShader = this.terrainShader;
-        }
-    }
 
-    private static Shader tryCompilePatchedOrNormal(Shader.Builder<?> builder, String shader, String original) {
+        this.translucentTerrainShader = tryCompilePatchedOrNormal(builder.define("TRANSLUCENT"), translucentFrag, frag);
-        boolean patched = shader != original;//This is the correct comparison type (reference)
-        try {
-            return builder.clone()
-                    .defineIf("PATCHED_SHADER", patched)
-                    .addSource(ShaderType.FRAGMENT, shader)
-                    .compile();
-        } catch (RuntimeException e) {
-            if (patched) {
-                Logger.error("Failed to compile shader patch, using normal pipeline to prevent errors", e);
-                return tryCompilePatchedOrNormal(builder, original, original);
-            } else {
-                throw e;
-            }
-        }
     }
 
     private void uploadUniformBuffer(MDICViewport viewport) {
@@ -180,6 +169,7 @@ public class MDICSectionRenderer extends AbstractSectionRenderer<MDICViewport, B
 
 
         glDisable(GL_CULL_FACE);
+        glDisable(GL_BLEND);
         glEnable(GL_DEPTH_TEST);
         this.terrainShader.bind();
         glBindVertexArray(GlVertexArray.STATIC_VAO);//Needs to be before binding
@@ -188,7 +178,14 @@ public class MDICSectionRenderer extends AbstractSectionRenderer<MDICViewport, B
 
         glMemoryBarrier(GL_COMMAND_BARRIER_BIT|GL_SHADER_STORAGE_BARRIER_BIT);//Barrier everything is needed
         glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);
+
+        if (VoxyClient.getOcclusionDebugState()==3) {
+            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+        }
         glMultiDrawElementsIndirectCountARB(GL_TRIANGLES, GL_UNSIGNED_SHORT, indirectOffset, drawCountOffset, maxDrawCount, 0);
+        if (VoxyClient.getOcclusionDebugState()==3) {
+            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+        }
 
         glEnable(GL_CULL_FACE);
         glBindVertexArray(0);
@@ -360,11 +357,9 @@ public class MDICSectionRenderer extends AbstractSectionRenderer<MDICViewport, B
 
     @Override
     public void free() {
-        if (this.terrainShader != this.translucentTerrainShader) {
-            this.translucentTerrainShader.free();
-        }
         this.uniform.free();
         this.distanceCountBuffer.free();
+        this.translucentTerrainShader.free();
         this.terrainShader.free();
         this.commandGenShader.free();
         this.cullShader.free();

src/main/java/me/cortex/voxy/client/core/rendering/section/backend/mdic/MDICViewport.java

@@ -1,4 +1,4 @@
-package me.cortex.voxy.client.core.rendering.section;
+package me.cortex.voxy.client.core.rendering.section.backend.mdic;
 
 import me.cortex.voxy.client.core.gl.GlBuffer;
 import me.cortex.voxy.client.core.rendering.Viewport;

src/main/java/me/cortex/voxy/client/core/rendering/section/geometry/BasicAsyncGeometryManager.java

@@ -11,11 +11,12 @@ import org.lwjgl.system.MemoryUtil;
 
 import java.util.function.Consumer;
 
-import static me.cortex.voxy.client.core.rendering.section.geometry.BasicSectionGeometryManager.SECTION_METADATA_SIZE;
 
 //Is basicly the manager for an "undefined" data store, the underlying store is irrelevant
 // this manager serves as an overlay, that is, it allows an implementation to do "async management" of the data store
 public class BasicAsyncGeometryManager implements IGeometryManager {
+    public static final int SECTION_METADATA_SIZE = 32;
+
     private static final long GEOMETRY_ELEMENT_SIZE = 8;
     private final HierarchicalBitSet allocationSet;
     private final AllocationArena allocationHeap = new AllocationArena();

src/main/java/me/cortex/voxy/client/core/rendering/section/geometry/BasicSectionGeometryData.java

@@ -34,7 +34,7 @@ public class BasicSectionGeometryData implements IGeometryData {
         Logger.info("if your game crashes/exits here without any other log message, try manually decreasing the geometry capacity");
         glGetError();//Clear any errors
         GlBuffer buffer = null;
-        if (!(Capabilities.INSTANCE.isNvidia)) {// && ThreadUtils.isWindows
+        if (!(Capabilities.INSTANCE.isNvidia&&Capabilities.INSTANCE.sparseBuffer)) {//This hack makes it so it doesnt crash on renderdoc
             buffer = new GlBuffer(geometryCapacity, false);//Only do this if we are not on nvidia
             //TODO: FIXME: TEST, see if the issue is that we are trying to zero the entire buffer, try only zeroing increments
             // or dont zero it at all
@@ -71,6 +71,7 @@ public class BasicSectionGeometryData implements IGeometryData {
         if (this.geometryBuffer.isSparse()) {
             if (this.sparseCommitment < size) {//if we try to access memory outside the allocation range, allocate it
                 glBindBuffer(GL_ARRAY_BUFFER, this.geometryBuffer.id);
+                size += 65536L*1024;//increase size by 64mb to prevent driver allocation thrashing
                 glBufferPageCommitmentARB(GL_ARRAY_BUFFER, this.sparseCommitment, size-this.sparseCommitment, true);
                 glBindBuffer(GL_ARRAY_BUFFER, 0);
                 this.sparseCommitment = size;

src/main/java/me/cortex/voxy/client/core/rendering/section/geometry/BasicSectionGeometryManager.java

@@ -135,7 +135,8 @@ public class BasicSectionGeometryManager extends AbstractSectionGeometryManager
         }
         var oldMetadata = this.sectionMetadata.set(id, null);
         this.geometry.downloadRemove(oldMetadata.geometryPtr, buffer ->
-            callback.accept(new BuiltSection(oldMetadata.position, oldMetadata.childExistence, oldMetadata.aabb, buffer.copy(), oldMetadata.offsets))
+                //TODO: occupancy
+            callback.accept(new BuiltSection(oldMetadata.position, oldMetadata.childExistence, oldMetadata.aabb, buffer.copy(), oldMetadata.offsets, null))
         );
         //this.geometry.free(oldMetadata.geometryPtr);
         this.invalidatedSectionIds.add(id);

src/main/java/me/cortex/voxy/client/core/rendering/util/ComputeUtils.java

@@ -1,94 +0,0 @@
-package me.cortex.voxy.client.core.rendering.util;
-
-import me.cortex.voxy.client.core.gl.GlBuffer;
-import me.cortex.voxy.client.core.gl.shader.Shader;
-import me.cortex.voxy.client.core.gl.shader.ShaderType;
-import org.lwjgl.system.MemoryUtil;
-
-import java.util.function.Supplier;
-
-import static org.lwjgl.opengl.GL20.glUniform1i;
-import static org.lwjgl.opengl.GL30.glBindBufferBase;
-import static org.lwjgl.opengl.GL43.GL_SHADER_STORAGE_BUFFER;
-import static org.lwjgl.opengl.GL43C.glDispatchCompute;
-
-//Utilities for common operations not suited for basic gl functions
-// such as sparse memory setting
-
-//TODO CLEAN THIS SHIT UP
-public class ComputeUtils {
-    private ComputeUtils() {}
-    public static ComputeUtils INSTANCE = new ComputeUtils();
-    private static final int SETTING_BUFFER_BINDING = 1;
-    private static final int ENTRY_BUFFER_BINDING = 2;
-
-    //TODO: FIXME! This should itself be just a raw streaming buffer/mapped ptr (probably)
-    private final GlBuffer SCRATCH = new GlBuffer(1<<20);//1 MB scratch buffer... this should be enough.. right?
-
-    private int maxCount;
-    private int count;
-    private long ptr;
-
-    private final Supplier<Shader> uintSetShader = makeCacheSetShader("uint");
-    public void prepSetUint(int maxCount) {
-        if (this.count != 0 || this.maxCount != 0 || this.ptr != 0) {
-            throw new IllegalStateException();
-        }
-        this.ptr = UploadStream.INSTANCE.upload(SCRATCH, 0, maxCount*8L);
-        this.maxCount = maxCount;
-    }
-
-    public void pushSetUint(int index, int value) {
-        //For uint it goes
-        // {uint value; uint index;}
-        if (this.maxCount <= this.count++) {
-            throw new IllegalStateException("Pushed to many values to prepared set");
-        }
-        MemoryUtil.memPutInt(this.ptr, value); this.ptr += 4;
-        MemoryUtil.memPutInt(this.ptr, index); this.ptr += 4;
-    }
-
-    public void finishSetUint(GlBuffer dst) {
-        UploadStream.INSTANCE.commit();
-        this.uintSetShader.get().bind();
-        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, SETTING_BUFFER_BINDING, dst.id);
-        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, ENTRY_BUFFER_BINDING, this.SCRATCH.id);
-        glUniform1i(0, this.count);
-        glDispatchCompute((this.count+127)/128, 1, 1);
-        this.ptr = 0;
-        this.maxCount = 0;
-        this.count = 0;
-    }
-
-
-
-
-
-    private static Supplier<Shader> makeCacheSetShader(String type) {
-        return makeAndCache(()->makeSetShader(type));
-    }
-
-    private static Shader makeSetShader(String type) {
-        return Shader.make()
-                .define("TYPE", type)
-                .define("SETTING_BUFFER_BINDING", SETTING_BUFFER_BINDING)
-                .define("ENTRY_BUFFER_BINDING", ENTRY_BUFFER_BINDING)
-                .add(ShaderType.COMPUTE, "voxy:util/set.comp")
-                .compile();
-    }
-
-    private static <T> Supplier<T> makeAndCache(Supplier<T> maker) {
-        Object[] value = new Object[1];
-        boolean[] hasSet = new boolean[1];
-        return ()->{
-            if (hasSet[0]) {
-                return (T) value[0];
-            } else {
-                var val = maker.get();
-                hasSet[0] = true;
-                value[0] = val;
-                return val;
-            }
-        };
-    }
-}

src/main/java/me/cortex/voxy/client/core/rendering/util/DeferredUpload.java

@@ -1,25 +0,0 @@
-package me.cortex.voxy.client.core.rendering.util;
-
-import me.cortex.voxy.client.core.gl.GlBuffer;
-import me.cortex.voxy.common.util.UnsafeUtil;
-import org.lwjgl.system.MemoryUtil;
-
-//Just a utility for making a deferred upload (make on other thread then upload on render thread)
-public final class DeferredUpload {
-    public final long ptr;
-    private final long size;
-    private final long offset;
-    private final GlBuffer buffer;
-    public DeferredUpload(GlBuffer buffer, long offset, long size) {
-        this.ptr = MemoryUtil.nmemAlloc(size);
-        this.offset = offset;
-        this.buffer = buffer;
-        this.size = size;
-    }
-
-    public void upload() {
-        long upPtr = UploadStream.INSTANCE.upload(this.buffer, this.offset, this.size);
-        UnsafeUtil.memcpy(this.ptr, upPtr, this.size);
-        MemoryUtil.nmemFree(this.ptr);
-    }
-}

src/main/java/me/cortex/voxy/client/core/rendering/util/DepthFramebuffer.java

@@ -28,12 +28,16 @@ public class DepthFramebuffer {
                 this.depthBuffer.free();
             }
             this.depthBuffer = new GlTexture().store(this.depthType, 1, width, height);
-            this.framebuffer.bind(this.depthType == GL_DEPTH24_STENCIL8?GL_DEPTH_STENCIL_ATTACHMENT: GL_DEPTH_ATTACHMENT, this.depthBuffer).verify();
+            this.framebuffer.bind(this.getDepthAttachmentType(), this.depthBuffer).verify();
             return true;
         }
         return false;
     }
 
+    public int getDepthAttachmentType() {
+        return this.depthType == GL_DEPTH24_STENCIL8?GL_DEPTH_STENCIL_ATTACHMENT: GL_DEPTH_ATTACHMENT;
+    }
+
     public void clear() {
         this.clear(1.0f);
     }
@@ -58,4 +62,8 @@ public class DepthFramebuffer {
     public void bind() {
         glBindFramebuffer(GL_FRAMEBUFFER, this.framebuffer.id);
     }
+
+    public int getFormat() {
+        return this.depthType;
+    }
 }

src/main/java/me/cortex/voxy/client/core/rendering/util/GlStateCapture.java

@@ -1,85 +0,0 @@
-package me.cortex.voxy.client.core.rendering.util;
-
-import it.unimi.dsi.fastutil.ints.IntArrayList;
-
-import static org.lwjgl.opengl.GL11.*;
-import static org.lwjgl.opengl.GL13.GL_ACTIVE_TEXTURE;
-import static org.lwjgl.opengl.GL13.glActiveTexture;
-
-public class GlStateCapture {
-    private final int[] capabilityIds;
-    private final boolean[] enabledCaps;
-
-
-    private final int[] textureUnits;
-    private final int[] textures;
-    private GlStateCapture(int[] caps, int[] textureUnits) {
-        this.capabilityIds = caps;
-        this.enabledCaps = new boolean[caps.length];
-
-        this.textureUnits = textureUnits;
-        this.textures = new int[textureUnits.length];
-    }
-
-    public void capture() {
-        this.textureUnits[0] = glGetInteger(GL_ACTIVE_TEXTURE);
-        //Capture all the texture data
-        for (int i = 0; i < this.textures.length; i++) {
-            glActiveTexture(this.textureUnits[i]);
-            this.textures[i] = glGetInteger(GL_TEXTURE_BINDING_2D);
-        }
-        //Reset the original active texture
-        glActiveTexture(this.textureUnits[0]);
-
-        for (int i = 0; i < this.capabilityIds.length; i++) {
-            this.enabledCaps[i] = glIsEnabled(this.capabilityIds[i]);
-        }
-    }
-
-    public void restore() {
-        //Capture all the texture data
-        for (int i = 1; i < this.textures.length; i++) {
-            glActiveTexture(this.textureUnits[i]);
-            //glBindSampler(this.textureUnits[i]-GL_TEXTURE0, 0);
-            glBindTexture(GL_TEXTURE_2D, this.textures[i]);
-        }
-        //Reset the original active texture
-        glActiveTexture(this.textureUnits[0]);
-        glBindTexture(GL_TEXTURE_2D, this.textures[0]);
-
-        for (int i = 0; i < this.capabilityIds.length; i++) {
-            if (this.enabledCaps[i]) {
-                glEnable(this.capabilityIds[i]);
-            } else {
-                glDisable(this.capabilityIds[i]);
-            }
-        }
-    }
-
-    public static Builder make() {
-        return new Builder();
-    }
-
-    public static class Builder {
-        private final IntArrayList caps = new IntArrayList();
-        private final IntArrayList textures = new IntArrayList();
-
-        private Builder() {
-            this.addTexture(-1);//Special texture unit, used to capture the current texture unit
-        }
-
-        public Builder addCapability(int cap) {
-            this.caps.add(cap);
-            return this;
-        }
-
-        public Builder addTexture(int unit) {
-            this.textures.add(unit);
-            return this;
-        }
-
-        public GlStateCapture build() {
-            return new GlStateCapture(this.caps.toIntArray(), this.textures.toIntArray());
-        }
-    }
-}

src/main/java/me/cortex/voxy/client/core/rendering/util/LightMapHelper.java

@@ -1,13 +1,13 @@
 package me.cortex.voxy.client.core.rendering.util;
 
-import net.minecraft.client.MinecraftClient;
-
 import static org.lwjgl.opengl.GL33.glBindSampler;
 import static org.lwjgl.opengl.GL45.glBindTextureUnit;
 
+import net.minecraft.client.Minecraft;
+
 public class LightMapHelper {
     public static void bind(int lightingIndex) {
         glBindSampler(lightingIndex, 0);
-        glBindTextureUnit(lightingIndex, ((net.minecraft.client.texture.GlTexture)(MinecraftClient.getInstance().gameRenderer.getLightmapTextureManager().getGlTextureView().texture())).getGlId());
+        glBindTextureUnit(lightingIndex, ((com.mojang.blaze3d.opengl.GlTexture)(Minecraft.getInstance().gameRenderer.lightTexture().getTextureView().texture())).glId());
     }
 }

src/main/java/me/cortex/voxy/client/core/rendering/util/RawDownloadStream.java

@@ -80,6 +80,17 @@ public class RawDownloadStream {
     }
 
     public void free() {
+        glFinish();
+        this.tick();
+        GlFence fence = new GlFence();
+        while (!fence.signaled()) {
+            glFinish();
+        }
+        fence.free();
+        this.tick();
+        if (this.frames.size() != 0) {
+            throw new IllegalStateException();
+        }
         this.frames.forEach(a->a.fence.free());
         this.downloadBuffer.free();
     }

src/main/java/me/cortex/voxy/client/core/rendering/util/UploadStream.java

@@ -17,6 +17,7 @@ import static org.lwjgl.opengl.ARBMapBufferRange.*;
 import static org.lwjgl.opengl.GL11.glFinish;
 import static org.lwjgl.opengl.GL42.glMemoryBarrier;
 import static org.lwjgl.opengl.GL42C.GL_BUFFER_UPDATE_BARRIER_BIT;
+import static org.lwjgl.opengl.GL44.GL_CLIENT_STORAGE_BIT;
 import static org.lwjgl.opengl.GL44.GL_MAP_COHERENT_BIT;
 import static org.lwjgl.opengl.GL45C.glFlushMappedNamedBufferRange;
 
@@ -31,7 +32,7 @@ public class UploadStream {
     private static final boolean USE_COHERENT = false;
 
     public UploadStream(long size) {
-        this.uploadBuffer = new GlPersistentMappedBuffer(size,GL_MAP_WRITE_BIT|GL_MAP_UNSYNCHRONIZED_BIT|(USE_COHERENT?GL_MAP_COHERENT_BIT:GL_MAP_FLUSH_EXPLICIT_BIT)).name("UploadStream");
+        this.uploadBuffer = new GlPersistentMappedBuffer(size,GL_CLIENT_STORAGE_BIT|GL_MAP_WRITE_BIT|GL_MAP_UNSYNCHRONIZED_BIT|(USE_COHERENT?GL_MAP_COHERENT_BIT:GL_MAP_FLUSH_EXPLICIT_BIT)).name("UploadStream");
         this.allocationArena.setLimit(size);
     }
 

src/main/java/me/cortex/voxy/client/core/util/GPUTiming.java

@@ -30,17 +30,37 @@ public class GPUTiming {
 
     private final GlTimestampQuerySet timingSet = new GlTimestampQuerySet();
 
+    private float[] timings = new float[0];
+
     public void marker() {
         this.timingSet.capture(0);
     }
 
+    public String getDebug() {
+        StringBuilder str = new StringBuilder("GpuTime: [");
+        for (int i = 0; i < this.timings.length; i++) {
+            str.append(String.format("%.2f", this.timings[i]));
+            if (i!=this.timings.length-1) {
+                str.append(',');
+            }
+        }
+        str.append(']');
+        return str.toString();
+    }
+
     public void tick() {
         this.timingSet.download((meta,data)->{
             long current = data[0];
+
+            if (data.length-1!=this.timings.length) {
+                this.timings = new float[data.length-1];
+            }
+
             for (int i = 1; i < meta.length; i++) {
                 long next = data[i];
                 long delta = next - current;
-                //System.out.println(delta);
+                float time = (float) (((double)delta)/1_000_000);
+                this.timings[i-1] = Math.max(this.timings[i-1]*0.99f+time*0.01f, time);
                 current = next;
             }
         });

src/main/java/me/cortex/voxy/client/core/util/IrisUtil.java

@@ -10,7 +10,10 @@ import net.irisshaders.iris.api.v0.IrisApi;
 import net.irisshaders.iris.gl.IrisRenderSystem;
 import net.irisshaders.iris.shadows.ShadowRenderer;
 
+import java.io.IOException;
+
 public class IrisUtil {
+
     public record CapturedViewportParameters(ChunkRenderMatrices matrices, FogParameters parameters, double x, double y, double z) {
         public Viewport<?> apply(VoxyRenderSystem vrs) {
             return vrs.setupViewport(this.matrices, this.parameters, this.x, this.y, this.z);
@@ -34,6 +37,19 @@ public class IrisUtil {
     public static void clearIrisSamplers() {
         if (IRIS_INSTALLED) clearIrisSamplers0();
     }
+    public static void reload() {
+        if (IRIS_INSTALLED) reload0();
+    }
+
+    private static void reload0() {
+        try {
+            if (IrisApi.getInstance().isShaderPackInUse()) {//Only reload if there is a shaderpack
+                Iris.reload();
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
 
     private static void clearIrisSamplers0() {
         for (int i = 0; i < 16; i++) {

src/main/java/me/cortex/voxy/client/iris/IrisShaderPatch.java

@@ -26,7 +26,6 @@ public class IrisShaderPatch {
     public static final boolean IMPERSONATE_DISTANT_HORIZONS = System.getProperty("voxy.impersonateDHShader", "false").equalsIgnoreCase("true");
 
 
-
     private static final class SSBODeserializer implements JsonDeserializer<Int2ObjectOpenHashMap<String>> {
         @Override
         public Int2ObjectOpenHashMap<String> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
@@ -140,6 +139,7 @@ public class IrisShaderPatch {
                                 }
                             }
                         } else {
+                            Logger.error("Unknown blend state "+val);
                             state = null;
                         }
                         if (bs != null) {
@@ -175,16 +175,34 @@ public class IrisShaderPatch {
         public boolean excludeLodsFromVanillaDepth;
         public float[] renderScale;
         public boolean useViewportDims;
-        public boolean checkValid() {
+        //public boolean deferTranslucentRendering;
+        public String checkValid() {
             if (this.blending != null) {
+                int i = 0;
                 for (BlendState state : this.blending.values()) {
                     if (state.buffer != -1 && (state.buffer<0||this.translucentDrawBuffers.length<=state.buffer)) {
-                        return false;
+                        if (state.buffer<0) {
+                            return "Blending buffer is <0 at index: " + i;
+                        } else {
+                            return "Blending buffer index out of bounds at "+i+" was "+state.buffer+" maximum is " +(this.translucentDrawBuffers.length-1);
+                        }
                     }
+                    i++;
                 }
             }
-
+            if (this.opaquePatchData == null) {
-            return this.opaqueDrawBuffers != null && this.translucentDrawBuffers != null && this.uniforms != null && this.opaquePatchData != null;
+                return "Opaque patch data is null";
+            }
+            if (this.uniforms == null) {
+                return "Uniforms are null";
+            }
+            if (this.opaqueDrawBuffers == null) {
+                return "Opaque draw buffers are null";
+            }
+            if (this.translucentDrawBuffers == null) {
+                return "Translucent draw buffers are null";
+            }
+            return null;
         }
     }
 
@@ -250,6 +268,10 @@ public class IrisShaderPatch {
         return new float[]{Math.max(0.01f,this.patchData.renderScale[0]),Math.max(0.01f,this.patchData.renderScale[1])};
     }
 
+    public boolean deferedTranslucentRendering() {
+        return false;//this.patchData.deferTranslucentRendering;
+    }
+
     public Runnable createBlendSetup() {
         if (this.patchData.blending == null || this.patchData.blending.isEmpty()) {
             return ()->{};//No blending change
@@ -319,27 +341,31 @@ public class IrisShaderPatch {
             }
             patchData = GSON.fromJson(voxyPatchData, PatchGson.class);
             if (patchData == null) {
-                throw new IllegalStateException("Voxy patch json returned null");
+                throw new IllegalStateException("Voxy patch json returned null, this is most likely due to malformed json file");
             }
 
             {//Inject data from the auxilery files if they are present
                 var opaque = sourceProvider.apply(directory.resolve("voxy_opaque.glsl"));
                 if (opaque != null) {
+                    Logger.info("External opaque shader patch applied");
                     patchData.opaquePatchData = opaque;
                 }
                 var translucent = sourceProvider.apply(directory.resolve("voxy_translucent.glsl"));
                 if (translucent != null) {
+                    Logger.info("External translucent shader patch applied");
                     patchData.translucentPatchData = translucent;
                 }
                 //This might be ok? not.. sure if is nice or not
                 var taa = sourceProvider.apply(directory.resolve("voxy_taa.glsl"));
                 if (taa != null) {
+                    Logger.info("External taa shader patch applied");
                     patchData.taaOffset = taa;
                 }
             }
 
-            if (!patchData.checkValid()) {
+            var invalidPatchDataReason = patchData.checkValid();
-                throw new IllegalStateException("voxy json patch not valid: " + voxyPatchData);
+            if (invalidPatchDataReason!=null) {
+                throw new IllegalStateException("voxy json patch not valid: " + invalidPatchDataReason);
             }
         } catch (Exception e) {
             patchData = null;

src/main/java/me/cortex/voxy/client/iris/IrisVoxyRenderPipelineData.java

@@ -3,6 +3,7 @@ package me.cortex.voxy.client.iris;
 import com.google.common.collect.ImmutableSet;
 import it.unimi.dsi.fastutil.ints.Int2ObjectLinkedOpenHashMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.longs.Long2ObjectFunction;
 import kroppeb.stareval.function.FunctionReturn;
 import kroppeb.stareval.function.Type;
 import me.cortex.voxy.client.core.IrisVoxyRenderPipeline;
@@ -13,6 +14,7 @@ import net.irisshaders.iris.gl.buffer.ShaderStorageBufferHolder;
 import net.irisshaders.iris.gl.image.ImageHolder;
 import net.irisshaders.iris.gl.sampler.GlSampler;
 import net.irisshaders.iris.gl.sampler.SamplerHolder;
+import net.irisshaders.iris.gl.state.FogMode;
 import net.irisshaders.iris.gl.state.ValueUpdateNotifier;
 import net.irisshaders.iris.gl.texture.InternalTextureFormat;
 import net.irisshaders.iris.gl.texture.TextureType;
@@ -20,15 +22,14 @@ import net.irisshaders.iris.gl.uniform.*;
 import net.irisshaders.iris.pipeline.IrisRenderingPipeline;
 import net.irisshaders.iris.targets.RenderTarget;
 import net.irisshaders.iris.targets.RenderTargets;
+import net.irisshaders.iris.uniforms.CommonUniforms;
 import net.irisshaders.iris.uniforms.custom.CustomUniforms;
 import net.irisshaders.iris.uniforms.custom.cached.*;
 import org.joml.*;
 import org.lwjgl.system.MemoryUtil;
 
 import java.util.*;
-import java.util.function.IntConsumer;
+import java.util.function.*;
-import java.util.function.IntSupplier;
-import java.util.function.LongConsumer;
 import java.util.stream.Collectors;
 
 import static org.lwjgl.opengl.ARBDirectStateAccess.glBindTextureUnit;
@@ -50,6 +51,7 @@ public class IrisVoxyRenderPipelineData {
     public final float[] resolutionScale;
     public final String TAA;
     public final boolean useViewportDims;
+    public final boolean deferTranslucency;
 
     private IrisVoxyRenderPipelineData(IrisShaderPatch patch, int[] opaqueDrawTargets, int[] translucentDrawTargets, StructLayout uniformSet, Runnable blendingSetup, ImageSet imageSet, SSBOSet ssboSet) {
         this.opaqueDrawTargets = opaqueDrawTargets;
@@ -64,6 +66,7 @@ public class IrisVoxyRenderPipelineData {
         this.TAA = patch.getTAAShift();
         this.resolutionScale = patch.getRenderScale();
         this.useViewportDims = patch.useViewportDims();
+        this.deferTranslucency = patch.deferedTranslucentRendering();
     }
 
     public SSBOSet getSsboSet() {
@@ -91,6 +94,7 @@ public class IrisVoxyRenderPipelineData {
     public static IrisVoxyRenderPipelineData buildPipeline(IrisRenderingPipeline ipipe, IrisShaderPatch patch, CustomUniforms cu, ShaderStorageBufferHolder ssboHolder) {
         var uniforms = createUniformLayoutStructAndUpdater(createUniformSet(cu, patch));
 
+
         var imageSet = createImageSet(ipipe, patch);
 
         var ssboSet = createSSBOLayouts(patch.getSSBOs(), ssboHolder);
@@ -114,40 +118,60 @@ public class IrisVoxyRenderPipelineData {
         return targetTextures;
     }
 
+
+    private static String convertToGlslType(UniformType type) {
+        return switch (type) {
+            case INT -> "int";
+            case FLOAT -> "float";
+            case MAT3 -> "mat3";
+            case MAT4 -> "mat4";
+            case VEC2 -> "vec2";
+            case VEC2I -> "ivec2";
+            case VEC3 -> "vec3";
+            case VEC3I -> "ivec3";
+            case VEC4 -> "vec4";
+            case VEC4I -> "ivec4";
+        };
+    }
+
+    public boolean shouldDeferTranslucency() {
+        return false;
+    }
+
     public record StructLayout(int size, String layout, LongConsumer updater) {}
-    private static StructLayout createUniformLayoutStructAndUpdater(CachedUniform[] uniforms) {
+    private static StructLayout createUniformLayoutStructAndUpdater(List<UniformWritingHolder> uniforms) {
-        if (uniforms.length == 0) {
+        if (uniforms.size() == 0) {
             return null;
         }
 
-        List<CachedUniform>[] ordering = new List[]{new ArrayList<>(), new ArrayList<>(), new ArrayList<>(), new ArrayList<>()};
+        List<UniformWritingHolder>[] ordering = new List[]{new ArrayList<>(), new ArrayList<>(), new ArrayList<>(), new ArrayList<>()};
 
         //Creates an optimial struct layout for the uniforms
         for (var uniform : uniforms) {
-            int order = getUniformOrdering(Type.convert(uniform.getType()));
+            int order = getUniformOrdering(uniform.type);
             ordering[order].add(uniform);
         }
 
         //Emit the ordering, note this is not optimial, but good enough, e.g. if have even number of align 2, emit that after align 4
         int pos = 0;
-        Int2ObjectLinkedOpenHashMap<CachedUniform> layout = new Int2ObjectLinkedOpenHashMap<>();
+        Int2ObjectLinkedOpenHashMap<UniformWritingHolder> layout = new Int2ObjectLinkedOpenHashMap<>();
         for (var uniform : ordering[0]) {//Emit exact align 4
-            layout.put(pos, uniform); pos += getSizeAndAlignment(Type.convert(uniform.getType()))>>5;
+            layout.put(pos, uniform); pos += getSizeAndAlignment(uniform.type)>>5;
         }
         if (!ordering[1].isEmpty() && (ordering[1].size()&1)==0) {
             //Emit all the align 2 as there is an even number of them
             for (var uniform : ordering[1]) {
-                layout.put(pos, uniform); pos += getSizeAndAlignment(Type.convert(uniform.getType()))>>5;
+                layout.put(pos, uniform); pos += getSizeAndAlignment(uniform.type)>>5;
             }
             ordering[1].clear();
         }
         //Emit align 3
         for (var uniform : ordering[2]) {//Emit size odd, alignment must be 4
-            layout.put(pos, uniform); pos += getSizeAndAlignment(Type.convert(uniform.getType()))>>5;
+            layout.put(pos, uniform); pos += getSizeAndAlignment(uniform.type)>>5;
             //We must get a size 1 to pad to align 4
             if (!ordering[3].isEmpty()) {//Size 1
                 uniform = ordering[3].removeFirst();
-                layout.put(pos, uniform); pos += getSizeAndAlignment(Type.convert(uniform.getType()))>>5;
+                layout.put(pos, uniform); pos += getSizeAndAlignment(uniform.type)>>5;
             } else {//Padding must be injected
                 pos += 1;
             }
@@ -155,15 +179,15 @@ public class IrisVoxyRenderPipelineData {
 
         //Emit align 2
         for (var uniform : ordering[1]) {
-            layout.put(pos, uniform); pos += getSizeAndAlignment(Type.convert(uniform.getType()))>>5;
+            layout.put(pos, uniform); pos += getSizeAndAlignment(uniform.type)>>5;
         }
 
         //Emit align 1
         for (var uniform : ordering[3]) {
-            layout.put(pos, uniform); pos += getSizeAndAlignment(Type.convert(uniform.getType()))>>5;
+            layout.put(pos, uniform); pos += getSizeAndAlignment(uniform.type)>>5;
         }
 
-        if (layout.size()!=uniforms.length) {
+        if (layout.size()!=uniforms.size()) {
             throw new IllegalStateException();
         }
 
@@ -173,7 +197,7 @@ public class IrisVoxyRenderPipelineData {
         {
             StringBuilder struct = new StringBuilder("{\n");
             for (var pair : layout.int2ObjectEntrySet()) {
-                struct.append("\t").append(pair.getValue().getType().toString()).append(" ").append(pair.getValue().getName()).append(";\n");
+                struct.append("\t").append(convertToGlslType(pair.getValue().type)).append(" ").append(pair.getValue().name).append(";\n");
             }
             struct.append("}");
             structLayout = struct.toString();
@@ -181,11 +205,10 @@ public class IrisVoxyRenderPipelineData {
 
         LongConsumer updater;
         {
-            FunctionReturn cacheRetObj = new FunctionReturn();
+            LongConsumer[] updaters = new LongConsumer[uniforms.size()];
-            LongConsumer[] updaters = new LongConsumer[uniforms.length];
             int i = 0;
             for (var pair : layout.int2ObjectEntrySet()) {
-                updaters[i++] = createWriter(pair.getIntKey()*4L, cacheRetObj, pair.getValue());
+                updaters[i++] = pair.getValue().writingFactory.get(pair.getIntKey()*4L);
             }
 
             updater = ptr -> {
@@ -271,9 +294,81 @@ public class IrisVoxyRenderPipelineData {
         };
     }
 
-    private static CachedUniform[] createUniformSet(CustomUniforms cu, IrisShaderPatch patch) {
+    private record UniformWritingHolder(String name, UniformType type, Long2ObjectFunction<LongConsumer> writingFactory) {
+
+    }
+    private static List<UniformWritingHolder> createUniformSet(CustomUniforms cu, IrisShaderPatch patch) {
         //This is a fking awful hack... but it works thinks
-        LocationalUniformHolder uniformBuilder = new LocationalUniformHolder() {
+
+        List<UniformWritingHolder> uniforms = new ArrayList<>();
+        Set<String> seenUniforms = new HashSet<>();
+        DynamicLocationalUniformHolder uniformBuilder = new DynamicLocationalUniformHolder() {
+            @Override
+            public DynamicLocationalUniformHolder uniform1i(UniformUpdateFrequency updateFrequency, String name, IntSupplier value) {
+                return this.uniform1i(name, value, null);
+            }
+
+            @Override
+            public DynamicLocationalUniformHolder uniform1i(String name, IntSupplier value, ValueUpdateNotifier notifier) {
+                this.injectDynamicUniformType(name, UniformType.INT, offset->{
+                    return ptr->{
+                        MemoryUtil.memPutInt(ptr+offset, value.getAsInt());
+                    };
+                });
+                return this;
+            }
+
+
+            @Override
+            public DynamicLocationalUniformHolder uniform1f(UniformUpdateFrequency updateFrequency, String name, FloatSupplier value) {
+                return this.uniform1f(name, value, null);
+            }
+
+            @Override
+            public DynamicLocationalUniformHolder uniform1f(String name, FloatSupplier value, ValueUpdateNotifier notifier) {
+                this.injectDynamicUniformType(name, UniformType.FLOAT, offset->{
+                    return ptr->{
+                        MemoryUtil.memPutFloat(ptr+offset, value.getAsFloat());
+                    };
+                });
+                return this;
+            }
+
+
+            @Override
+            public DynamicLocationalUniformHolder uniform3f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector3f> value) {
+                return this.uniform3f(name, value, null);
+            }
+
+            @Override
+            public DynamicLocationalUniformHolder uniform3f(String name, Supplier<Vector3f> value, ValueUpdateNotifier notifier) {
+                this.injectDynamicUniformType(name, UniformType.VEC3, offset->{
+                    return ptr->{
+                      value.get().getToAddress(ptr+offset);
+                    };
+                });
+                return this;
+            }
+
+            private void injectDynamicUniformType(String name, UniformType type, Long2ObjectFunction<LongConsumer> supplier) {
+                var names = patch.getUniformList();
+                for (int i = 0; i < names.length; i++) {
+                    if (names[i].equals(name)) {
+                        if (!seenUniforms.add(name)) {
+                            throw new IllegalArgumentException("Already added uniform: " + name);
+                        }
+                        uniforms.add(new UniformWritingHolder(name, type, supplier));
+                        break;
+                    }
+                }
+            }
+
+            @Override
+            public DynamicLocationalUniformHolder addDynamicUniform(Uniform uniform, ValueUpdateNotifier valueUpdateNotifier) {
+                throw new IllegalStateException("Type not implemented for uniform: " + uniform);
+                //return this;
+            }
+
             @Override
             public LocationalUniformHolder addUniform(UniformUpdateFrequency uniformUpdateFrequency, Uniform uniform) {
                 return this;
@@ -296,31 +391,36 @@ public class IrisVoxyRenderPipelineData {
                 return null;
             }
         };
+        CommonUniforms.addDynamicUniforms(uniformBuilder, FogMode.PER_FRAGMENT);
         cu.assignTo(uniformBuilder);
         cu.mapholderToPass(uniformBuilder, patch);
 
-        CachedUniform[] uniforms = new CachedUniform[patch.getUniformList().length];
+        FunctionReturn cachedReturn = new FunctionReturn();
-        ((CustomUniformsAccessor)cu).getLocationMap().get(patch).object2IntEntrySet().forEach(entry->uniforms[entry.getIntValue()] = entry.getKey());
+        ((CustomUniformsAccessor)cu).getLocationMap().get(patch).object2IntEntrySet().forEach(entry-> {
-        int i = 0;
+            if (!seenUniforms.add(entry.getKey().getName())) {
-        int j = 0;
+                throw new IllegalArgumentException("Already added uniform: " + entry.getKey().getName());
-        for (var uniform : uniforms) {
-            if (uniform == null) {
-                Logger.error("Unknown uniform at location "+j + " skipping");
-            } else {
-                uniforms[i++] = uniform;//This shuffles the uniforms down till its compacted
             }
-            j++;
+            uniforms.add(new UniformWritingHolder(entry.getKey().getName(), Type.convert(entry.getKey().getType()),offset->createWriter(offset, cachedReturn, entry.getKey())));
+        });
+
+        if (uniforms.size() != patch.getUniformList().length) {
+            Set<String> uniformsUnseen = new HashSet<>(List.of(patch.getUniformList()));
+            for (var uniform : uniforms) {
+                uniformsUnseen.remove(uniform.name);
+            }
+            Logger.error("The following uniforms could not be found: [" + uniformsUnseen.stream().sorted(String::compareToIgnoreCase).collect(Collectors.joining(","))+"]");
         }
         //In _theory_ this should work?
-        return Arrays.copyOf(uniforms, i);
+        return uniforms;
     }
 
-    private record TextureWSampler(String name, IntSupplier texture, int sampler) { }
+    private record TextureWSampler(String name, IntSupplier texture, IntSupplier sampler) { }
     public record ImageSet(String layout, IntConsumer bindingFunction) {
 
     }
     private static ImageSet createImageSet(IrisRenderingPipeline ipipe, IrisShaderPatch patch) {
         var samplerDataSet = patch.getSamplerSet();
+        if (samplerDataSet == null) return null;
         Set<String> samplerNameSet = new LinkedHashSet<>(samplerDataSet.keySet());
         if (samplerNameSet.isEmpty()) return null;
         Set<TextureWSampler> samplerSet = new LinkedHashSet<>();
@@ -345,27 +445,30 @@ public class IrisVoxyRenderPipelineData {
             }
 
             @Override
-            public boolean addDefaultSampler(TextureType type, IntSupplier texture, ValueUpdateNotifier notifier, GlSampler sampler, String... names) {
+            public boolean addDefaultSampler(TextureType type, IntSupplier texture, ValueUpdateNotifier notifier, Supplier<GlSampler> sampler, String... names) {
                 Logger.error("Unsupported default sampler");
                 return false;
             }
 
             @Override
-            public boolean addDynamicSampler(TextureType type, IntSupplier texture, GlSampler sampler, String... names) {
+            public boolean addDynamicSampler(TextureType type, IntSupplier texture, Supplier<GlSampler> sampler, String... names) {
                 return this.addDynamicSampler(type, texture, null, sampler, names);
             }
 
             @Override
-            public boolean addDynamicSampler(TextureType type, IntSupplier texture, ValueUpdateNotifier notifier, GlSampler sampler, String... names) {
+            public boolean addDynamicSampler(TextureType type, IntSupplier texture, ValueUpdateNotifier notifier, Supplier<GlSampler> sampler, String... names) {
                 if (!this.hasSampler(names)) return false;
-                samplerSet.add(new TextureWSampler(this.name(names), texture, sampler!=null?sampler.getId():-1));
+                samplerSet.add(new TextureWSampler(this.name(names), texture, sampler!=null?()->{
+                    var s = sampler.get();
+                    return s!=null?s.getId():-1;
+                }:()->-1));
                 return true;
             }
 
             @Override
             public void addExternalSampler(int texture, String... names) {
                 if (!this.hasSampler(names)) return;
-                samplerSet.add(new TextureWSampler(this.name(names), ()->texture, -1));
+                samplerSet.add(new TextureWSampler(this.name(names), ()->texture, ()->-1));
             }
         };
 
@@ -386,7 +489,7 @@ public class IrisVoxyRenderPipelineData {
 
         //samplerSet contains our samplers
         if (samplerSet.size() != samplerNameSet.size()) {
-            Logger.error("Did not find all requested samplers. Found [" + samplerSet.stream().map(a->a.name).collect(Collectors.joining()) + "] expected " + samplerNameSet);
+            Logger.error("Did not find all requested samplers. Found [" + samplerSet.stream().map(a->a.name).collect(Collectors.joining(", ")) + "] expected " + samplerNameSet);
         }
 
         //TODO: generate a layout (defines) for all the samplers with the correct types
@@ -408,8 +511,9 @@ public class IrisVoxyRenderPipelineData {
                 int unit = j+base;
                 var ts = samplers[j];
                 glBindTextureUnit(unit, ts.texture.getAsInt());
-                if (ts.sampler != -1) {
+                int sampler = ts.sampler.getAsInt();
-                    glBindSampler(unit, ts.sampler);
+                if (sampler != -1) {
+                    glBindSampler(unit, sampler);
                 }//TODO: might need to bind sampler 0
             }
         };

src/main/java/me/cortex/voxy/client/iris/VoxySamplers.java

@@ -1,5 +1,6 @@
 package me.cortex.voxy.client.iris;
 
+import net.irisshaders.iris.gl.sampler.GlSampler;
 import net.irisshaders.iris.gl.sampler.SamplerHolder;
 import net.irisshaders.iris.gl.texture.TextureType;
 import net.irisshaders.iris.pipeline.IrisRenderingPipeline;
@@ -32,7 +33,7 @@ public class VoxySamplers {
                     return 0;
                 }
                 return dt.id;
-            }, null, opaqueNames);
+            }, ()->GlSampler.MIPPED_NEAREST_NEAREST, opaqueNames);
 
             samplers.addDynamicSampler(TextureType.TEXTURE_2D, () -> {
                 var pipeData = ((IGetIrisVoxyPipelineData)pipeline).voxy$getPipelineData();
@@ -48,7 +49,7 @@ public class VoxySamplers {
                     return 0;
                 }
                 return dt.id;
-            }, null, translucentNames);
+            }, ()->GlSampler.MIPPED_NEAREST_NEAREST, translucentNames);
         }
     }
 }

src/main/java/me/cortex/voxy/client/iris/VoxyUniforms.java

@@ -1,9 +1,9 @@
 package me.cortex.voxy.client.iris;
 
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
 import net.irisshaders.iris.gl.uniform.UniformHolder;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
 import org.joml.Matrix4f;
 import org.joml.Matrix4fc;
 
@@ -14,7 +14,7 @@ import static net.irisshaders.iris.gl.uniform.UniformUpdateFrequency.PER_FRAME;
 public class VoxyUniforms {
 
     public static Matrix4f getViewProjection() {//This is 1 frame late ;-; cries, since the update occurs _before_ the voxy render pipeline
-        var getVrs = (IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer;
+        var getVrs = (IGetVoxyRenderSystem) Minecraft.getInstance().levelRenderer;
         if (getVrs == null || getVrs.getVoxyRenderSystem() == null) {
             return new Matrix4f();
         }
@@ -23,7 +23,7 @@ public class VoxyUniforms {
     }
 
     public static Matrix4f getModelView() {//This is 1 frame late ;-; cries, since the update occurs _before_ the voxy render pipeline
-        var getVrs = (IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer;
+        var getVrs = (IGetVoxyRenderSystem) Minecraft.getInstance().levelRenderer;
         if (getVrs == null || getVrs.getVoxyRenderSystem() == null) {
             return new Matrix4f();
         }
@@ -32,7 +32,7 @@ public class VoxyUniforms {
     }
 
     public static Matrix4f getProjection() {//This is 1 frame late ;-; cries, since the update occurs _before_ the voxy render pipeline
-        var getVrs = (IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer;
+        var getVrs = (IGetVoxyRenderSystem) Minecraft.getInstance().levelRenderer;
         if (getVrs == null || getVrs.getVoxyRenderSystem() == null) {
             return new Matrix4f();
         }

src/main/java/me/cortex/voxy/client/mixin/flashback/MixinFlashbackRecorder.java

@@ -5,7 +5,7 @@ import com.moulberry.flashback.record.Recorder;
 import me.cortex.voxy.client.VoxyClientInstance;
 import me.cortex.voxy.client.compat.IFlashbackMeta;
 import me.cortex.voxy.commonImpl.VoxyCommon;
-import net.minecraft.registry.DynamicRegistryManager;
+import net.minecraft.core.RegistryAccess;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -18,7 +18,7 @@ public class MixinFlashbackRecorder {
     @Shadow @Final private FlashbackMeta metadata;
 
     @Inject(method = "<init>", at = @At("TAIL"))
-    private void voxy$getStoragePath(DynamicRegistryManager registryAccess, CallbackInfo retInf) {
+    private void voxy$getStoragePath(RegistryAccess registryAccess, CallbackInfo retInf) {
         if (VoxyCommon.isAvailable()) {
             var instance = VoxyCommon.getInstance();
             if (instance instanceof VoxyClientInstance ci) {

src/main/java/me/cortex/voxy/client/mixin/iris/MixinIris.java

@@ -6,7 +6,6 @@ import net.irisshaders.iris.Iris;
 import net.irisshaders.iris.shaderpack.ShaderPack;
 import net.irisshaders.iris.shaderpack.materialmap.NamespacedId;
 import net.irisshaders.iris.shaderpack.programs.ProgramSet;
-import net.minecraft.util.Identifier;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;

src/main/java/me/cortex/voxy/client/mixin/iris/MixinIrisRenderingPipeline.java

@@ -10,7 +10,7 @@ import net.irisshaders.iris.gl.buffer.ShaderStorageBufferHolder;
 import net.irisshaders.iris.pipeline.IrisRenderingPipeline;
 import net.irisshaders.iris.shaderpack.programs.ProgramSet;
 import net.irisshaders.iris.uniforms.custom.CustomUniforms;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -41,10 +41,10 @@ public class MixinIrisRenderingPipeline implements IGetVoxyPatchData, IGetIrisVo
         }
     }
 
-    @Inject(method = "beginLevelRendering", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/opengl/GlStateManager;_activeTexture(I)V", shift = At.Shift.BEFORE), remap = true)
+    @Inject(method = "beginLevelRendering", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/opengl/GlStateManager;_activeTexture(I)V", shift = At.Shift.BEFORE), remap = false)
     private void voxy$injectViewportSetup(CallbackInfo ci) {
         if (IrisUtil.CAPTURED_VIEWPORT_PARAMETERS != null) {
-            var renderer = ((IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer).getVoxyRenderSystem();
+            var renderer = ((IGetVoxyRenderSystem) Minecraft.getInstance().levelRenderer).getVoxyRenderSystem();
             if (renderer != null) {
                 IrisUtil.CAPTURED_VIEWPORT_PARAMETERS.apply(renderer);
             }

src/main/java/me/cortex/voxy/client/mixin/iris/MixinLevelRenderer.java

@@ -1,16 +1,15 @@
 package me.cortex.voxy.client.mixin.iris;
 
 import com.mojang.blaze3d.buffers.GpuBufferSlice;
+import com.mojang.blaze3d.resource.GraphicsResourceAllocator;
 import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
-import me.cortex.voxy.client.core.VoxyRenderSystem;
 import me.cortex.voxy.client.core.util.IrisUtil;
 import net.caffeinemc.mods.sodium.client.render.chunk.ChunkRenderMatrices;
 import net.caffeinemc.mods.sodium.client.util.FogStorage;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Camera;
-import net.minecraft.client.render.Camera;
+import net.minecraft.client.DeltaTracker;
-import net.minecraft.client.render.RenderTickCounter;
+import net.minecraft.client.Minecraft;
-import net.minecraft.client.render.WorldRenderer;
+import net.minecraft.client.renderer.LevelRenderer;
-import net.minecraft.client.util.ObjectAllocator;
 import org.joml.Matrix4f;
 import org.joml.Vector4f;
 import org.spongepowered.asm.mixin.Final;
@@ -22,30 +21,31 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 import static org.lwjgl.opengl.GL11C.glViewport;
 
-@Mixin(WorldRenderer.class)
+@Mixin(LevelRenderer.class)
-public class MixinWorldRenderer {
+public class MixinLevelRenderer {
-    @Shadow @Final private MinecraftClient client;
+    @Shadow @Final private Minecraft minecraft;
 
-    @Inject(method = "render", at = @At("HEAD"), order = 100)
+    @Inject(method = "renderLevel", at = @At("HEAD"), order = 100)
     private void voxy$injectIrisCompat(
-            ObjectAllocator allocator,
+            GraphicsResourceAllocator allocator,
-            RenderTickCounter tickCounter,
+            DeltaTracker tickCounter,
             boolean renderBlockOutline,
             Camera camera,
             Matrix4f positionMatrix,
             Matrix4f projectionMatrix,
-            GpuBufferSlice fog,
+            Matrix4f basicProjectionMatrix,
+            GpuBufferSlice fogBuffer,
             Vector4f fogColor,
-            boolean shouldRenderSky,
+            boolean renderSky,
             CallbackInfo ci) {
         if (IrisUtil.irisShaderPackEnabled()) {
             var renderer = ((IGetVoxyRenderSystem) this).getVoxyRenderSystem();
             if (renderer != null) {
                 //Fixthe fucking viewport dims, fuck iris
-                glViewport(0,0,MinecraftClient.getInstance().getFramebuffer().textureWidth, MinecraftClient.getInstance().getFramebuffer().textureHeight);
+                glViewport(0,0,Minecraft.getInstance().getMainRenderTarget().width, Minecraft.getInstance().getMainRenderTarget().height);
 
-                var pos = camera.getCameraPos();
+                var pos = camera.position();
-                IrisUtil.CAPTURED_VIEWPORT_PARAMETERS = new IrisUtil.CapturedViewportParameters(new ChunkRenderMatrices(projectionMatrix, positionMatrix), ((FogStorage) this.client.gameRenderer).sodium$getFogParameters(), pos.x, pos.y, pos.z);
+                IrisUtil.CAPTURED_VIEWPORT_PARAMETERS = new IrisUtil.CapturedViewportParameters(new ChunkRenderMatrices(projectionMatrix, positionMatrix), ((FogStorage) this.minecraft.gameRenderer).sodium$getFogParameters(), pos.x, pos.y, pos.z);
             }
         }
     }

src/main/java/me/cortex/voxy/client/mixin/iris/MixinMatrixUniforms.java

@@ -1,6 +1,6 @@
 package me.cortex.voxy.client.mixin.iris;
 
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.util.IrisUtil;
 import me.cortex.voxy.client.iris.VoxyUniforms;
 import net.irisshaders.iris.gl.uniform.UniformHolder;

src/main/java/me/cortex/voxy/client/mixin/iris/MixinProgramSet.java

@@ -1,6 +1,6 @@
 package me.cortex.voxy.client.mixin.iris;
 
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.util.IrisUtil;
 import me.cortex.voxy.client.iris.IGetVoxyPatchData;
 import me.cortex.voxy.client.iris.IrisShaderPatch;

src/main/java/me/cortex/voxy/client/mixin/iris/MixinStandardMacros.java

@@ -3,7 +3,7 @@ package me.cortex.voxy.client.mixin.iris;
 import com.google.common.collect.ImmutableList;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.util.IrisUtil;
 import me.cortex.voxy.client.iris.IrisShaderPatch;
 import net.irisshaders.iris.gl.shader.StandardMacros;

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinBlockableEventLoop.java

@@ -1,17 +1,18 @@
 package me.cortex.voxy.client.mixin.minecraft;
 
 import me.cortex.voxy.client.LoadException;
-import net.minecraft.util.thread.ThreadExecutor;
+import net.minecraft.util.thread.BlockableEventLoop;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;
 
-@Mixin(ThreadExecutor.class)
+@Mixin(BlockableEventLoop.class)
-public abstract class MixinThreadExecutor {
+public abstract class MixinBlockableEventLoop {
-    @Shadow public static boolean isMemoryError(Throwable exception){return false;};
 
-    @Redirect(method = "executeTask", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/thread/ThreadExecutor;isMemoryError(Ljava/lang/Throwable;)Z"))
+    @Shadow public static boolean isNonRecoverable(Throwable throwable){return false;}
+
+    @Redirect(method = "doRunTask", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/thread/BlockableEventLoop;isNonRecoverable(Ljava/lang/Throwable;)Z"))
     private boolean voxy$forceCrashOnError(Throwable exception) {
         if (exception instanceof LoadException le) {
             if (le.getCause() instanceof RuntimeException cause) {
@@ -19,6 +20,6 @@ public abstract class MixinThreadExecutor {
             }
             throw le;
         }
-        return isMemoryError(exception);
+        return isNonRecoverable(exception);
     }
 }

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinClientChunkCache.java

@@ -1,12 +1,12 @@
 package me.cortex.voxy.client.mixin.minecraft;
 
-import me.cortex.voxy.client.ICheekyClientChunkManager;
+import me.cortex.voxy.client.ICheekyClientChunkCache;
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.common.world.service.VoxelIngestService;
 import net.fabricmc.loader.api.FabricLoader;
-import net.minecraft.client.world.ClientChunkManager;
+import net.minecraft.client.multiplayer.ClientChunkCache;
-import net.minecraft.util.math.ChunkPos;
+import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.chunk.WorldChunk;
+import net.minecraft.world.level.chunk.LevelChunk;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
@@ -14,20 +14,20 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(ClientChunkManager.class)
+@Mixin(ClientChunkCache.class)
-public class MixinClientChunkManager implements ICheekyClientChunkManager {
+public class MixinClientChunkCache implements ICheekyClientChunkCache {
     @Unique
     private static final boolean BOBBY_INSTALLED = FabricLoader.getInstance().isModLoaded("bobby");
 
-    @Shadow volatile ClientChunkManager.ClientChunkMap chunks;
+    @Shadow volatile ClientChunkCache.Storage storage;
 
     @Override
-    public WorldChunk voxy$cheekyGetChunk(int x, int z) {
+    public LevelChunk voxy$cheekyGetChunk(int x, int z) {
         //This doesnt do the in range check stuff, it just gets the chunk at all costs
-        return this.chunks.getChunk(this.chunks.getIndex(x, z));
+        return this.storage.getChunk(this.storage.getIndex(x, z));
     }
 
-    @Inject(method = "unload", at = @At("HEAD"))
+    @Inject(method = "drop", at = @At("HEAD"))
     public void voxy$captureChunkBeforeUnload(ChunkPos pos, CallbackInfo ci) {
         if (VoxyConfig.CONFIG.ingestEnabled && BOBBY_INSTALLED) {
             var chunk = this.voxy$cheekyGetChunk(pos.x, pos.z);

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinClientCommonPacketListenerImpl.java

@@ -1,19 +1,19 @@
 package me.cortex.voxy.client.mixin.minecraft;
 
 import me.cortex.voxy.client.LoadException;
-import net.minecraft.client.network.ClientCommonNetworkHandler;
+import net.minecraft.client.multiplayer.ClientCommonPacketListenerImpl;
-import net.minecraft.network.packet.Packet;
+import net.minecraft.network.protocol.Packet;
-import net.minecraft.network.packet.s2c.play.GameJoinS2CPacket;
+import net.minecraft.network.protocol.game.ClientboundLoginPacket;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(ClientCommonNetworkHandler.class)
+@Mixin(ClientCommonPacketListenerImpl.class)
-public class MixinClientCommonNetworkHandler {
+public class MixinClientCommonPacketListenerImpl {
-    @Inject(method = "onPacketException", at = @At("HEAD"), cancellable = true)
+    @Inject(method = "onPacketError", at = @At("HEAD"), cancellable = true)
     private void handleDisconnectAsCrash(Packet<?> packet, Exception exception, CallbackInfo ci) {
-        if (packet instanceof GameJoinS2CPacket) {
+        if (packet instanceof ClientboundLoginPacket) {
             ci.cancel();
             throw new LoadException("Force crashing due to exception during on game join", exception);
         }

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinClientLevel.java

@@ -0,0 +1,83 @@
+package me.cortex.voxy.client.mixin.minecraft;
+
+import me.cortex.voxy.common.config.VoxyConfig;
+import me.cortex.voxy.common.world.service.VoxelIngestService;
+import me.cortex.voxy.commonImpl.WorldIdentifier;
+import net.minecraft.client.multiplayer.ClientChunkCache;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.client.renderer.LevelRenderer;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
+import net.minecraft.core.SectionPos;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LightLayer;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.dimension.DimensionType;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ClientLevel.class)
+public abstract class MixinClientLevel {
+
+    @Unique
+    private int bottomSectionY;
+
+    @Shadow @Final public LevelRenderer levelRenderer;
+
+    @Shadow public abstract ClientChunkCache getChunkSource();
+
+    @Inject(method = "<init>", at = @At("TAIL"))
+    private void voxy$getBottom(
+            ClientPacketListener networkHandler,
+            ClientLevel.ClientLevelData properties,
+            ResourceKey<Level> registryRef,
+            Holder<DimensionType> dimensionType,
+            int loadDistance,
+            int simulationDistance,
+            LevelRenderer worldRenderer,
+            boolean debugWorld,
+            long seed,
+            int seaLevel,
+            CallbackInfo cir) {
+        this.bottomSectionY = ((Level)(Object)this).getMinY()>>4;
+    }
+
+    @Inject(method = "setBlocksDirty", at = @At("TAIL"))
+    private void voxy$injectIngestOnStateChange(BlockPos pos, BlockState old, BlockState updated, CallbackInfo cir) {
+        if (old == updated) return;
+
+        //TODO: is this _really_ needed, we should have enough processing power to not need todo it if its only a
+        // block removal
+        if (!updated.isAir()) return;
+
+        if (!VoxyConfig.CONFIG.ingestEnabled) return;//Only ingest if setting enabled
+
+        var self = (Level)(Object)this;
+        var wi = WorldIdentifier.of(self);
+        if (wi == null) {
+            return;
+        }
+
+        int x = pos.getX()&15;
+        int y = pos.getY()&15;
+        int z = pos.getZ()&15;
+        if (x == 0 || x==15 || y==0 || y==15 || z==0||z==15) {//Update if there is a statechange on the boarder
+            var csp = SectionPos.of(pos);
+
+            var section = self.getChunk(pos).getSection(csp.y()-this.bottomSectionY);
+            var lp = self.getLightEngine();
+
+            var blp = lp.getLayerListener(LightLayer.BLOCK).getDataLayerData(csp);
+            var slp = lp.getLayerListener(LightLayer.SKY).getDataLayerData(csp);
+
+            VoxelIngestService.rawIngest(wi, section, csp.x(), csp.y(), csp.z(), blp==null?null:blp.copy(), slp==null?null:slp.copy());
+        }
+    }
+}

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinClientPacketListener.java

@@ -1,20 +1,19 @@
 package me.cortex.voxy.client.mixin.minecraft;
 
-import me.cortex.voxy.client.VoxyClient;
 import me.cortex.voxy.client.VoxyClientInstance;
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.commonImpl.VoxyCommon;
-import net.minecraft.client.network.ClientPlayNetworkHandler;
+import net.minecraft.client.multiplayer.ClientPacketListener;
-import net.minecraft.network.packet.s2c.play.GameJoinS2CPacket;
+import net.minecraft.network.protocol.game.ClientboundLoginPacket;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(ClientPlayNetworkHandler.class)
+@Mixin(ClientPacketListener.class)
-public class MixinClientLoginNetworkHandler {
+public class MixinClientPacketListener {
-    @Inject(method = "onGameJoin", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/packet/s2c/play/GameJoinS2CPacket;commonPlayerSpawnInfo()Lnet/minecraft/network/packet/s2c/play/CommonPlayerSpawnInfo;"))
+    @Inject(method = "handleLogin", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/protocol/game/ClientboundLoginPacket;commonPlayerSpawnInfo()Lnet/minecraft/network/protocol/game/CommonPlayerSpawnInfo;"))
-    private void voxy$init(GameJoinS2CPacket packet, CallbackInfo ci) {
+    private void voxy$init(ClientboundLoginPacket packet, CallbackInfo ci) {
         if (VoxyCommon.isAvailable() && !VoxyClientInstance.isInGame) {
             VoxyClientInstance.isInGame = true;
             if (VoxyConfig.CONFIG.enabled) {

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinClientWorld.java

@@ -1,85 +0,0 @@
-package me.cortex.voxy.client.mixin.minecraft;
-
-import me.cortex.voxy.client.config.VoxyConfig;
-import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
-import me.cortex.voxy.common.world.service.VoxelIngestService;
-import me.cortex.voxy.commonImpl.VoxyCommon;
-import me.cortex.voxy.commonImpl.WorldIdentifier;
-import net.minecraft.block.BlockState;
-import net.minecraft.client.network.ClientPlayNetworkHandler;
-import net.minecraft.client.render.WorldRenderer;
-import net.minecraft.client.world.ClientChunkManager;
-import net.minecraft.client.world.ClientWorld;
-import net.minecraft.registry.RegistryKey;
-import net.minecraft.registry.entry.RegistryEntry;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.ChunkSectionPos;
-import net.minecraft.world.LightType;
-import net.minecraft.world.World;
-import net.minecraft.world.dimension.DimensionType;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.Unique;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(ClientWorld.class)
-public abstract class MixinClientWorld {
-
-    @Unique
-    private int bottomSectionY;
-
-    @Shadow @Final public WorldRenderer worldRenderer;
-
-    @Shadow public abstract ClientChunkManager getChunkManager();
-
-    @Inject(method = "<init>", at = @At("TAIL"))
-    private void voxy$getBottom(
-            ClientPlayNetworkHandler networkHandler,
-            ClientWorld.Properties properties,
-            RegistryKey<World> registryRef,
-            RegistryEntry<DimensionType> dimensionType,
-            int loadDistance,
-            int simulationDistance,
-            WorldRenderer worldRenderer,
-            boolean debugWorld,
-            long seed,
-            int seaLevel,
-            CallbackInfo cir) {
-        this.bottomSectionY = ((World)(Object)this).getBottomY()>>4;
-    }
-
-    @Inject(method = "scheduleBlockRerenderIfNeeded", at = @At("TAIL"))
-    private void voxy$injectIngestOnStateChange(BlockPos pos, BlockState old, BlockState updated, CallbackInfo cir) {
-        if (old == updated) return;
-
-        //TODO: is this _really_ needed, we should have enough processing power to not need todo it if its only a
-        // block removal
-        if (!updated.isAir()) return;
-
-        if (!VoxyConfig.CONFIG.ingestEnabled) return;//Only ingest if setting enabled
-
-        var self = (World)(Object)this;
-        var wi = WorldIdentifier.of(self);
-        if (wi == null) {
-            return;
-        }
-
-        int x = pos.getX()&15;
-        int y = pos.getY()&15;
-        int z = pos.getZ()&15;
-        if (x == 0 || x==15 || y==0 || y==15 || z==0||z==15) {//Update if there is a statechange on the boarder
-            var csp = ChunkSectionPos.from(pos);
-
-            var section = self.getChunk(pos).getSection(csp.getSectionY()-this.bottomSectionY);
-            var lp = self.getLightingProvider();
-
-            var blp = lp.get(LightType.BLOCK).getLightSection(csp);
-            var slp = lp.get(LightType.SKY).getLightSection(csp);
-
-            VoxelIngestService.rawIngest(wi, section, csp.getSectionX(), csp.getSectionY(), csp.getSectionZ(), blp==null?null:blp.copy(), slp==null?null:slp.copy());
-        }
-    }
-}

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinDebugHud.java

@@ -1,30 +0,0 @@
-package me.cortex.voxy.client.mixin.minecraft;
-
-import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
-import me.cortex.voxy.commonImpl.VoxyCommon;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.gui.hud.DebugHud;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.List;
-
-@Mixin(DebugHud.class)
-public class MixinDebugHud {
-    @Inject(method = "getRightText", at = @At("RETURN"))
-    private void injectDebug(CallbackInfoReturnable<List<String>> cir) {
-        var ret = cir.getReturnValue();
-        var instance = VoxyCommon.getInstance();
-        if (instance != null) {
-            ret.add("");
-            ret.add("");
-            instance.addDebug(ret);
-        }
-        var renderer = ((IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer).getVoxyRenderSystem();
-        if (renderer != null) {
-            renderer.addDebugInfo(ret);
-        }
-    }
-}

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinDebugScreenEntryList.java

@@ -0,0 +1,28 @@
+package me.cortex.voxy.client.mixin.minecraft;
+
+import net.minecraft.client.gui.components.debug.DebugScreenEntryList;
+import net.minecraft.resources.Identifier;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.List;
+
+@Mixin(DebugScreenEntryList.class)
+public abstract class MixinDebugScreenEntryList {
+    @Shadow @Final private List<Identifier> currentlyEnabled;
+    @Shadow public abstract boolean isOverlayVisible();
+
+    @Inject(method = "rebuildCurrentList", at = @At(value = "INVOKE", target = "Ljava/util/List;sort(Ljava/util/Comparator;)V"))
+    private void voxy$injectVersionDisplay(CallbackInfo cir) {
+        if (this.isOverlayVisible()) {
+            var id = Identifier.fromNamespaceAndPath("voxy", "version");
+            if (!this.currentlyEnabled.contains(id)) {
+                this.currentlyEnabled.add(id);
+            }
+        }
+    }
+}

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinFogRenderer.java

@@ -1,30 +1,40 @@
 package me.cortex.voxy.client.mixin.minecraft;
 
-import me.cortex.voxy.client.config.VoxyConfig;
+import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
+import com.llamalad7.mixinextras.sugar.Local;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Camera;
-import net.minecraft.client.render.fog.FogData;
+import net.minecraft.client.DeltaTracker;
-import net.minecraft.client.render.fog.FogRenderer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.fog.FogData;
+import net.minecraft.client.renderer.fog.FogRenderer;
+import org.joml.Vector4f;
 import org.objectweb.asm.Opcodes;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-@Mixin(FogRenderer.class)
+@Mixin(value = FogRenderer.class,remap = true)
 public class MixinFogRenderer {
-    @Redirect(method = "applyFog(Lnet/minecraft/client/render/Camera;IZLnet/minecraft/client/render/RenderTickCounter;FLnet/minecraft/client/world/ClientWorld;)Lorg/joml/Vector4f;", at = @At(value = "FIELD", target = "Lnet/minecraft/client/render/fog/FogData;renderDistanceEnd:F", opcode = Opcodes.PUTFIELD), require = 0)
+    @Inject(method = "setupFog", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/systems/RenderSystem;getDevice()Lcom/mojang/blaze3d/systems/GpuDevice;", remap = false))
-    private void voxy$modifyFog(FogData instance, float distance) {
+    private void voxy$modifyFog(Camera camera, int rdInt, DeltaTracker tracker, float pTick, ClientLevel lvl, CallbackInfoReturnable<Vector4f> cir, @Local(type=FogData.class) FogData data) {
-        var vrs = (IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer;
+        if (!VoxyConfig.CONFIG.isRenderingEnabled()) return;
 
-        if (VoxyConfig.CONFIG.renderVanillaFog || vrs == null || vrs.getVoxyRenderSystem() == null) {
+        var vrs = IGetVoxyRenderSystem.getNullable();
-            instance.renderDistanceEnd = distance;
+        if (vrs == null) return;
-        } else {
+
-            instance.renderDistanceStart = 999999999;
+        data.renderDistanceStart = 999999999;
-            instance.renderDistanceEnd = 999999999;
+        data.renderDistanceEnd = 999999999;
-            if (!VoxyConfig.CONFIG.useEnvironmentalFog) {
+        /*
-                instance.environmentalStart = 99999999;
+        if (!VoxyConfig.CONFIG.useRenderFog) {
-                instance.environmentalEnd = 99999999;
+        }*/
-            }
+        if (!VoxyConfig.CONFIG.useEnvironmentalFog) {
+            data.environmentalStart = 99999999;
+            data.environmentalEnd = 99999999;
         }
     }
 }

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinGlDebug.java

@@ -2,7 +2,7 @@ package me.cortex.voxy.client.mixin.minecraft;
 
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
-import net.minecraft.client.gl.GlDebug;
+import com.mojang.blaze3d.opengl.GlDebug;
 import org.slf4j.Logger;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
@@ -13,9 +13,9 @@ import java.io.StringWriter;
 
 @Mixin(GlDebug.class)
 public class MixinGlDebug {
-    @WrapOperation(method = "onDebugMessage", at = @At(value = "INVOKE", target = "Lorg/slf4j/Logger;info(Ljava/lang/String;Ljava/lang/Object;)V", remap = false))
+    @WrapOperation(method = "printDebugLog", at = @At(value = "INVOKE", target = "Lorg/slf4j/Logger;info(Ljava/lang/String;Ljava/lang/Object;)V", remap = false))
     private void voxy$wrapDebug(Logger instance, String base, Object msgObj, Operation<Void> original) {
-        if (msgObj instanceof GlDebug.DebugMessage msg) {
+        if (msgObj instanceof GlDebug.LogEntry msg) {
             var throwable = new Throwable(msg.toString());
             if (isCausedByVoxy(throwable.getStackTrace())) {
                 original.call(instance, base+"\n"+getStackTraceAsString(throwable), throwable);

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinLayerLightSectionStorage.java

@@ -0,0 +1,16 @@
+package me.cortex.voxy.client.mixin.minecraft;
+
+import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
+import net.minecraft.world.level.chunk.DataLayer;
+import net.minecraft.world.level.lighting.LayerLightSectionStorage;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+@Mixin(LayerLightSectionStorage.class)
+public class MixinLayerLightSectionStorage {
+    @Redirect(method = "<init>", at = @At(value = "INVOKE", target = "Lit/unimi/dsi/fastutil/longs/Long2ObjectMaps;synchronize(Lit/unimi/dsi/fastutil/longs/Long2ObjectMap;)Lit/unimi/dsi/fastutil/longs/Long2ObjectMap;"), remap = false)
+    private static Long2ObjectMap<DataLayer> voxy$removeSynchronized(Long2ObjectMap<DataLayer> map) {
+        return map;
+    }
+}

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinLevelRenderer.java

@@ -1,7 +1,7 @@
 package me.cortex.voxy.client.mixin.minecraft;
 
 import me.cortex.voxy.client.VoxyClientInstance;
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
 import me.cortex.voxy.client.core.VoxyRenderSystem;
 import me.cortex.voxy.client.core.util.IrisUtil;
@@ -9,9 +9,8 @@ import me.cortex.voxy.common.Logger;
 import me.cortex.voxy.common.world.WorldEngine;
 import me.cortex.voxy.commonImpl.VoxyCommon;
 import me.cortex.voxy.commonImpl.WorldIdentifier;
-import net.minecraft.client.render.Frustum;
+import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.client.render.WorldRenderer;
+import net.minecraft.client.renderer.LevelRenderer;
-import net.minecraft.client.world.ClientWorld;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -20,9 +19,9 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(WorldRenderer.class)
+@Mixin(LevelRenderer.class)
-public abstract class MixinWorldRenderer implements IGetVoxyRenderSystem {
+public abstract class MixinLevelRenderer implements IGetVoxyRenderSystem {
-    @Shadow private @Nullable ClientWorld world;
+    @Shadow private @Nullable ClientLevel level;
     @Unique private VoxyRenderSystem renderer;
 
     @Override
@@ -30,17 +29,17 @@ public abstract class MixinWorldRenderer implements IGetVoxyRenderSystem {
         return this.renderer;
     }
 
-    @Inject(method = "reload()V", at = @At("RETURN"), order = 900)//We want to inject before sodium
+    @Inject(method = "allChanged()V", at = @At("RETURN"), order = 900)//We want to inject before sodium
     private void reloadVoxyRenderer(CallbackInfo ci) {
         this.shutdownRenderer();
-        if (this.world != null) {
+        if (this.level != null) {
             this.createRenderer();
         }
     }
 
-    @Inject(method = "setWorld", at = @At("HEAD"))
+    @Inject(method = "setLevel", at = @At("HEAD"))
-    private void voxy$captureSetWorld(ClientWorld world, CallbackInfo ci) {
+    private void voxy$captureSetWorld(ClientLevel world, CallbackInfo ci) {
-        if (this.world != world) {
+        if (this.level != world) {
             this.shutdownRenderer();
         }
     }
@@ -61,11 +60,15 @@ public abstract class MixinWorldRenderer implements IGetVoxyRenderSystem {
     @Override
     public void createRenderer() {
         if (this.renderer != null) throw new IllegalStateException("Cannot have multiple renderers");
-        if (!VoxyConfig.CONFIG.isRenderingEnabled()) {
+        if (!VoxyConfig.CONFIG.enabled) {
             Logger.info("Not creating renderer due to disabled");
             return;
         }
-        if (this.world == null) {
+        if (!VoxyConfig.CONFIG.isRenderingEnabled()) {
+            Logger.info("Not creating renderer due to disabled rendering");
+            return;
+        }
+        if (this.level == null) {
             Logger.error("Not creating renderer due to null world");
             return;
         }
@@ -74,13 +77,13 @@ public abstract class MixinWorldRenderer implements IGetVoxyRenderSystem {
             Logger.error("Not creating renderer due to null instance");
             return;
         }
-        WorldEngine world = WorldIdentifier.ofEngine(this.world);
+        WorldEngine world = WorldIdentifier.ofEngine(this.level);
         if (world == null) {
             Logger.error("Null world selected");
             return;
         }
         try {
-            this.renderer = new VoxyRenderSystem(world, instance.getThreadPool());
+            this.renderer = new VoxyRenderSystem(world, instance.getServiceManager());
         } catch (RuntimeException e) {
             if (IrisUtil.irisShaderPackEnabled()) {
                 IrisUtil.disableIrisShaders();
@@ -88,5 +91,6 @@ public abstract class MixinWorldRenderer implements IGetVoxyRenderSystem {
                 throw e;
             }
         }
+        instance.updateDedicatedThreads();
     }
 }

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinMinecraft.java

@@ -2,15 +2,15 @@ package me.cortex.voxy.client.mixin.minecraft;
 
 import me.cortex.voxy.client.VoxyClientInstance;
 import me.cortex.voxy.commonImpl.VoxyCommon;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(MinecraftClient.class)
+@Mixin(Minecraft.class)
-public class MixinMinecraftClient {
+public class MixinMinecraft {
-    @Inject(method = "disconnect(Lnet/minecraft/client/gui/screen/Screen;Z)V", at = @At("TAIL"))
+    @Inject(method = "disconnect", at = @At("TAIL"))
     private void voxy$injectWorldClose(CallbackInfo ci) {
         if (VoxyCommon.isAvailable() && VoxyClientInstance.isInGame) {
             VoxyCommon.shutdownInstance();

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinRenderSystem.java

@@ -1,10 +1,11 @@
 package me.cortex.voxy.client.mixin.minecraft;
 
 
+import com.mojang.blaze3d.shaders.ShaderSource;
 import com.mojang.blaze3d.shaders.ShaderType;
 import com.mojang.blaze3d.systems.RenderSystem;
 import me.cortex.voxy.client.VoxyClient;
-import net.minecraft.util.Identifier;
+import net.minecraft.resources.Identifier;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -17,7 +18,7 @@ import java.util.function.BiFunction;
 public class MixinRenderSystem {
     //We need to inject before iris to initalize our systems
     @Inject(method = "initRenderer", order = 900, remap = false, at = @At("RETURN"))
-    private static void voxy$injectInit(long windowHandle, int debugVerbosity, boolean sync, BiFunction<Identifier, ShaderType, String> shaderSourceGetter, boolean renderDebugLabels, CallbackInfo ci) {
+    private static void voxy$injectInit(long windowHandle, int debugVerbosity, boolean sync, ShaderSource source, boolean renderDebugLabels, CallbackInfo ci) {
         VoxyClient.initVoxyClient();
     }
 }

src/main/java/me/cortex/voxy/client/mixin/minecraft/MixinWindow.java

@@ -1,11 +1,11 @@
 package me.cortex.voxy.client.mixin.minecraft;
 
+import com.mojang.blaze3d.platform.DisplayData;
+import com.mojang.blaze3d.platform.ScreenManager;
+import com.mojang.blaze3d.platform.Window;
+import com.mojang.blaze3d.platform.WindowEventHandler;
 import me.cortex.voxy.client.GPUSelectorWindows2;
 import me.cortex.voxy.common.util.ThreadUtils;
-import net.minecraft.client.WindowEventHandler;
-import net.minecraft.client.WindowSettings;
-import net.minecraft.client.util.MonitorTracker;
-import net.minecraft.client.util.Window;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -13,8 +13,8 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(Window.class)
 public class MixinWindow {
-    @Inject(method = "<init>", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/util/Window;throwOnGlError()V"))
+    @Inject(method = "<init>", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/platform/Window;setBootErrorCallback()V"))
-    private void injectInitWindow(WindowEventHandler eventHandler, MonitorTracker monitorTracker, WindowSettings settings, String fullscreenVideoMode, String title, CallbackInfo ci) {
+    private void injectInitWindow(WindowEventHandler eventHandler, ScreenManager monitorTracker, DisplayData settings, String fullscreenVideoMode, String title, CallbackInfo ci) {
         //System.load("C:\\Program Files\\RenderDoc\\renderdoc.dll");
         var prop = System.getProperty("voxy.forceGpuSelectionIndex", "NO");
         if (!prop.equals("NO")) {

src/main/java/me/cortex/voxy/client/mixin/nvidium/MixinRenderPipeline.java

@@ -6,7 +6,7 @@ import net.caffeinemc.mods.sodium.client.render.chunk.ChunkRenderMatrices;
 import net.caffeinemc.mods.sodium.client.render.chunk.terrain.TerrainRenderPass;
 import net.caffeinemc.mods.sodium.client.render.viewport.Viewport;
 import net.caffeinemc.mods.sodium.client.util.FogParameters;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -16,7 +16,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 public class MixinRenderPipeline {
     @Inject(method = "renderFrame", at = @At("RETURN"))
     private void voxy$injectRender(TerrainRenderPass pass, Viewport frustum, FogParameters fogParameters, ChunkRenderMatrices crm, double px, double py, double pz, CallbackInfo ci) {
-        var renderer = ((IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer).getVoxyRenderSystem();
+        var renderer = ((IGetVoxyRenderSystem) Minecraft.getInstance().levelRenderer).getVoxyRenderSystem();
         if (renderer != null) {
             renderer.renderOpaque(renderer.setupViewport(crm, fogParameters, px, py, pz));
         }

src/main/java/me/cortex/voxy/client/mixin/sodium/AccessorSodiumWorldRenderer.java

@@ -0,0 +1,14 @@
+package me.cortex.voxy.client.mixin.sodium;
+
+import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap;
+import net.caffeinemc.mods.sodium.client.render.SodiumWorldRenderer;
+import net.caffeinemc.mods.sodium.client.render.chunk.RenderSectionManager;
+import net.caffeinemc.mods.sodium.client.render.chunk.map.ChunkTracker;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(value = SodiumWorldRenderer.class, remap = false)
+public interface AccessorSodiumWorldRenderer {
+    @Accessor
+    RenderSectionManager getRenderSectionManager();
+}

src/main/java/me/cortex/voxy/client/mixin/sodium/MixinChunkJobQueue.java

@@ -0,0 +1,36 @@
+package me.cortex.voxy.client.mixin.sodium;
+
+import me.cortex.voxy.client.compat.SemaphoreBlockImpersonator;
+import me.cortex.voxy.common.config.VoxyConfig;
+import me.cortex.voxy.common.thread.MultiThreadPrioritySemaphore;
+import me.cortex.voxy.commonImpl.VoxyCommon;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.concurrent.Semaphore;
+
+@Mixin(targets={"net.caffeinemc.mods.sodium.client.render.chunk.compile.executor.ChunkJobQueue"},remap = false)
+public class MixinChunkJobQueue {
+    @Unique private MultiThreadPrioritySemaphore.Block voxy$semaphoreBlock;
+
+    @Redirect(method = "<init>", at = @At(value = "NEW", target = "(I)Ljava/util/concurrent/Semaphore;"))
+    private Semaphore voxy$injectUnifiedPool(int permits) {
+        var instance = VoxyCommon.getInstance();
+        if (instance != null && !VoxyConfig.CONFIG.dontUseSodiumBuilderThreads) {
+            this.voxy$semaphoreBlock = instance.getThreadPool().groupSemaphore.createBlock();
+            return new SemaphoreBlockImpersonator(this.voxy$semaphoreBlock);
+        }
+        return new Semaphore(permits);
+    }
+
+    @Inject(method = "shutdown", at = @At("RETURN"))
+    private void voxy$injectAtShutdown(CallbackInfoReturnable ci) {
+        if (this.voxy$semaphoreBlock != null) {
+            this.voxy$semaphoreBlock.free();
+        }
+    }
+}

src/main/java/me/cortex/voxy/client/mixin/sodium/MixinDefaultChunkRenderer.java

@@ -1,29 +1,55 @@
 package me.cortex.voxy.client.mixin.sodium;
 
+import com.mojang.blaze3d.textures.GpuSampler;
+import me.cortex.voxy.client.VoxyClient;
 import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
 import me.cortex.voxy.client.core.rendering.Viewport;
 import me.cortex.voxy.client.core.util.IrisUtil;
+import me.cortex.voxy.commonImpl.VoxyCommon;
 import net.caffeinemc.mods.sodium.client.gl.device.CommandList;
+import net.caffeinemc.mods.sodium.client.gl.device.RenderDevice;
 import net.caffeinemc.mods.sodium.client.render.chunk.ChunkRenderMatrices;
 import net.caffeinemc.mods.sodium.client.render.chunk.DefaultChunkRenderer;
+import net.caffeinemc.mods.sodium.client.render.chunk.ShaderChunkRenderer;
 import net.caffeinemc.mods.sodium.client.render.chunk.lists.ChunkRenderListIterable;
 import net.caffeinemc.mods.sodium.client.render.chunk.terrain.DefaultTerrainRenderPasses;
 import net.caffeinemc.mods.sodium.client.render.chunk.terrain.TerrainRenderPass;
+import net.caffeinemc.mods.sodium.client.render.chunk.vertex.format.ChunkVertexType;
 import net.caffeinemc.mods.sodium.client.render.viewport.CameraTransform;
 import net.caffeinemc.mods.sodium.client.util.FogParameters;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(value = DefaultChunkRenderer.class, remap = false)
-public class MixinDefaultChunkRenderer {
+public abstract class MixinDefaultChunkRenderer extends ShaderChunkRenderer {
+
+    public MixinDefaultChunkRenderer(RenderDevice device, ChunkVertexType vertexType) {
+        super(device, vertexType);
+    }
+
+    @Inject(method = "render", at = @At(value = "HEAD"), cancellable = true)
+    private void cancelThingie(ChunkRenderMatrices matrices, CommandList commandList, ChunkRenderListIterable renderLists, TerrainRenderPass renderPass, CameraTransform camera, FogParameters fogParameters, boolean indexedRenderingEnabled, GpuSampler terrainSampler, CallbackInfo ci) {
+        if (VoxyClient.disableSodiumChunkRender()) {
+            super.begin(renderPass, fogParameters, terrainSampler);
+            this.doRender(matrices, renderPass, camera, fogParameters);
+            super.end(renderPass);
+            ci.cancel();
+        }
+    }
 
     @Inject(method = "render", at = @At(value = "INVOKE", target = "Lnet/caffeinemc/mods/sodium/client/render/chunk/ShaderChunkRenderer;end(Lnet/caffeinemc/mods/sodium/client/render/chunk/terrain/TerrainRenderPass;)V", shift = At.Shift.BEFORE))
-    private void injectRender(ChunkRenderMatrices matrices, CommandList commandList, ChunkRenderListIterable renderLists, TerrainRenderPass renderPass, CameraTransform camera, FogParameters fogParameters, boolean indexedRenderingEnabled, CallbackInfo ci) {
+    private void injectRender(ChunkRenderMatrices matrices, CommandList commandList, ChunkRenderListIterable renderLists, TerrainRenderPass renderPass, CameraTransform camera, FogParameters fogParameters, boolean indexedRenderingEnabled, GpuSampler terrainSampler, CallbackInfo ci) {
+        this.doRender(matrices, renderPass, camera, fogParameters);
+    }
+
+    @Unique
+    private void doRender(ChunkRenderMatrices matrices, TerrainRenderPass renderPass, CameraTransform camera, FogParameters fogParameters) {
         if (renderPass == DefaultTerrainRenderPasses.CUTOUT) {
-            var renderer = ((IGetVoxyRenderSystem) MinecraftClient.getInstance().worldRenderer).getVoxyRenderSystem();
+            var renderer = ((IGetVoxyRenderSystem) Minecraft.getInstance().levelRenderer).getVoxyRenderSystem();
             if (renderer != null) {
                 Viewport<?> viewport = null;
                 if (IrisUtil.irisShaderPackEnabled()) {

src/main/java/me/cortex/voxy/client/mixin/sodium/MixinRenderRegionManager.java

@@ -0,0 +1,29 @@
+package me.cortex.voxy.client.mixin.sodium;
+
+import com.llamalad7.mixinextras.injector.v2.WrapWithCondition;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import me.cortex.voxy.common.config.VoxyConfig;
+import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
+import me.cortex.voxy.commonImpl.VoxyCommon;
+import net.caffeinemc.mods.sodium.client.render.chunk.RenderSection;
+import net.caffeinemc.mods.sodium.client.render.chunk.region.RenderRegionManager;
+import net.minecraft.client.Minecraft;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(value = RenderRegionManager.class, remap = false)
+public class MixinRenderRegionManager {
+    @Redirect(method = "uploadResults(Lnet/caffeinemc/mods/sodium/client/gl/device/CommandList;Lnet/caffeinemc/mods/sodium/client/render/chunk/region/RenderRegion;Ljava/util/Collection;)V", at = @At(value = "INVOKE", target = "Ljava/lang/Math;toIntExact(J)I"), remap = false)
+    private int voxy$cancelFade(long time) {
+        var vrs = ((IGetVoxyRenderSystem)(Minecraft.getInstance().levelRenderer)).getVoxyRenderSystem();
+        if (vrs!=null) {
+            return -2;
+        } else {
+            return Math.toIntExact(time);
+        }
+    }
+}

src/main/java/me/cortex/voxy/client/mixin/sodium/MixinRenderSectionManager.java

@@ -1,23 +1,24 @@
 package me.cortex.voxy.client.mixin.sodium;
 
-import me.cortex.voxy.client.ICheekyClientChunkManager;
+import me.cortex.voxy.client.ICheekyClientChunkCache;
-import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.common.config.VoxyConfig;
 import me.cortex.voxy.client.core.IGetVoxyRenderSystem;
 import me.cortex.voxy.client.core.VoxyRenderSystem;
 import me.cortex.voxy.common.world.service.VoxelIngestService;
 import me.cortex.voxy.commonImpl.VoxyCommon;
-import me.cortex.voxy.commonImpl.WorldIdentifier;
 import net.caffeinemc.mods.sodium.client.gl.device.CommandList;
 import net.caffeinemc.mods.sodium.client.render.chunk.RenderSection;
 import net.caffeinemc.mods.sodium.client.render.chunk.RenderSectionManager;
+import net.caffeinemc.mods.sodium.client.render.chunk.compile.executor.ChunkBuilder;
 import net.caffeinemc.mods.sodium.client.render.chunk.data.BuiltSectionInfo;
 import net.caffeinemc.mods.sodium.client.render.chunk.map.ChunkTrackerHolder;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.SortBehavior;
 import net.fabricmc.loader.api.FabricLoader;
-import net.minecraft.client.world.ClientWorld;
+import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.util.math.ChunkPos;
+import net.minecraft.core.SectionPos;
-import net.minecraft.util.math.ChunkSectionPos;
+import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.LightType;
+import net.minecraft.world.level.LightLayer;
+import net.minecraft.world.level.chunk.status.ChunkStatus;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -32,24 +33,26 @@ public class MixinRenderSectionManager {
     @Unique
     private static final boolean BOBBY_INSTALLED = FabricLoader.getInstance().isModLoaded("bobby");
 
-    @Shadow @Final private ClientWorld level;
+    @Shadow @Final private ClientLevel level;
+
+    @Shadow @Final private ChunkBuilder builder;
 
     @Inject(method = "<init>", at = @At("TAIL"))
-    private void voxy$resetChunkTracker(ClientWorld level, int renderDistance, SortBehavior sortBehavior, CommandList commandList, CallbackInfo ci) {
+    private void voxy$resetChunkTracker(ClientLevel level, int renderDistance, SortBehavior sortBehavior, CommandList commandList, CallbackInfo ci) {
-        if (level.worldRenderer != null) {
+        if (level.levelRenderer != null) {
-            var system = ((IGetVoxyRenderSystem)(level.worldRenderer)).getVoxyRenderSystem();
+            var system = ((IGetVoxyRenderSystem)(level.levelRenderer)).getVoxyRenderSystem();
             if (system != null) {
                 system.chunkBoundRenderer.reset();
             }
         }
-        this.bottomSectionY = this.level.getBottomY()>>4;
+        this.bottomSectionY = this.level.getMinY()>>4;
     }
 
     @Inject(method = "onChunkRemoved", at = @At("HEAD"))
     private void injectIngest(int x, int z, CallbackInfo ci) {
         //TODO: Am not quite sure if this is right
         if (VoxyConfig.CONFIG.ingestEnabled && !BOBBY_INSTALLED) {
-            var cccm = (ICheekyClientChunkManager)this.level.getChunkManager();
+            var cccm = (ICheekyClientChunkCache)this.level.getChunkSource();
             if (cccm != null) {
                 var chunk = cccm.voxy$cheekyGetChunk(x, z);
                 if (chunk != null) {
@@ -59,16 +62,19 @@ public class MixinRenderSectionManager {
         }
     }
 
-    /*
+
     @Inject(method = "onChunkAdded", at = @At("HEAD"))
-    private void voxy$trackChunkAdd(int x, int z, CallbackInfo ci) {
+    private void voxy$ingestOnAdd(int x, int z, CallbackInfo ci) {
-        if (this.level.worldRenderer != null) {
+        if (this.level.levelRenderer != null && VoxyConfig.CONFIG.ingestEnabled) {
-            var system = ((IGetVoxyRenderSystem)(this.level.worldRenderer)).getVoxyRenderSystem();
+            var cccm = this.level.getChunkSource();
-            if (system != null) {
+            if (cccm != null) {
-                system.chunkBoundRenderer.addChunk(ChunkPos.toLong(x, z));
+                var chunk = cccm.getChunk(x, z, ChunkStatus.FULL, false);
+                if (chunk != null) {
+                    VoxelIngestService.tryAutoIngestChunk(chunk);
+                }
             }
         }
-    }*/
+    }
 
     /*
     @Inject(method = "onChunkRemoved", at = @At("HEAD"))
@@ -100,28 +106,28 @@ public class MixinRenderSectionManager {
         if (flags == 0)//Only process things with stuff
             return true;
 
-        VoxyRenderSystem system = ((IGetVoxyRenderSystem)(this.level.worldRenderer)).getVoxyRenderSystem();
+        VoxyRenderSystem system = ((IGetVoxyRenderSystem)(this.level.levelRenderer)).getVoxyRenderSystem();
         if (system == null) {
             return true;
         }
         int x = instance.getChunkX(), y = instance.getChunkY(), z = instance.getChunkZ();
 
-        if (wasBuilt) {
+        if (wasBuilt && VoxyConfig.CONFIG.ingestEnabled) {
             var tracker = ((AccessorChunkTracker)ChunkTrackerHolder.get(this.level)).getChunkStatus();
             //in theory the cache value could be wrong but is so soso unlikely and at worst means we either duplicate ingest a chunk
             // which... could be bad ;-; or we dont ingest atall which is ok!
-            long key = ChunkPos.toLong(x, z);
+            long key = ChunkPos.asLong(x, z);
             if (key != this.cachedChunkPos) {
                 this.cachedChunkPos = key;
                 this.cachedChunkStatus = tracker.getOrDefault(key, 0);
             }
             if (this.cachedChunkStatus == 3) {//If this chunk still has surrounding chunks
                 var section = this.level.getChunk(x,z).getSection(y-this.bottomSectionY);
-                var lp = this.level.getLightingProvider();
+                var lp = this.level.getLightEngine();
 
-                var csp = ChunkSectionPos.from(x,y,z);
+                var csp = SectionPos.of(x,y,z);
-                var blp = lp.get(LightType.BLOCK).getLightSection(csp);
+                var blp = lp.getLayerListener(LightLayer.BLOCK).getDataLayerData(csp);
-                var slp = lp.get(LightType.SKY).getLightSection(csp);
+                var slp = lp.getLayerListener(LightLayer.SKY).getDataLayerData(csp);
 
                 //Note: we dont do this check and just blindly ingest, it shouldbe ok :tm:
                 //if (blp != null || slp != null)
@@ -135,7 +141,7 @@ public class MixinRenderSectionManager {
             x-=sector<<10;
             y+=16+(256-32-sector*30);
         }
-        long pos = ChunkSectionPos.asLong(x,y,z);
+        long pos = SectionPos.asLong(x,y,z);
         if (wasBuilt) {//Remove
             //TODO: on chunk remove do ingest if is surrounded by built chunks (or when the tracker says is ok)
 

src/main/java/me/cortex/voxy/client/mixin/sodium/MixinSodiumOptionsGUI.java

@@ -1,27 +0,0 @@
-package me.cortex.voxy.client.mixin.sodium;
-
-import me.cortex.voxy.client.config.VoxyConfigScreenPages;
-import me.cortex.voxy.commonImpl.VoxyCommon;
-import net.caffeinemc.mods.sodium.client.gui.SodiumOptionsGUI;
-import net.caffeinemc.mods.sodium.client.gui.options.OptionPage;
-import net.minecraft.client.gui.screen.Screen;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.List;
-
-@Mixin(SodiumOptionsGUI.class)
-public class MixinSodiumOptionsGUI {
-    @Shadow(remap = false) @Final private List<OptionPage> pages;
-
-    @Inject(method = "<init>", at = @At("TAIL"))
-    private void voxy$addConfigPage(Screen prevScreen, CallbackInfo ci) {
-        if (VoxyCommon.isAvailable()) {
-            this.pages.add(VoxyConfigScreenPages.voxyOptionPage = VoxyConfigScreenPages.page());
-        }
-    }
-}

src/main/java/me/cortex/voxy/client/mixin/sodium/MixinSodiumWorldRenderer.java

@@ -0,0 +1,19 @@
+package me.cortex.voxy.client.mixin.sodium;
+
+import me.cortex.voxy.commonImpl.VoxyCommon;
+import me.cortex.voxy.commonImpl.VoxyInstance;
+import net.caffeinemc.mods.sodium.client.gl.device.CommandList;
+import net.caffeinemc.mods.sodium.client.render.SodiumWorldRenderer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(value = SodiumWorldRenderer.class, remap = false)
+public class MixinSodiumWorldRenderer {
+    @Inject(method = "initRenderer", at = @At("TAIL"), remap = false)
+    private void voxy$injectThreadUpdate(CommandList cl, CallbackInfo ci) {
+        var vi = VoxyCommon.getInstance();
+        if (vi != null) vi.updateDedicatedThreads();
+    }
+}

src/main/java/me/cortex/voxy/client/mixin/sodium/MixinVideoSettingsScreen.java

@@ -0,0 +1,34 @@
+package me.cortex.voxy.client.mixin.sodium;
+
+import me.cortex.voxy.client.config.IConfigPageSetter;
+import net.caffeinemc.mods.sodium.client.config.structure.OptionPage;
+import net.caffeinemc.mods.sodium.client.config.structure.Page;
+import net.caffeinemc.mods.sodium.client.gui.VideoSettingsScreen;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(value = VideoSettingsScreen.class, remap = false)
+public abstract class MixinVideoSettingsScreen implements IConfigPageSetter {
+    @Shadow public abstract void jumpToPage(Page page);
+
+    @Shadow protected abstract void onSectionFocused(Page page);
+
+    @Unique
+    private OptionPage voxyJumpPage;
+
+    public void voxy$setPageJump(OptionPage page) {
+        this.voxyJumpPage = page;
+    }
+
+    @Inject(method = "rebuild", at = @At("TAIL"))
+    private void voxy$jumpPages(CallbackInfo ci) {
+        if (this.voxyJumpPage != null) {
+            this.jumpToPage(this.voxyJumpPage);
+            this.onSectionFocused(this.voxyJumpPage);
+        }
+    }
+}

src/main/java/me/cortex/voxy/client/taskbar/Taskbar.java

@@ -1,7 +1,7 @@
 package me.cortex.voxy.client.taskbar;
 
 import me.cortex.voxy.common.Logger;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
 import org.apache.commons.lang3.SystemUtils;
 
 public abstract class Taskbar {
@@ -37,7 +37,7 @@ public abstract class Taskbar {
     private static ITaskbar createInterface() {
         if (SystemUtils.IS_OS_WINDOWS) {
             try {
-                return new WindowsTaskbar(MinecraftClient.getInstance().getWindow().getHandle());
+                return new WindowsTaskbar(Minecraft.getInstance().getWindow().handle());
             } catch (Exception e) {
                 Logger.error("Unable to create windows taskbar interface", e);
                 return new NoopTaskbar();