Update the mod homepage

The rendering is almost completely functional, only fog needs to be re-implemented.

.gitignore

@@ -22,4 +22,32 @@ eclipse
 run
 
 # Files from Forge MDK
+logs
 forge*changelog.txt
+
+.architectury-transformer/
+build/
+*.ipr
+run/
+*.iws
+out/
+*.iml
+.gradle/
+output/
+bin/
+libs/
+
+.classpath
+.project
+.idea/
+classes/
+.metadata
+.vscode
+.settings
+*.launch
+
+**/src/generated/
+Merged/
+
+# file from notepad++
+*.bak

.gitlab-ci.yml

@@ -0,0 +1,132 @@
+# use Eclipse's JDK
+image: gradle:eclipse-temurin
+
+# all stages need to be defined here
+stages:
+    - gradleSetup
+    - build
+    - merge
+
+variables:
+    # Disable the Gradle daemon for Continuous Integration servers as correctness
+    # is usually a priority over speed in CI environments. Using a fresh
+    # runtime for each build is more reliable since the runtime is completely
+    # isolated from any previous builds.
+    GRADLE_OPTS: "-Dorg.gradle.daemon=false"
+    # Pull core when building
+    GIT_SUBMODULE_STRATEGY: recursive
+
+
+before_script:
+    - echo $CI_JOB_ID
+    # Writing GE_JOB_ID variable to environment file, will need the value in the next stage.
+    - echo GE_JOB_ID=$CI_JOB_ID >> generate_jars.env
+
+
+
+
+# first stage
+# This prevents us from re-downloading Gradle every stage
+gradleSetup:
+    stage: gradleSetup
+    script: ./gradlew --build-cache --gradle-user-home cache/ check
+    # build using Java 17
+    image: eclipse-temurin:17
+    cache:
+        key:
+            files:
+                - gradle/wrapper/gradle-wrapper.properties
+        policy: push
+        paths:
+            - cache/
+
+
+
+# second stage
+build:
+    stage: build
+    script: ./gradlew build --gradle-user-home cache/
+    # build using Java 17
+    image: eclipse-temurin:17
+    cache:
+        key: "$CI_COMMIT_REF_NAME"
+        policy: pull-push
+        paths:
+            - .architectury-transformer
+            - .gradle
+            - build
+            - common/.gradle
+            - common/build
+            - core/.gradle
+            - core/build
+            - fabric/.gradle
+            - fabric/src/generated
+            - forge/.gradle
+            - forge/src/generated
+            - build
+            - .gradle
+            - cache/
+    artifacts:
+        name: "NightlyBuild-$CI_COMMIT_SHORT_SHA}-${CI_COMMIT_TIMESTAMP}"
+        paths:
+            # relative to the root directory
+            - fabric/build/libs
+            - forge/build/libs
+        exclude:
+            - fabric/build/libs/*-dev.jar
+            - fabric/build/libs/*-dev-shadow.jar
+            - fabric/build/libs/*-sources-dev.jar
+            - fabric/build/libs/*-sources.jar
+            - forge/build/libs/*-dev.jar
+            - forge/build/libs/*-dev-shadow.jar
+            - forge/build/libs/*-sources-dev.jar
+            - forge/build/libs/*-sources.jar
+        reports:
+            # To ensure we've access to these files in the next stage
+            dotenv: generate_jars.env
+        expire_in: 1 day
+
+# third stage
+merge:
+    stage: merge
+    script: ./gradlew merge --gradle-user-home cache/
+    # build using Java 17
+    image: eclipse-temurin:17
+    cache:
+        key: "$CI_COMMIT_REF_NAME"
+        policy: pull-push
+        paths:
+            - build
+            - .gradle
+            - cache/
+    artifacts:
+        name: "Merged_NightlyBuild-${CI_COMMIT_SHORT_SHA}-${CI_COMMIT_TIMESTAMP}"
+        paths:
+            # relative to the root directory
+            - Merged
+        expire_in: 1 day
+
+
+## forth stage
+#deploy:
+#    stage: deploy
+#    image: registry.gitlab.com/gitlab-org/release-cli:latest
+#    script:
+#        - echo 'running release_job'
+#        - echo 'Previous Job ID is printed below'
+#        - echo $GE_JOB_ID
+#    # Specifying that this job requires artifacts from the previous job to succeed
+#    needs:
+#        - job: build
+#          artifacts: true
+#    release:
+#        name: 'Unstable Jars for Latest Commit' #: $CI_COMMIT_SHORT_SHA'
+#        description: 'Created automatically using the release-cli.'
+#        # tag_name is a mendatory field and can not be an empty string
+#        tag_name: 'Unstable-$CI_COMMIT_SHORT_SHA'
+#        assets:
+#            links:
+#                - name: 'Fabric Jars'
+#                  url: 'https://gitlab.com/jeseibel/minecraft-lod-mod/cw/-/jobs/${GE_JOB_ID}/artifacts/file/fabric/build/libs'
+#                - name: 'Forge Jars'
+#                  url: 'https://gitlab.com/jeseibel/minecraft-lod-mod/cw/-/jobs/${GE_JOB_ID}/artifacts/file/forge/build/libs'

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "core"]
+	path = core
+	url = https://gitlab.com/jeseibel/distant-horizons-core.git

CREDITS.txt

@@ -1,65 +0,0 @@
-Minecraft Forge: Credits/Thank You
-
-Forge is a set of tools and modifications to the Minecraft base game code to assist 
-mod developers in creating new and exciting content. It has been in development for 
-several years now, but I would like to take this time thank a few people who have 
-helped it along it's way.
-
-First, the people who originally created the Forge projects way back in Minecraft 
-alpha. Eloraam of RedPower, and SpaceToad of Buildcraft, without their acceptiance 
-of me taking over the project, who knows what Minecraft modding would be today.
-
-Secondly, someone who has worked with me, and developed some of the core features
-that allow modding to be as functional, and as simple as it is, cpw. For developing
-FML, which stabelized the client and server modding ecosystem. As well as the base
-loading system that allows us to modify Minecraft's code as elegently as possible.
-
-Mezz, who has stepped up as the issue and pull request manager. Helping to keep me
-sane as well as guiding the community into creating better additions to Forge.
-
-Searge, Bspks, Fesh0r, ProfMobious, and all the rest over on the MCP team {of which 
-I am a part}. For creating some of the core tools needed to make Minecraft modding 
-both possible, and as stable as can be.
-  On that note, here is some specific information of the MCP data we use:
-    * Minecraft Coder Pack (MCP) *
-      Forge Mod Loader and Minecraft Forge have permission to distribute and automatically 
-      download components of MCP and distribute MCP data files. This permission is not 
-      transitive and others wishing to redistribute the Minecraft Forge source independently
-      should seek permission of MCP or remove the MCP data files and request their users 
-      to download MCP separately.
-      
-And lastly, the countless community members who have spent time submitting bug reports, 
-pull requests, and just helping out the community in general. Thank you.
-
---LexManos
-
-=========================================================================
-
-This is Forge Mod Loader.
-
-You can find the source code at all times at https://github.com/MinecraftForge/MinecraftForge/tree/1.12.x/src/main/java/net/minecraftforge/fml
-
-This minecraft mod is a clean open source implementation of a mod loader for minecraft servers
-and minecraft clients.
-
-The code is authored by cpw.
-
-It began by partially implementing an API defined by the client side ModLoader, authored by Risugami.
-http://www.minecraftforum.net/topic/75440-
-This support has been dropped as of Minecraft release 1.7, as Risugami no longer maintains ModLoader.
-
-It also contains suggestions and hints and generous helpings of code from LexManos, author of MinecraftForge.
-http://www.minecraftforge.net/
-
-Additionally, it contains an implementation of topological sort based on that 
-published at http://keithschwarz.com/interesting/code/?dir=topological-sort
-
-It also contains code from the Maven project for performing versioned dependency
-resolution. http://maven.apache.org/
-
-It also contains a partial repackaging of the javaxdelta library from http://sourceforge.net/projects/javaxdelta/
-with credit to it's authors.
-
-Forge Mod Loader downloads components from the Minecraft Coder Pack
-(http://mcp.ocean-labs.de/index.php/Main_Page) with kind permission from the MCP team.
-

Readme.md

@@ -0,0 +1,86 @@
+# Distant Horizons
+
+This mod adds a Level Of Detail (LOD) system to Minecraft.\
+This implementation renders simplified chunks outside the normal render distance\
+allowing for an increased view distance without harming performance.
+
+Or in other words: this mod lets you see farther without turning your game into a slide show.\
+If you want to see a quick demo, check out a video covering the mod here:
+
+<a href="https://www.youtube.com/watch?v=H2tnvEVbO1c" target="_blank">![Minecraft Level Of Detail (LOD) mod - Alpha 1.5](https://i.ytimg.com/vi_webp/H2tnvEVbO1c/mqdefault.webp)</a>
+
+Architectury version: 3.4-SNAPSHOT\
+Forge version: 37.1.0\
+Fabric version: 0.12.6\
+Fabric API version: 0.37.1+1.17
+
+Modmenu version: 2.0.14\
+Sodium version: mc1.17.1-0.3.3
+
+Notes:\
+This version has been confirmed to work in Eclipse and Retail Minecraft.\
+(Retail running forge version 1.17.1-37.1.0 and fabric version 1.17.1-0.12.6)
+
+
+## source code installation
+
+See the Forge Documentation online for more detailed instructions:\
+http://mcforge.readthedocs.io/en/latest/gettingstarted/
+
+### Prerequisites
+
+* A Java Development Kit (JDK) for Java 16 (recommended) or newer. Visit https://www.oracle.com/java/technologies/downloads/ for installers.
+* Git or someway to clone git projects. Visit https://git-scm.com/ for installers.
+* (Not required) Any Java IDE, for example Intellij IDEA and Eclipse. You may also use any other code editors, such as Visual Studio Code. (Optional)
+  It's better to use IntelliJ IDEA since Eclipse is not supported by Architectury, but it still works.
+
+**If using IntelliJ:**
+1. open IDEA and import the build.gradle
+2. refresh the Gradle project in IDEA if required
+
+**If using Ecplise:**
+Not supported...
+
+Side note: invalidate caches and restart if required
+
+## Compiling
+
+**Using GUI**
+1. Open a command line in the project folder
+2. Run the command: `./gradlew build`
+3. The compiled jar file will be in the folder `fabric/build/libs/` and `forge/build/libs/`
+
+**If in terminal:**
+1. `git clone -b 1.17.1 --recurse-submodules https://gitlab.com/jeseibel/minecraft-lod-mod.git`
+2. `cd minecraft-lod-mod`
+3. `./gradlew assemble` or `./gradlew build`
+4. The build should be in `fabric/build/libs/` and `forge/build/libs/`
+
+
+## Other commands
+
+`./gradlew --refresh-dependencies` to refresh local dependencies.
+
+`./gradlew clean` to reset everything (this does not affect your code) and then start the process again.
+
+
+## Note to self
+
+The Minecraft source code is NOT added to your workspace in an editable way. Minecraft is treated like a normal Library. Sources are there for documentation and research purposes only.
+
+Source code uses Mojang mappings.
+
+## Useful commands
+
+Build only Fabric: `./gradlew fabric:assemble` or `./gradlew fabric:build`\
+Build only Forge: `./gradlew fabric:assemble` or `./gradlew forge:build`\
+Run the Fabric client (for debugging): `./gradlew fabric:runClient`\
+Run the Forge client (for debugging): `./gradlew forge:runClient`
+
+## Open Source Acknowledgements
+
+XZ for Java (data compression)\
+https://tukaani.org/xz/java.html
+
+DHJarMerger (To merge multiple mod versions into one jar)\
+https://github.com/Ran-helo/DHJarMerger

Readme.txt

@@ -1,65 +0,0 @@
-This mod adds a Level Of Detail (LOD) system to Minecraft.
-This implementation renders simplified chunks outside the normal render distance
-allowing for an increased view distance without harming performance.
-
-
-Forge version: 1.16.4-35.1.4
-
-Notes:
-This version has been confirmed to work in Eclipse and retail Minecraft.
-(retail running forge 1.16.4-35.1.37)
-That being said only singleplayer is currently supported; connecting
-to servers (local or otherwise) will cause no LODs to be drawn and
-may cause instibility.
-
-
-========================
-source code installation
-========================
-
-See the Forge Documentation online for more detailed instructions:
-http://mcforge.readthedocs.io/en/latest/gettingstarted/
-
-Step 1: Create a system variable called "JAVA_MC_HOME" with the location of the JDK 1.8.0_251 (This is needed for gradle to work correctly)
-
-Step 2: replace JAVA_HOME with JAVA_MC_HOME in gradle.bat
-
-Step 3: open a command line in the project folder
-
-Step 4: run the command: "./gradlew geneclipseruns"
-
-Step 5: run the command: "./gradlew eclipse"
-
-Step 6: Make sure the eclipse has the JDK 1.8.0_251 installed. (This is needed so that eclipse can run minecraft)
-
-Step 7: Import the project into eclipse
-
-
-
-=========
-compiling
-=========
-
-Step 1: open a command line in the project folder
-
-Step 2: run the command: "./gradlew build"
-
-Step 3: the compiled jar file will be in the folder "build\libs"
-
-
-
-==============
-Other commands
-==============
-
-"./gradlew --refresh-dependencies" to refresh local dependencies. 
-"./gradlew clean" to reset everything (this does not affect your code) and then start the process again.
-
-
-
-============
-Note to self
-============
-
-The Minecraft source code is NOT added to your workspace in a editable way. Minecraft is treated like a normal Library. Sources are there for documentation and research purposes only.
-

build.gradle

@@ -1,160 +1,109 @@
+import io.github.ran.jarmerger.JarMergerPlugin
+
 buildscript {
-    repositories {
-        maven { url = 'https://files.minecraftforge.net/maven' }
-        jcenter()
-        mavenCentral()
-		maven { url='https://dist.creeper.host/Sponge/maven' }
+    dependencies{
+        classpath files('plugins/DHJarMerger-1.0.jar')
     }
+}
+
+plugins {
+    id "architectury-plugin" version "3.4-SNAPSHOT"
+    id "dev.architectury.loom" version "0.10.0.195" apply false
+}
+
+apply plugin: JarMergerPlugin
+
+architectury {
+    minecraft = rootProject.minecraft_version
+}
+
+subprojects { p ->
+    apply plugin: "dev.architectury.loom"
+
+    loom {
+        silentMojangMappingsLicense()
+    }
+
+    configurations {
+        common
+        shadowMe
+        implementation.extendsFrom shadowMe
+    }
+
     dependencies {
-        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.+', changing: true
-		classpath group: 'org.spongepowered', name: 'mixingradle', version: '0.7-SNAPSHOT'
-    }
-}
-apply plugin: 'net.minecraftforge.gradle'
-apply plugin: 'org.spongepowered.mixin'
-// Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
-apply plugin: 'eclipse'
-apply plugin: 'maven-publish'
+        minecraft "com.mojang:minecraft:${rootProject.minecraft_version}"
+        // The following line declares the mojmap mappings
+        mappings loom.officialMojangMappings()
 
-version = 'a1'
-group = 'com.backsun.lod'
-archivesBaseName = 'lod_1.16.4'
+        // Toml
+        implementation("com.electronwill.night-config:toml:${rootProject.toml_version}")
 
-sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
-
-println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
-minecraft {
-    // The mappings can be changed at any time, and must be in the following format.
-    // snapshot_YYYYMMDD   Snapshot are built nightly.
-    // stable_#            Stables are built at the discretion of the MCP team.
-    // Use non-default mappings at your own risk. they may not always work.
-    // Simply re-run your setup task after changing the mappings to update your workspace.
-    mappings channel: 'snapshot', version: '20201028-1.16.3'
-
-    // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
-    
-    accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
-
-    // Default run configurations.
-    // These can be tweaked, removed, or duplicated as needed.
-    runs {
-        client {
-            workingDirectory project.file('run')
-			arg "-mixin.config=lod.mixins.json"
-
-            // Recommended logging data for a userdev environment
-            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
-
-            // Recommended logging level for the console
-            property 'forge.logging.console.level', 'debug'
-
-            mods {
-                examplemod {
-                    source sourceSets.main
-                }
-            }
+        if (p != project(":forge")) {
+            // We depend on fabric loader here to use the fabric @Environment annotations and get the mixin dependencies
+            // Do NOT use other classes from fabric loader unless working with fabric
+            modImplementation "net.fabricmc:fabric-loader:${rootProject.fabric_loader_version}"
         }
 
-        server {
-            workingDirectory project.file('run')
-			arg "-mixin.config=lod.mixins.json"
-			
-            // Recommended logging data for a userdev environment
-            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
 
-            // Recommended logging level for the console
-            property 'forge.logging.console.level', 'debug'
-
-            mods {
-                examplemod {
-                    source sourceSets.main
-                }
-            }
-        }
-
-        data {
-            workingDirectory project.file('run')
-
-            // Recommended logging data for a userdev environment
-            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
-
-            // Recommended logging level for the console
-            property 'forge.logging.console.level', 'debug'
-
-            // Specify the modid for data generation, where to output the resulting resource, and where to look for existing resources.
-            args '--mod', 'lod', '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
-
-            mods {
-                examplemod {
-                    source sourceSets.main
-                }
-            }
+        if (p != project(":core")) {
+            common(project(":core")) { transitive false }
+            shadowMe(project(":core")) { transitive false }
         }
     }
 }
 
-// Include resources generated by data generators.
-sourceSets.main.resources { srcDir 'src/generated/resources' }
+allprojects {
+    apply plugin: "java"
+    apply plugin: "architectury-plugin"
+    apply plugin: "maven-publish"
 
-dependencies {
-    // Specify the version of Minecraft to use, If this is any group other then 'net.minecraft' it is assumed
-    // that the dep is a ForgeGradle 'patcher' dependency. And it's patches will be applied.
-    // The userdev artifact is a special name and will get all sorts of transformations applied to it.
-    minecraft 'net.minecraftforge:forge:1.16.4-35.1.4'
+    archivesBaseName = rootProject.archives_base_name
+    version = rootProject.mod_version
+    group = rootProject.maven_group
 
-    // You may put jars on which you depend on in ./libs or you may define them like so..
-    // compile "some.group:artifact:version:classifier"
-    // compile "some.group:artifact:version"
-
-    // Real examples
-    // compile 'com.mod-buildcraft:buildcraft:6.0.8:dev'  // adds buildcraft to the dev env
-    // compile 'com.googlecode.efficient-java-matrix-library:ejml:0.24' // adds ejml to the dev env
-
-    // The 'provided' configuration is for optional dependencies that exist at compile-time but might not at runtime.
-    // provided 'com.mod-buildcraft:buildcraft:6.0.8:dev'
-
-    // These dependencies get remapped to your current MCP mappings
-    // deobf 'com.mod-buildcraft:buildcraft:6.0.8:dev'
-
-    // For more info...
-    // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html
-    // http://www.gradle.org/docs/current/userguide/dependency_management.html
-
-}
-
-// Example for how to get properties into the manifest for reading by the runtime..
-jar {
-    manifest {
-        attributes([
-            "Specification-Title": "Levels of Detail",
-            "Specification-Version": "1", // We are version 1 of ourselves
-            "Implementation-Title": project.name,
-            "Implementation-Version": "1.0",
-            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
-			"MixinConfigs": "lod.mixins.json",
-        ])
-    }
-}
-
-// Example configuration to allow publishing using the maven-publish task
-// This is the preferred method to reobfuscate your jar file
-jar.finalizedBy('reobfJar') 
-// However if you are in a multi-project build, dev time needs unobfed jar files, so you can delay the obfuscation until publishing by doing
-//publish.dependsOn('reobfJar')
-
-publishing {
-    publications {
-        mavenJava(MavenPublication) {
-            artifact jar
-        }
-    }
     repositories {
+        mavenCentral()
+        // used to download and compile dependencies from git repos
+        maven { url 'https://jitpack.io' }
+
+        // Required for importing Modrinth mods
         maven {
-            url "file:///${project.projectDir}/mcmodsrepo"
+            name = "Modrinth"
+            url = "https://api.modrinth.com/maven"
+            content {
+                includeGroup "maven.modrinth"
+            }
+        }
+
+        // Required for importing CursedForge mods
+        maven {
+            url "https://www.cursemaven.com"
+            content {
+                includeGroup "curse.maven"
+            }
+        }
+
+        // These 2 are for importing mods that arnt on CursedForge, Modrinth, GitHub, GitLab or anywhere opensource
+        flatDir {
+            dirs "${rootDir}/mods/fabric"
+            content {
+                includeGroup "fabric-mod"
+            }
+        }
+        flatDir {
+            dirs "${rootDir}/mods/forge"
+            content {
+                includeGroup "forge-mod"
+            }
         }
     }
-}
 
-mixin {
-    add sourceSets.main, "lod.refmap.json"
+    tasks.withType(JavaCompile) {
+        options.encoding = "UTF-8"
+        options.release = 16
+    }
+
+    java {
+        withSourcesJar()
+    }
 }

common/build.gradle

@@ -0,0 +1,29 @@
+loom {
+    accessWidenerPath.set(file("src/main/resources/lod.accesswidener"))
+}
+
+architectury {
+    common()
+}
+
+afterEvaluate {
+    tasks {
+        remapJar {
+            remapAccessWidener.set(false)
+        }
+    }
+}
+
+publishing {
+    publications {
+        mavenCommon(MavenPublication) {
+            artifactId = rootProject.archives_base_name
+            from components.java
+        }
+    }
+
+    // See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
+    repositories {
+        // Add repositories to publish to here.
+    }
+}

common/src/main/java/com/seibel/lod/common/Config.java

@@ -0,0 +1,276 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common;
+
+import com.seibel.lod.common.wrappers.config.ConfigGui;
+import com.seibel.lod.core.config.*;
+import com.seibel.lod.core.enums.config.*;
+import com.seibel.lod.core.enums.rendering.*;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton.IClient.IAdvanced.*;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton.IClient.IGraphics.*;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton.IClient.IWorldGenerator;
+
+/**
+ * This handles any configuration the user has access to.
+ * @author coolGi2007
+ * @version 12-12-2021
+ */
+public class Config extends ConfigGui
+//public class Config extends TinyConfig
+{
+	// CONFIG STRUCTURE
+	// 	-> Client
+	//		|
+	//		|-> Graphics
+	//		|		|-> Quality
+	//		|		|-> FogQuality
+	//		|		|-> AdvancedGraphics
+	//		|
+	//		|-> World Generation
+	//		|
+	//		|-> Advanced
+	//				|-> Threads
+	//				|-> Buffers
+	//				|-> Debugging
+
+	// Since the original config system uses forge stuff, that means we have to rewrite the whole config system
+
+	@ConfigAnnotations.ScreenEntry
+	public static Client client;
+
+	@ConfigAnnotations.FileComment
+	public static String _optionsButton = ILodConfigWrapperSingleton.IClient.OPTIONS_BUTTON_DESC;
+	// I know this option should be in Client
+	// This is a hacky method to not show the button in the options screen but show it in the mod menu
+	// Tough it is in client in the wrapper singleton
+	@ConfigAnnotations.Entry
+	public static boolean optionsButton = true;
+
+	public static class Client
+	{
+		@ConfigAnnotations.ScreenEntry
+		public static Graphics graphics;
+
+		@ConfigAnnotations.ScreenEntry
+		public static WorldGenerator worldGenerator;
+
+		@ConfigAnnotations.ScreenEntry
+		public static Advanced advanced;
+
+
+		public static class Graphics
+		{
+			@ConfigAnnotations.ScreenEntry
+			public static Quality quality;
+
+			@ConfigAnnotations.ScreenEntry
+			public static FogQuality fogQuality;
+
+			@ConfigAnnotations.ScreenEntry
+			public static AdvancedGraphics advancedGraphics;
+
+
+			public static class Quality
+			{
+				@ConfigAnnotations.FileComment
+				public static String _drawResolution = IQuality.DRAW_RESOLUTION_DESC;
+				@ConfigAnnotations.Entry
+				public static HorizontalResolution drawResolution = IQuality.DRAW_RESOLUTION_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _lodChunkRenderDistance = IQuality.LOD_CHUNK_RENDER_DISTANCE_DESC;
+				@ConfigAnnotations.Entry(minValue = 16, maxValue = 2048)
+				public static int lodChunkRenderDistance = IQuality.LOD_CHUNK_RENDER_DISTANCE_MIN_DEFAULT_MAX.defaultValue;
+
+				@ConfigAnnotations.FileComment
+				public static String _verticalQuality = IQuality.VERTICAL_QUALITY_DESC;
+				@ConfigAnnotations.Entry
+				public static VerticalQuality verticalQuality = IQuality.VERTICAL_QUALITY_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _horizontalScale = IQuality.HORIZONTAL_SCALE_DESC;
+				@ConfigAnnotations.Entry(minValue = 2, maxValue = 32)
+				public static int horizontalScale = IQuality.HORIZONTAL_SCALE_MIN_DEFAULT_MAX.defaultValue;
+
+				@ConfigAnnotations.FileComment
+				public static String _horizontalQuality = IQuality.HORIZONTAL_SCALE_DESC;
+				@ConfigAnnotations.Entry
+				public static HorizontalQuality horizontalQuality = IQuality.HORIZONTAL_QUALITY_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _dropoffQuality = IQuality.DROPOFF_QUALITY_DESC;
+				@ConfigAnnotations.Entry
+				public static DropoffQuality dropoffQuality = IQuality.DROPOFF_QUALITY_DEFAULT;
+			}
+
+
+			public static class FogQuality
+			{
+				@ConfigAnnotations.FileComment
+				public static String _fogDistance = IFogQuality.FOG_DISTANCE_DESC;
+				@ConfigAnnotations.Entry
+				public static FogDistance fogDistance = IFogQuality.FOG_DISTANCE_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _fogDrawMode = IFogQuality.FOG_DRAW_MODE_DESC;
+				@ConfigAnnotations.Entry
+				public static FogDrawMode fogDrawMode = IFogQuality.FOG_DRAW_MODE_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _fogColorMode = IFogQuality.FOG_COLOR_MODE_DESC;
+				@ConfigAnnotations.Entry
+				public static FogColorMode fogColorMode = IFogQuality.FOG_COLOR_MODE_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _disableVanillaFog = IFogQuality.DISABLE_VANILLA_FOG_DESC;
+				@ConfigAnnotations.Entry
+				public static boolean disableVanillaFog = IFogQuality.DISABLE_VANILLA_FOG_DEFAULT;
+			}
+
+			
+			public static class AdvancedGraphics
+			{
+				@ConfigAnnotations.FileComment
+				public static String _disableDirectionalCulling = IAdvancedGraphics.DISABLE_DIRECTIONAL_CULLING_DESC;
+				@ConfigAnnotations.Entry
+				public static boolean disableDirectionalCulling = IAdvancedGraphics.DISABLE_DIRECTIONAL_CULLING_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _vanillaOverdraw = IAdvancedGraphics.VANILLA_OVERDRAW_DESC;
+				@ConfigAnnotations.Entry
+				public static VanillaOverdraw vanillaOverdraw = IAdvancedGraphics.VANILLA_OVERDRAW_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _useExtendedNearClipPlane = IAdvancedGraphics.USE_EXTENDED_NEAR_CLIP_PLANE_DESC;
+				@ConfigAnnotations.Entry
+				public static boolean useExtendedNearClipPlane = IAdvancedGraphics.USE_EXTENDED_NEAR_CLIP_PLANE_DEFAULT;
+
+				/*
+				@ConfigAnnotations.FileComment
+				public static String _backsideCullingRange = IAdvancedGraphics.VANILLA_CULLING_RANGE_DESC;
+				@ConfigAnnotations.Entry(minValue = 0, maxValue = 512)
+				public static int backsideCullingRange = IAdvancedGraphics.VANILLA_CULLING_RANGE_MIN_DEFAULT_MAX.defaultValue;
+				*/
+			}
+		}
+
+
+		public static class WorldGenerator
+		{
+			@ConfigAnnotations.FileComment
+			public static String _enableDistantGeneration = IWorldGenerator.ENABLE_DISTANT_GENERATION_DESC;
+			@ConfigAnnotations.Entry
+			public static boolean enableDistantGeneration = IWorldGenerator.ENABLE_DISTANT_GENERATION_DEFAULT;
+
+//			@ConfigAnnotations.FileComment
+//			public static String _distanceGenerationMode = IWorldGenerator.getDistanceGenerationModeDesc();
+			@ConfigAnnotations.Entry
+			public static DistanceGenerationMode distanceGenerationMode = IWorldGenerator.DISTANCE_GENERATION_MODE_DEFAULT;
+			
+			@ConfigAnnotations.FileComment
+			public static String _lightGenerationMode = IWorldGenerator.LIGHT_GENERATION_MODE_DESC;
+			@ConfigAnnotations.Entry
+			public static LightGenerationMode lightGenerationMode = IWorldGenerator.LIGHT_GENERATION_MODE_DEFAULT;
+			
+			@ConfigAnnotations.FileComment
+			public static String _generationPriority = IWorldGenerator.GENERATION_PRIORITY_DESC;
+			@ConfigAnnotations.Entry
+			public static GenerationPriority generationPriority = IWorldGenerator.GENERATION_PRIORITY_DEFAULT;
+
+			/*
+			@ConfigAnnotations.FileComment
+			public static String _allowUnstableFeatureGeneration = IWorldGenerator.ALLOW_UNSTABLE_FEATURE_GENERATION_DESC;
+			// FIXME: Temperary override. In 1.18, the newer Unstable gnerator is more usable
+			@ConfigAnnotations.Entry
+			public static boolean allowUnstableFeatureGeneration = true;//IWorldGenerator.ALLOW_UNSTABLE_FEATURE_GENERATION_DEFAULT;
+			*/
+			
+			@ConfigAnnotations.FileComment
+			public static String _blocksToAvoid = IWorldGenerator.BLOCKS_TO_AVOID_DESC;
+			@ConfigAnnotations.Entry
+			public static BlocksToAvoid blocksToAvoid = IWorldGenerator.BLOCKS_TO_AVOID_DEFAULT;
+		}
+
+		public static class Advanced
+		{
+			@ConfigAnnotations.ScreenEntry
+			public static Threading threading;
+
+			@ConfigAnnotations.ScreenEntry
+			public static Debugging debugging;
+
+			@ConfigAnnotations.ScreenEntry
+			public static Buffers buffers;
+
+
+			public static class Threading
+			{
+				@ConfigAnnotations.FileComment
+				public static String _numberOfWorldGenerationThreads = IThreading.NUMBER_OF_WORLD_GENERATION_THREADS_DESC;
+				@ConfigAnnotations.Entry(minValue = 1, maxValue = 50)
+				public static int numberOfWorldGenerationThreads = IThreading.NUMBER_OF_WORLD_GENERATION_THREADS_DEFAULT.defaultValue;
+
+				@ConfigAnnotations.FileComment
+				public static String _numberOfBufferBuilderThreads = IThreading.NUMBER_OF_BUFFER_BUILDER_THREADS_DESC;
+				@ConfigAnnotations.Entry(minValue = 1, maxValue = 50)
+				public static int numberOfBufferBuilderThreads = IThreading.NUMBER_OF_BUFFER_BUILDER_THREADS_MIN_DEFAULT_MAX.defaultValue;
+			}
+
+
+			public static class Debugging
+			{
+				@ConfigAnnotations.FileComment
+				public static String _drawLods = IDebugging.DRAW_LODS_DESC;
+				@ConfigAnnotations.Entry
+				public static boolean drawLods = IDebugging.DRAW_LODS_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _debugMode = IDebugging.DEBUG_MODE_DESC;
+				@ConfigAnnotations.Entry
+				public static DebugMode debugMode = IDebugging.DEBUG_MODE_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _enableDebugKeybindings = IDebugging.DEBUG_KEYBINDINGS_ENABLED_DESC;
+				@ConfigAnnotations.Entry
+				public static boolean enableDebugKeybindings = IDebugging.DEBUG_KEYBINDINGS_ENABLED_DEFAULT;
+			}
+
+
+			public static class Buffers
+			{
+				@ConfigAnnotations.FileComment
+				public static String _gpuUploadMethod = IBuffers.GPU_UPLOAD_METHOD_DESC;
+				@ConfigAnnotations.Entry
+				public static GpuUploadMethod gpuUploadMethod = IBuffers.GPU_UPLOAD_METHOD_DEFAULT;
+
+				@ConfigAnnotations.FileComment
+				public static String _gpuUploadPerMegabyteInMilliseconds = IBuffers.GPU_UPLOAD_PER_MEGABYTE_IN_MILLISECONDS_DESC;
+				@ConfigAnnotations.Entry(minValue = 0, maxValue = 5000)
+				public static int gpuUploadPerMegabyteInMilliseconds = IBuffers.GPU_UPLOAD_PER_MEGABYTE_IN_MILLISECONDS_DEFAULT.defaultValue;
+
+				@ConfigAnnotations.FileComment
+				public static String _rebuildTimes = IBuffers.REBUILD_TIMES_DESC;
+				@ConfigAnnotations.Entry
+				public static BufferRebuildTimes rebuildTimes = IBuffers.REBUILD_TIMES_DEFAULT;
+			}
+		}
+	}
+}

common/src/main/java/com/seibel/lod/common/LodCommonMain.java

@@ -0,0 +1,35 @@
+package com.seibel.lod.common;
+
+import com.seibel.lod.common.forge.LodForgeMethodCaller;
+import com.seibel.lod.common.networking.NetworkInterface;
+import com.seibel.lod.common.wrappers.DependencySetup;
+import com.seibel.lod.common.wrappers.config.ConfigGui;
+
+/**
+ * This is the common main class
+ * @author Ran
+ */
+public class LodCommonMain {
+    public static boolean forge = false;
+    public static boolean serverSided;
+    public static LodForgeMethodCaller forgeMethodCaller;
+    public static NetworkInterface networkInterface;
+
+    public static void startup(LodForgeMethodCaller caller, boolean serverSided) {
+        LodCommonMain.serverSided = serverSided;
+        if (caller != null) {
+            LodCommonMain.forge = true;
+            forgeMethodCaller = caller;
+        }
+
+        DependencySetup.createInitialBindings();
+    }
+
+    public static void initConfig() {
+        ConfigGui.init(Config.class);
+    }
+
+    public static void registerNetworking(NetworkInterface networkInterface) {
+        LodCommonMain.networkInterface = networkInterface;
+    }
+}

common/src/main/java/com/seibel/lod/common/forge/LodForgeMethodCaller.java

@@ -0,0 +1,21 @@
+package com.seibel.lod.common.forge;
+
+import com.seibel.lod.common.wrappers.minecraft.MinecraftWrapper;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+
+import java.util.List;
+import java.util.Random;
+
+/**
+ * used for calling methods that forge modified
+ * (forge modifies vanilla methods for some reason)
+ * @author Ran
+ */
+public interface LodForgeMethodCaller {
+    List<BakedQuad> getQuads(MinecraftWrapper mc, Block block, BlockState blockState, Direction direction, Random random);
+    int getPixelRGBA(TextureAtlasSprite sprite, int frameIndex, int x, int y);
+}

common/src/main/java/com/seibel/lod/common/networking/NetworkInterface.java

@@ -0,0 +1,12 @@
+package com.seibel.lod.common.networking;
+
+import net.minecraft.network.FriendlyByteBuf;
+
+/**
+ * @author Ran
+ */
+public interface NetworkInterface {
+    void send(FriendlyByteBuf packetByteBuf);
+
+    FriendlyByteBuf receive();
+}

common/src/main/java/com/seibel/lod/common/networking/Networking.java

@@ -0,0 +1,20 @@
+package com.seibel.lod.common.networking;
+
+import io.netty.buffer.Unpooled;
+import net.minecraft.network.FriendlyByteBuf;
+
+/**
+ * This class holds most of the networking code for the mod.
+ * @author Ran
+ */
+public class Networking {
+//    public void example(int packetId) {
+//        FriendlyByteBuf packetByteBuf = Networking.createNew();
+//        packetByteBuf.writeInt(packetId);
+//        LodCommonMain.networkInterface.send(packetByteBuf);
+//    }
+
+    public static FriendlyByteBuf createNew() {
+        return new FriendlyByteBuf(Unpooled.buffer());
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/DependencySetup.java

@@ -0,0 +1,37 @@
+package com.seibel.lod.common.wrappers;
+
+import com.seibel.lod.common.LodCommonMain;
+import com.seibel.lod.common.wrappers.block.BlockColorSingletonWrapper;
+import com.seibel.lod.common.wrappers.minecraft.MinecraftRenderWrapper;
+import com.seibel.lod.common.wrappers.minecraft.MinecraftWrapper;
+import com.seibel.lod.core.handlers.IReflectionHandler;
+import com.seibel.lod.core.handlers.ReflectionHandler;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.IVersionConstants;
+import com.seibel.lod.core.wrapperInterfaces.IWrapperFactory;
+import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorSingletonWrapper;
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftWrapper;
+
+/**
+ * Binds all necessary dependencies, so we
+ * can access them in Core. <br>
+ * This needs to be called before any Core classes
+ * are loaded.
+ *
+ * @author James Seibel
+ * @author Ran
+ * @version 12-1-2021
+ */
+public class DependencySetup {
+    public static void createInitialBindings() {
+        SingletonHandler.bind(IBlockColorSingletonWrapper.class, BlockColorSingletonWrapper.INSTANCE);
+        if (!LodCommonMain.serverSided) {
+            SingletonHandler.bind(IMinecraftWrapper.class, MinecraftWrapper.INSTANCE);
+            SingletonHandler.bind(IMinecraftRenderWrapper.class, MinecraftRenderWrapper.INSTANCE);
+            SingletonHandler.bind(IReflectionHandler.class, ReflectionHandler.createSingleton(MinecraftWrapper.INSTANCE.getOptions().getClass().getDeclaredFields(), MinecraftWrapper.INSTANCE.getOptions()));
+            SingletonHandler.bind(IVersionConstants.class, VersionConstants.INSTANCE);
+        }
+        SingletonHandler.bind(IWrapperFactory.class, WrapperFactory.INSTANCE);
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/McObjectConverter.java

@@ -0,0 +1,54 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers;
+
+import java.nio.FloatBuffer;
+
+import com.mojang.math.Matrix4f;
+import com.seibel.lod.core.enums.LodDirection;
+import com.seibel.lod.core.objects.math.Mat4f;
+
+import net.minecraft.core.Direction;
+
+/**
+ * This class converts to and from Minecraft objects (Ex: Matrix4f)
+ * and objects we created (Ex: Mat4f).
+ *
+ * @author James Seibel
+ * @version 11-20-2021
+ */
+public class McObjectConverter
+{
+    /** 4x4 float matrix converter */
+    public static Mat4f Convert(Matrix4f mcMatrix)
+    {
+        FloatBuffer buffer = FloatBuffer.allocate(16);
+        mcMatrix.store(buffer);
+        Mat4f matrix = new Mat4f(buffer);
+        matrix.transpose();
+        return matrix;
+    }
+
+
+    public static Direction Convert(LodDirection lodDirection)
+    {
+        return Direction.byName(lodDirection.name());
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/VersionConstants.java

@@ -0,0 +1,55 @@
+package com.seibel.lod.common.wrappers;
+
+import com.seibel.lod.core.enums.config.DistanceGenerationMode;
+import com.seibel.lod.core.wrapperInterfaces.IVersionConstants;
+
+/**
+ * @author James Seibel
+ * @version 12-11-2021
+ */
+public class VersionConstants implements IVersionConstants {
+    public static final VersionConstants INSTANCE = new VersionConstants();
+
+
+    private VersionConstants() {
+
+    }
+
+
+    @Override
+    public int getMinimumWorldHeight() {
+        return 0;
+    }
+
+    @Override
+    public boolean isWorldGeneratorSingleThreaded(DistanceGenerationMode distanceGenerationMode) {
+        // We are always asking the server to generate the chunk,
+        // so no use running this stuff multithreaded.
+        return true;
+        /*
+        switch (distanceGenerationMode) {
+            default:
+            case NONE:
+            case BIOME_ONLY:
+            case BIOME_ONLY_SIMULATE_HEIGHT:
+            case SURFACE:
+            case FEATURES:
+                return false;
+
+            case FULL:
+                return true;
+        }
+         */
+    }
+
+    @Override
+    public int getWorldGenerationCountPerThread() {
+        return 1;
+    }
+
+
+	@Override
+	public boolean hasBatchGenerationImplementation() {
+		return true;
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/WrapperFactory.java

@@ -0,0 +1,90 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers;
+
+import com.seibel.lod.core.builders.lodBuilding.LodBuilder;
+import com.seibel.lod.core.objects.lod.LodDimension;
+import com.seibel.lod.core.wrapperInterfaces.IWrapperFactory;
+import com.seibel.lod.core.wrapperInterfaces.block.AbstractBlockPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.world.IWorldWrapper;
+import com.seibel.lod.core.wrapperInterfaces.worldGeneration.AbstractBatchGenerationEnvionmentWrapper;
+import com.seibel.lod.core.wrapperInterfaces.worldGeneration.AbstractWorldGeneratorWrapper;
+import com.seibel.lod.common.wrappers.block.BlockPosWrapper;
+import com.seibel.lod.common.wrappers.chunk.ChunkPosWrapper;
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment;
+import com.seibel.lod.common.wrappers.worldGeneration.WorldGeneratorWrapper;
+
+/**
+ * This handles creating abstract wrapper objects.
+ *
+ * @author James Seibel
+ * @version 11-20-2021
+ */
+public class WrapperFactory implements IWrapperFactory {
+    public static final WrapperFactory INSTANCE = new WrapperFactory();
+
+
+    @Override
+    public AbstractBlockPosWrapper createBlockPos() {
+        return new BlockPosWrapper();
+    }
+
+    @Override
+    public AbstractBlockPosWrapper createBlockPos(int x, int y, int z) {
+        return new BlockPosWrapper(x, y, z);
+    }
+
+    @Override
+    public AbstractChunkPosWrapper createChunkPos() {
+        return new ChunkPosWrapper();
+    }
+
+    @Override
+    public AbstractChunkPosWrapper createChunkPos(long xAndZPositionCombined) {
+        return new ChunkPosWrapper(xAndZPositionCombined);
+    }
+
+    @Override
+    public AbstractChunkPosWrapper createChunkPos(int x, int z) {
+        return new ChunkPosWrapper(x, z);
+    }
+
+    @Override
+    public AbstractChunkPosWrapper createChunkPos(AbstractChunkPosWrapper newChunkPos) {
+        return new ChunkPosWrapper(newChunkPos);
+    }
+
+    @Override
+    public AbstractChunkPosWrapper createChunkPos(AbstractBlockPosWrapper blockPos) {
+        return new ChunkPosWrapper(blockPos);
+    }
+
+    @Override
+    public AbstractWorldGeneratorWrapper createWorldGenerator(LodBuilder newLodBuilder, LodDimension newLodDimension, IWorldWrapper worldWrapper) {
+        return new WorldGeneratorWrapper(newLodBuilder, newLodDimension, worldWrapper);
+    }
+    
+    @Override
+    public AbstractBatchGenerationEnvionmentWrapper createBatchGenerator(LodBuilder newLodBuilder,
+			LodDimension newLodDimension, IWorldWrapper worldWrapper) {
+		return new BatchGenerationEnvironment(worldWrapper, newLodBuilder, newLodDimension);
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/WrapperUtil.java

@@ -0,0 +1,34 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers;
+
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/**
+ * Stores any variables or code that
+ * may be shared between wrapper objects.
+ *
+ * @author James Seibel
+ * @version 11-20-2021
+ */
+public class WrapperUtil {
+    /** If we ever need to use a heightmap for any reason, use this one. */
+    public static final Heightmap.Types DEFAULT_HEIGHTMAP = Heightmap.Types.WORLD_SURFACE_WG;
+}

common/src/main/java/com/seibel/lod/common/wrappers/block/BlockColorSingletonWrapper.java

@@ -0,0 +1,46 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers.block;
+
+import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorSingletonWrapper;
+import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorWrapper;
+
+import net.minecraft.world.level.block.Blocks;
+
+
+/**
+ * Contains methods that would have been static in BlockColorWrapper.
+ * Since interfaces can't create/implement static methods we have
+ * to split the object up in two.
+ *
+ * @author James Seibel
+ * @version 11-17-2021
+ */
+public class BlockColorSingletonWrapper implements IBlockColorSingletonWrapper
+{
+    public static final BlockColorSingletonWrapper INSTANCE = new BlockColorSingletonWrapper();
+
+    @Override
+    public IBlockColorWrapper getWaterColor()
+    {
+        return BlockColorWrapper.getBlockColorWrapper(Blocks.WATER);
+    }
+}
+

common/src/main/java/com/seibel/lod/common/wrappers/block/BlockColorWrapper.java

@@ -0,0 +1,328 @@
+package com.seibel.lod.common.wrappers.block;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Random;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import com.seibel.lod.common.LodCommonMain;
+import com.seibel.lod.common.wrappers.minecraft.MinecraftWrapper;
+import com.seibel.lod.core.util.ColorUtil;
+import com.seibel.lod.core.wrapperInterfaces.block.AbstractBlockPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorWrapper;
+
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.BushBlock;
+import net.minecraft.world.level.block.FlowerBlock;
+import net.minecraft.world.level.block.GrassBlock;
+import net.minecraft.world.level.block.LeavesBlock;
+import net.minecraft.world.level.block.TallGrassBlock;
+import net.minecraft.world.level.block.state.BlockState;
+
+
+/**
+ * @author James Seibel
+ * @version 11-21-2021
+ */
+public class BlockColorWrapper implements IBlockColorWrapper
+{
+    //set of block which require tint
+    public static final ConcurrentMap<Block, BlockColorWrapper> blockColorWrapperMap = new ConcurrentHashMap<>();
+    //    public static final ModelDataMap dataMap = new ModelDataMap.Builder().build();
+    public static final AbstractBlockPosWrapper blockPos = new BlockPosWrapper(0, 0, 0);
+    public static final Random random = new Random(0);
+    //public static BlockColourWrapper WATER_COLOR = getBlockColorWrapper(Blocks.WATER);
+    public static final Direction[] directions = new Direction[] { Direction.UP, Direction.EAST, Direction.SOUTH, Direction.WEST, Direction.NORTH, Direction.DOWN };
+
+    private final Block block;
+    private int color;
+    private boolean isColored;
+    private boolean toTint;
+    private boolean foliageTint;
+    private boolean grassTint;
+    private boolean waterTint;
+
+
+    /**Constructor only require for the block instance we are wrapping**/
+    public BlockColorWrapper(Block block)
+    {
+        this.block = block;
+        this.color = 0;
+        this.isColored = true;
+        this.toTint = false;
+        this.foliageTint = false;
+        this.grassTint = false;
+        this.waterTint = false;
+        setupColorAndTint();
+		/*StringBuilder s = new StringBuilder();
+		s.append(block + "\n"
+								   + Integer.toHexString(
+				Minecraft.getInstance().getBlockColors().createDefault().getColor(
+						block.defaultBlockState(),
+						(World) MinecraftWrapper.INSTANCE.getWrappedServerLevel().getLevel(),
+						blockPosWrapper.getBlockPos())) + "\n"
+		);
+		for(Property x : Minecraft.getInstance().getBlockColors().getColoringProperties(block))
+			s.append(x.getName() + " " + x.getPossibleValues() + '\n');
+		System.out.println(s);*/
+        //System.out.println(block + " color " + Integer.toHexString(color) + " to tint " + toTint + " folliageTint " + folliageTint + " grassTint " + grassTint + " waterTint " + waterTint);
+    }
+
+
+    /**
+     * this return a wrapper of the block in input
+     * @param block object of the block to wrap
+     */
+    public static IBlockColorWrapper getBlockColorWrapper(Block block)
+    {
+        //first we check if the block has already been wrapped
+        if (blockColorWrapperMap.containsKey(block) && blockColorWrapperMap.get(block) != null)
+            return blockColorWrapperMap.get(block);
+
+
+        //if it hasn't been created yet, we create it and save it in the map
+        BlockColorWrapper blockWrapper = new BlockColorWrapper(block);
+        blockColorWrapperMap.put(block, blockWrapper);
+
+        //we return the newly created wrapper
+        return blockWrapper;
+    }
+
+    /**
+     * Generate the color of the given block from its texture
+     * and store it for later use.
+     */
+    private void setupColorAndTint()
+    {
+        BlockState blockState = block.defaultBlockState();
+        //BlockPosWrapper blockPosWrapper = new BlockPosWrapper();
+        MinecraftWrapper mc = MinecraftWrapper.INSTANCE;
+        TextureAtlasSprite texture;
+        List<BakedQuad> quads = null;
+
+        //boolean isTinted = false;
+        //int listSize = 0;
+
+        // first step is to check if this block has a tinted face
+        //for (Direction direction : directions)
+        //{
+        //    quads = mc.getModelManager().getBlockModelShaper().getBlockModel(block.defaultBlockState()).getQuads(blockState, direction, random);
+        //    listSize = Math.max(listSize, quads.size());
+        //    for (BakedQuad bakedQuad : quads)
+        //    {
+        //        isTinted |= bakedQuad.isTinted();
+        //    }
+        //}
+
+        //if it contains a tinted face then we store this block in the toTint set
+        //if (isTinted)
+        //    this.toTint = true;
+
+        //now we get the first non-empty face
+        for (Direction direction : directions)
+        {
+            quads = mc.getModelManager().getBlockModelShaper().getBlockModel(block.defaultBlockState()).getQuads(blockState, direction, random);
+            if (!quads.isEmpty())
+                break;
+        }
+
+        //the quads list is not empty we extract the first one
+        if (!quads.isEmpty())
+        {
+            isColored = true;
+            texture = quads.get(0).getSprite();
+        }
+        else
+        {
+            isColored = true;
+            texture = mc.getModelManager().getBlockModelShaper().getParticleIcon(block.defaultBlockState());
+        }
+
+        int count = 0;
+        int alpha = 0;
+        int red = 0;
+        int green = 0;
+        int blue = 0;
+        int numberOfGreyPixel = 0;
+        int tempColor;
+        int colorMultiplier;
+
+        // generate the block's color
+//        for (int frameIndex = 0; frameIndex < texture.getFrameCount(); frameIndex++)
+        boolean lookForTint = grassInstance() || leavesInstance() || waterIstance();
+    
+        int frameIndex = 0; // TODO
+        {
+            // textures normally use u and v instead of x and y
+            for (int u = 0; u < texture.getWidth(); u++)
+            {
+                for (int v = 0; v < texture.getHeight(); v++)
+                {
+                	//FIXME: Better way on the TextureAtlasSpriteWrapper!!!
+                    tempColor = LodCommonMain.forge ?
+                    		LodCommonMain.forgeMethodCaller.getPixelRGBA(texture, frameIndex, u, v)
+                    		: TextureAtlasSpriteWrapper.getPixelRGBA(texture, frameIndex, u, v);
+
+                    if (tempColor == 0)
+                        continue;
+
+                    if (lookForTint)
+                    {
+                        // determine if this pixel is gray
+                        int colorMax = Math.max(Math.max(ColorUtil.getBlue(tempColor), ColorUtil.getGreen(tempColor)), ColorUtil.getRed(tempColor));
+                        int colorMin = 4 + Math.min(Math.min(ColorUtil.getBlue(tempColor), ColorUtil.getGreen(tempColor)), ColorUtil.getRed(tempColor));
+                        boolean isGray = colorMax < colorMin;
+                        if (isGray)
+                            numberOfGreyPixel++;
+                    }
+
+
+                    // for flowers, weight their non-green color higher
+                    if (block instanceof FlowerBlock && (!(ColorUtil.getGreen(tempColor) > (ColorUtil.getBlue(tempColor) + 30)) || !(ColorUtil.getGreen(tempColor) > (ColorUtil.getRed(tempColor) + 30))))
+                        colorMultiplier = 5;
+                    else
+                        colorMultiplier = 1;
+
+
+                    // add to the running averages
+                    count += colorMultiplier;
+                    alpha += ColorUtil.getAlpha(tempColor) * colorMultiplier;
+                    red += ColorUtil.getBlue(tempColor) * colorMultiplier;
+                    green += ColorUtil.getGreen(tempColor) * colorMultiplier;
+                    blue += ColorUtil.getRed(tempColor) * colorMultiplier;
+                }
+            }
+        }
+
+
+        if (count == 0)
+            // this block is entirely transparent
+            tempColor = 0;
+        else
+        {
+            // determine the average color
+            alpha /= count;
+            red /= count;
+            green /= count;
+            blue /= count;
+            tempColor = ColorUtil.rgbToInt(alpha, red, green, blue);
+        }
+
+        // determine if this block should use the biome color tint
+        if (lookForTint && (float) numberOfGreyPixel / count > 0.75f)
+            this.toTint = true;
+
+        // we check which kind of tint we need to apply
+        this.grassTint = grassInstance() && toTint;
+
+        this.foliageTint = leavesInstance() && toTint;
+
+        this.waterTint = waterIstance() && toTint;
+
+        //hardcoded leaves
+        if (block == Blocks.SPRUCE_LEAVES)
+            color = ColorUtil.multiplyRGBcolors(tempColor, 0xFF619961);
+        else if (block == Blocks.BIRCH_LEAVES)
+            color = ColorUtil.multiplyRGBcolors(tempColor, 0xFF80A755);
+        else
+            color = tempColor;
+    }
+
+    /** determine if the given block should use the biome's grass color */
+    private boolean grassInstance()
+    {
+        return block instanceof GrassBlock
+                || block instanceof BushBlock
+//                || block instanceof IGrowable
+//                || block instanceof AbstractPlantBlock
+//                || block instanceof AbstractTopPlantBlock
+                || block instanceof TallGrassBlock;
+    }
+
+    /** determine if the given block should use the biome's foliage color */
+    private boolean leavesInstance()
+    {
+        return (block instanceof LeavesBlock && block != Blocks.SPRUCE_LEAVES && block != Blocks.BIRCH_LEAVES/* && block != Blocks.AZALEA_LEAVES && block != Blocks.FLOWERING_AZALEA_LEAVES*/)
+                || block == Blocks.VINE
+                || block == Blocks.SUGAR_CANE;
+    }
+
+    /** determine if the given block should use the biome's foliage color */
+    private boolean waterIstance()
+    {
+        return block == Blocks.WATER;
+    }
+
+    @Override
+    public String getName(){
+        return block.getName().toString();
+    }
+
+//--------------//
+//Colors getters//
+//--------------//
+
+    @Override
+    public boolean hasColor()
+    {
+        return isColored;
+    }
+
+    @Override
+    public int getColor()
+    {
+        return color;
+    }
+
+//------------//
+//Tint getters//
+//------------//
+
+
+    @Override
+    public boolean hasTint()
+    {
+        return toTint;
+    }
+
+    @Override
+    public boolean hasGrassTint()
+    {
+        return grassTint;
+    }
+
+    @Override
+    public boolean hasFolliageTint()
+    {
+        return foliageTint;
+    }
+
+    @Override
+    public boolean hasWaterTint()
+    {
+        return waterTint;
+    }
+
+
+
+
+    @Override public boolean equals(Object o)
+    {
+        if (this == o)
+            return true;
+        if (!(o instanceof BlockColorWrapper))
+            return false;
+        BlockColorWrapper that = (BlockColorWrapper) o;
+        return Objects.equals(block, that.block);
+    }
+
+    @Override public int hashCode()
+    {
+        return Objects.hash(block);
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/block/BlockPosWrapper.java

@@ -0,0 +1,84 @@
+package com.seibel.lod.common.wrappers.block;
+
+import java.util.Objects;
+
+import com.seibel.lod.core.enums.LodDirection;
+import com.seibel.lod.core.wrapperInterfaces.block.AbstractBlockPosWrapper;
+
+import net.minecraft.core.BlockPos;
+
+
+/**
+ * @author James Seibel
+ * @version 11-21-2021
+ */
+public class BlockPosWrapper extends AbstractBlockPosWrapper
+{
+    private BlockPos.MutableBlockPos blockPos;
+
+
+    public BlockPosWrapper()
+    {
+        this.blockPos = new BlockPos.MutableBlockPos(0,0,0);
+    }
+
+    public BlockPosWrapper(int x, int y, int z)
+    {
+        this.blockPos = new BlockPos.MutableBlockPos(x, y, z);
+    }
+
+
+
+    @Override
+    public void set(int x, int y, int z)
+    {
+        blockPos.set(x, y, z);
+    }
+
+    @Override
+    public int getX()
+    {
+        return blockPos.getX();
+    }
+
+    @Override
+    public int getY()
+    {
+        return blockPos.getY();
+    }
+
+    @Override
+    public int getZ()
+    {
+        return blockPos.getZ();
+    }
+
+    @Override
+    public int get(LodDirection.Axis axis)
+    {
+        return axis.choose(getX(), getY(), getZ());
+    }
+
+    public BlockPos.MutableBlockPos getBlockPos()
+    {
+        return blockPos;
+    }
+
+    @Override public boolean equals(Object o)
+    {
+        return blockPos.equals(o);
+    }
+
+    @Override public int hashCode()
+    {
+        return Objects.hash(blockPos);
+    }
+
+    @Override
+    public BlockPosWrapper offset(int x, int y, int z)
+    {
+        blockPos.set(blockPos.getX() + x, blockPos.getY() + y, blockPos.getZ() + z);
+        return this;
+    }
+
+}

common/src/main/java/com/seibel/lod/common/wrappers/block/BlockShapeWrapper.java

@@ -0,0 +1,158 @@
+
+package com.seibel.lod.common.wrappers.block;
+
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import com.seibel.lod.core.wrapperInterfaces.block.IBlockShapeWrapper;
+import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper;
+import com.seibel.lod.common.wrappers.chunk.ChunkWrapper;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+
+/**
+ * @author James Seibel
+ * @version 11-21-2021
+ */
+public class BlockShapeWrapper implements IBlockShapeWrapper
+{
+    //set of block which require tint
+    public static final ConcurrentMap<Block, BlockShapeWrapper> blockShapeWrapperMap = new ConcurrentHashMap<>();
+    public static BlockShapeWrapper WATER_SHAPE = new BlockShapeWrapper();
+
+    private final Block block;
+    private final boolean toAvoid;
+    private boolean nonFull;
+    private boolean noCollision;
+
+    /**Constructor only require for the block instance we are wrapping**/
+    public BlockShapeWrapper(Block block, IChunkWrapper chunkWrapper, int x, int y, int z)
+    {
+        this.block = block;
+        this.nonFull = false;
+        this.noCollision = false;
+        this.toAvoid = ofBlockToAvoid();
+        setupShapes(chunkWrapper, x, y, z);
+        //System.out.println(block + " non full " + nonFull + " no collision " + noCollision + " to avoid " + toAvoid);
+    }
+
+    private BlockShapeWrapper()
+    {
+        this.block = Blocks.WATER;
+        this.nonFull = false;
+        this.noCollision = false;
+        this.toAvoid = false;
+    }
+
+    /**
+     * this return a wrapper of the block in input
+     * @param block Block object to wrap
+     */
+    static public BlockShapeWrapper getBlockShapeWrapper(Block block, ChunkWrapper chunkWrapper, int x, int y, int z)
+    {
+        //first we check if the block has already been wrapped
+        if (blockShapeWrapperMap.containsKey(block) && blockShapeWrapperMap.get(block) != null)
+            return blockShapeWrapperMap.get(block);
+
+
+        //if it hasn't been created yet, we create it and save it in the map
+        BlockShapeWrapper blockWrapper = new BlockShapeWrapper(block, chunkWrapper, x, y, z);
+        blockShapeWrapperMap.put(block, blockWrapper);
+
+        //we return the newly created wrapper
+        return blockWrapper;
+    }
+
+    private void setupShapes(IChunkWrapper chunkWrapper, int x, int y, int z)
+    {
+        ChunkAccess chunk = ((ChunkWrapper) chunkWrapper).getChunk();
+        BlockPos blockPos = new BlockPos(x, y, z);
+        boolean noCollisionSetted = false;
+        boolean nonFullSetted = false;
+        if (!block.defaultBlockState().getFluidState().isEmpty())// || block instanceof SixWayBlock)
+        {
+            noCollisionSetted = true;
+            nonFullSetted = true;
+            noCollision = false;
+            nonFull = false;
+        }
+        if (!nonFullSetted)
+        {
+            VoxelShape voxelShape = block.defaultBlockState().getShape(chunk, blockPos);
+
+            if (!voxelShape.isEmpty())
+            {
+                AABB bbox = voxelShape.bounds();
+                double xWidth = (bbox.maxX - bbox.minX);
+                double yWidth = (bbox.maxY - bbox.minY);
+                double zWidth = (bbox.maxZ - bbox.minZ);
+                nonFull = xWidth < 1 && zWidth < 1 && yWidth < 1;
+            }
+            else
+            {
+                nonFull = false;
+            }
+        }
+
+        if (!noCollisionSetted)
+        {
+            VoxelShape collisionShape = block.defaultBlockState().getCollisionShape(chunk, blockPos);
+            noCollision = collisionShape.isEmpty();
+        }
+    }
+
+    @Override
+    public boolean ofBlockToAvoid()
+    {
+        return block.equals(Blocks.AIR)
+                || block.equals(Blocks.CAVE_AIR)
+                || block.equals(Blocks.BARRIER);
+    }
+//-----------------//
+//Avoidance getters//
+//-----------------//
+
+
+    @Override
+    public boolean isNonFull()
+    {
+        return nonFull;
+    }
+
+    @Override
+    public boolean hasNoCollision()
+    {
+        return noCollision;
+    }
+
+    @Override
+    public boolean isToAvoid()
+    {
+        return toAvoid;
+    }
+
+
+
+
+    @Override public boolean equals(Object o)
+    {
+        if (this == o)
+            return true;
+        if (!(o instanceof BlockShapeWrapper))
+            return false;
+        BlockShapeWrapper that = (BlockShapeWrapper) o;
+        return Objects.equals(block, that.block);
+    }
+
+    @Override public int hashCode()
+    {
+        return Objects.hash(block);
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/block/TextureAtlasSpriteWrapper.java

@@ -0,0 +1,28 @@
+package com.seibel.lod.common.wrappers.block;
+
+
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+
+/**
+ * For wrapping/utilizing around TextureAtlasSprite
+ * @author Ran
+ */
+public class TextureAtlasSpriteWrapper {
+
+    /**
+     * This code is from Minecraft Forge
+     * Which is licensed under the terms of GNU Lesser General Public License
+     * as published by the Free Software Foundation version 2.1
+     * of the License.
+     *
+     * The code has been modified to use TextureAtlasSprite
+     */
+    public static int getPixelRGBA(TextureAtlasSprite sprite, int frameIndex, int x, int y) {
+        if (sprite.animatedTexture != null) {
+            x += sprite.animatedTexture.getFrameX(frameIndex) * sprite.width;
+            y += sprite.animatedTexture.getFrameY(frameIndex) * sprite.height;
+        }
+
+        return sprite.mainImage[0].getPixelRGBA(x, y);
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/chunk/ChunkPosWrapper.java

@@ -0,0 +1,138 @@
+package com.seibel.lod.common.wrappers.chunk;
+
+import java.util.Objects;
+
+import com.seibel.lod.core.util.LevelPosUtil;
+import com.seibel.lod.core.util.LodUtil;
+import com.seibel.lod.core.wrapperInterfaces.block.AbstractBlockPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
+import com.seibel.lod.common.wrappers.block.BlockPosWrapper;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.ChunkPos;
+
+
+/**
+ * @author James Seibel
+ * @version 11-21-2021
+ */
+public class ChunkPosWrapper extends AbstractChunkPosWrapper
+{
+    private net.minecraft.world.level.ChunkPos chunkPos;
+
+    public ChunkPosWrapper()
+    {
+        this.chunkPos = new ChunkPos(0, 0);
+    }
+
+    public ChunkPosWrapper(BlockPos blockPos)
+    {
+        this.chunkPos = new ChunkPos(blockPos);
+    }
+
+    public ChunkPosWrapper(AbstractChunkPosWrapper newChunkPos)
+    {
+        this.chunkPos = ((ChunkPosWrapper) newChunkPos).chunkPos;
+    }
+
+    public ChunkPosWrapper(AbstractBlockPosWrapper blockPos)
+    {
+        this.chunkPos = new ChunkPos(((BlockPosWrapper) blockPos).getBlockPos());
+    }
+
+    public ChunkPosWrapper(int chunkX, int chunkZ)
+    {
+        this.chunkPos = new ChunkPos(chunkX, chunkZ);
+    }
+    
+    public ChunkPosWrapper(long l)
+    {
+        this.chunkPos = new ChunkPos(l);
+    }
+
+
+    public ChunkPosWrapper(ChunkPos pos)
+    {
+        this.chunkPos = pos;
+    }
+
+
+
+
+    @Override
+    public int getX()
+    {
+        return chunkPos.x;
+    }
+
+    @Override
+    public int getZ()
+    {
+        return chunkPos.z;
+    }
+
+    @Override
+    public int getMinBlockX()
+    {
+        return chunkPos.getMinBlockX();
+    }
+
+    @Override
+    public int getMinBlockZ()
+    {
+        return chunkPos.getMinBlockZ();
+    }
+
+    @Override
+    public int getRegionX()
+    {
+    	return LevelPosUtil.convert(LodUtil.CHUNK_DETAIL_LEVEL, chunkPos.x, LodUtil.REGION_DETAIL_LEVEL);
+    }
+
+    @Override
+    public int getRegionZ()
+    {
+    	return LevelPosUtil.convert(LodUtil.CHUNK_DETAIL_LEVEL, chunkPos.z, LodUtil.REGION_DETAIL_LEVEL);
+    }
+
+    public ChunkPos getChunkPos()
+    {
+        return chunkPos;
+    }
+    
+	@Override
+	public long getLong() {
+		return chunkPos.toLong();
+	}
+
+    @Override
+    public boolean equals(Object o)
+    {
+        // If the object is compared with itself then return true
+        if (o == this) {
+            return true;
+        }
+        // Check if o is an instance of RegionPos or not
+        if (!(o instanceof ChunkPosWrapper)) {
+            return false;
+        }
+        ChunkPosWrapper c = (ChunkPosWrapper) o;
+        return c.chunkPos.equals(chunkPos);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return Objects.hash(chunkPos);
+    }
+
+    @Override
+    public AbstractBlockPosWrapper getWorldPosition()
+    {
+        // the parameter here is the y position
+        BlockPos blockPos = chunkPos.getMiddleBlockPosition(0);
+        return new BlockPosWrapper(blockPos.getX(), blockPos.getY(), blockPos.getZ());
+    }
+
+
+}

common/src/main/java/com/seibel/lod/common/wrappers/chunk/ChunkWrapper.java

@@ -0,0 +1,178 @@
+package com.seibel.lod.common.wrappers.chunk;
+
+import com.seibel.lod.core.util.LevelPosUtil;
+import com.seibel.lod.core.util.LodUtil;
+import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorWrapper;
+import com.seibel.lod.core.wrapperInterfaces.block.IBlockShapeWrapper;
+import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper;
+import com.seibel.lod.core.wrapperInterfaces.world.IBiomeWrapper;
+import com.seibel.lod.common.wrappers.WrapperUtil;
+import com.seibel.lod.common.wrappers.block.BlockColorWrapper;
+import com.seibel.lod.common.wrappers.block.BlockShapeWrapper;
+import com.seibel.lod.common.wrappers.world.BiomeWrapper;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.QuartPos;
+import net.minecraft.world.level.BlockAndTintGetter;
+import net.minecraft.world.level.LightLayer;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.LiquidBlock;
+import net.minecraft.world.level.block.LiquidBlockContainer;
+import net.minecraft.world.level.block.SimpleWaterloggedBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.LevelChunkSection;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/**
+ *
+ * @author James Seibel
+ * @version 11-21-2021
+ */
+public class ChunkWrapper implements IChunkWrapper
+{
+    private ChunkAccess chunk;
+    private BlockAndTintGetter lightSource;
+
+    @Override
+    public int getHeight(){
+        return chunk.getHeight();
+    }
+
+    @Override
+    public int getMinBuildHeight()
+    {
+        return chunk.getMinBuildHeight();
+    }
+    @Override
+    public int getMaxBuildHeight()
+    {
+        return chunk.getMaxBuildHeight();
+    }
+
+    @Override
+    public int getHeightMapValue(int xRel, int zRel)
+    {
+        return chunk.getOrCreateHeightmapUnprimed(WrapperUtil.DEFAULT_HEIGHTMAP).getFirstAvailable(xRel, zRel);
+    }
+
+    @Override
+    public IBiomeWrapper getBiome(int x, int y, int z)
+    {
+        return BiomeWrapper.getBiomeWrapper(chunk.getBiomes().getNoiseBiome(
+                QuartPos.fromBlock(x), QuartPos.fromBlock(y), QuartPos.fromBlock(z)));
+    }
+
+    @Override
+    public IBlockColorWrapper getBlockColorWrapper(int x, int y, int z)
+    {
+        BlockState blockState = chunk.getBlockState(new BlockPos(x,y,z));
+        Block block = blockState.getBlock();
+        return BlockColorWrapper.getBlockColorWrapper(block);
+    }
+
+    @Override
+    public IBlockShapeWrapper getBlockShapeWrapper(int x, int y, int z)
+    {
+        BlockState blockState = chunk.getBlockState(new BlockPos(x,y,z));
+        Block block = blockState.getBlock();
+        return BlockShapeWrapper.getBlockShapeWrapper(block, this, x, y, z);
+    }
+
+    @Deprecated
+    public ChunkWrapper(ChunkAccess chunk)
+    {
+        this.chunk = chunk;
+        this.lightSource = null;
+    }
+    public ChunkWrapper(ChunkAccess chunk, BlockAndTintGetter lightSource)
+    {
+        this.chunk = chunk;
+        this.lightSource = lightSource;
+    }
+
+    public ChunkAccess getChunk() {
+        return chunk;
+    }
+
+    @Override
+    public int getChunkPosX(){
+        return chunk.getPos().x;
+    }
+
+    @Override
+    public int getChunkPosZ(){
+        return chunk.getPos().z;
+    }
+
+    @Override
+    public int getRegionPosX(){
+    	return LevelPosUtil.convert(LodUtil.CHUNK_DETAIL_LEVEL, getChunkPosX(), LodUtil.REGION_DETAIL_LEVEL);
+    }
+
+    @Override
+    public int getRegionPosZ(){
+    	return LevelPosUtil.convert(LodUtil.CHUNK_DETAIL_LEVEL, getChunkPosZ(), LodUtil.REGION_DETAIL_LEVEL);
+    }
+
+    @Override
+    public int getMaxY(int x, int z) {
+        return chunk.getHeight(Heightmap.Types.MOTION_BLOCKING, Math.floorMod(x, 16), Math.floorMod(z, 16));
+    }
+
+    @Override
+    public int getMaxX(){
+        return chunk.getPos().getMaxBlockX();
+    }
+    @Override
+    public int getMaxZ(){
+        return chunk.getPos().getMaxBlockZ();
+    }
+    @Override
+    public int getMinX(){
+        return chunk.getPos().getMinBlockX();
+    }
+    @Override
+    public int getMinZ() {
+        return chunk.getPos().getMinBlockZ();
+    }
+
+	@Override
+	public long getLongChunkPos() {
+		return chunk.getPos().toLong();
+	}
+
+    @Override
+    public boolean isLightCorrect(){
+    	return true;
+        //return chunk.isLightCorrect();
+    }
+
+    public boolean isWaterLogged(int x, int y, int z)
+    {
+        BlockState blockState = chunk.getBlockState(new BlockPos(x,y,z));
+
+        //This type of block is always in water
+        return (!(blockState.getBlock() instanceof LiquidBlockContainer) && (blockState.getBlock() instanceof SimpleWaterloggedBlock))
+                && (blockState.hasProperty(BlockStateProperties.WATERLOGGED) && blockState.getValue(BlockStateProperties.WATERLOGGED));
+    }
+
+    @Override
+    public int getEmittedBrightness(int x, int y, int z)
+    {
+        return chunk.getLightEmission(new BlockPos(x,y,z));
+    }
+
+    @Override
+    public int getBlockLight(int x, int y, int z) {
+        if (lightSource == null) return -1;
+        return lightSource.getBrightness(LightLayer.BLOCK, new BlockPos(x,y,z));
+    }
+
+    @Override
+    public int getSkyLight(int x, int y, int z) {
+        if (lightSource == null) return -1;
+        return lightSource.getBrightness(LightLayer.SKY, new BlockPos(x, y, z));
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/config/ConfigGui.java

@@ -0,0 +1,761 @@
+package com.seibel.lod.common.wrappers.config;
+
+import java.lang.reflect.Field;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+// Logger (for debug stuff)
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+// Uses https://github.com/TheElectronWill/night-config for toml (only for Fabric since Forge already includes this)
+
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+
+// Gets info from our own mod
+
+import com.seibel.lod.common.LodCommonMain;
+import com.seibel.lod.core.ModInfo;
+import com.seibel.lod.core.config.*;
+
+// Minecraft imports
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiComponent;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.ContainerObjectSelectionList;
+import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.CommonComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TextComponent;
+import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.client.resources.language.I18n;	// translation
+import net.minecraft.client.gui.narration.NarratableEntry; // Remove in 1.16
+
+/**
+ * Based upon TinyConfig
+ * https://github.com/Minenash/TinyConfig
+ *
+ * This config should work for both Fabric and Forge as long as you use Mojang mappings
+ *
+ * Credits to Motschen
+ *
+ * @author coolGi2007
+ * @version 1-14-2022
+ */
+@SuppressWarnings("unchecked")
+public abstract class ConfigGui
+{
+	/*
+	        TODO list
+
+		Fix floats not working
+        Make a wiki
+        Make it so you can enable and disable buttons from showing
+        Make min and max not final
+        Move the ConfigScreenConfigs class to the config class that extends this
+     */
+	/*
+		List of hacky things that are done that should be done properly
+
+		The buttons that don't show are still loaded but just not rendered
+		The screen with is set to double so the scroll bar doesn't show
+	 */
+
+
+	private static final Pattern INTEGER_ONLY_REGEX = Pattern.compile("(-?[0-9]*)");
+	private static final Pattern DECIMAL_ONLY_REGEX = Pattern.compile("-?([\\d]+\\.?[\\d]*|[\\d]*\\.?[\\d]+|\\.)");
+
+	private static final List<EntryInfo> entries = new ArrayList<>();
+	public static final Map<String,EntryInfo> entryMap = new HashMap<>();
+
+	// Change these to your own mod
+	private static final String MOD_NAME = ModInfo.NAME;					// For file saving and identifying
+	private static final String MOD_NAME_READABLE = ModInfo.READABLE_NAME;	// For logs
+	//	private static final Logger LOGGER = ClientApi.LOGGER;						// For logs
+	private static final Logger LOGGER = LogManager.getLogger(ModInfo.NAME);		// For logs (this inits before ClientAPI so this is a temp fix)
+
+
+
+
+	//==============//
+	// Initializers //
+	//==============//
+
+	private static class ConfigScreenConfigs
+	{
+		// This contains all the configs for the configs
+		public static final int SpaceFromRightScreen = 10;
+		public static final int ButtonWidthSpacing = 5;
+		public static final int ResetButtonWidth = 40;
+	}
+
+	public static class EntryInfo<T>
+	{
+		Field field;
+		Object widget;
+		int width = 0;
+		int max;
+		Map.Entry<EditBox, Component> error;
+		Object defaultValue;
+		Object value;
+		String tempValue;
+		boolean inLimits = true;
+		TranslatableComponent name;
+		int index;
+		/** Hides the button */
+		boolean hideOption = false;
+		/** This asks if it is a button to goto a new screen */
+		boolean screenButton = false;
+		/** This is only called if button is true */
+		String gotoScreen = "";
+		String category;
+		Class<T> varClass;
+
+
+		@Deprecated
+		boolean fileComment = false;
+	}
+
+	private static Path configFilePath;
+
+
+
+	public static void init(Class<?> config)
+	{
+		Minecraft mc =  Minecraft.getInstance();
+		configFilePath = mc.gameDirectory.toPath().resolve("config").resolve(MOD_NAME + ".toml");
+
+		initNestedClass(config, "");
+
+		for (EntryInfo info : entries) {
+			if (info.field.isAnnotationPresent(ConfigAnnotations.Entry.class)) {
+				try {
+					info.value = info.field.get(null);
+					info.tempValue = info.value.toString();
+				} catch (IllegalAccessException ignored) {
+				}
+			}
+		}
+
+		loadFromFile();
+	}
+
+	private static void initNestedClass(Class<?> config, String category)
+	{
+		for (Field field : config.getFields())
+		{
+			EntryInfo info = new EntryInfo();
+			if (field.isAnnotationPresent(ConfigAnnotations.Entry.class) || field.isAnnotationPresent(ConfigAnnotations.Comment.class) || field.isAnnotationPresent(ConfigAnnotations.ScreenEntry.class))
+			{
+				// If putting in your own mod then put your own check for server sided
+				info.category = category;
+				if (!LodCommonMain.serverSided)
+					initClient(field, info, category);
+			}
+
+			if (field.isAnnotationPresent(ConfigAnnotations.Entry.class))
+			{
+				entryMap.put((!category.isEmpty() ? category + "." : "") + field.getName(), info);
+				info.varClass = field.getType();
+				try
+				{
+					info.defaultValue = field.get(null);
+				}
+				catch (IllegalAccessException ignored) {}
+			}
+
+			if (field.isAnnotationPresent(ConfigAnnotations.ScreenEntry.class))
+				initNestedClass(field.getType(), (!category.isEmpty() ? category + "." : "") + field.getName());
+
+			// File comment (WILL BE REMOVED SOON)
+			if (field.isAnnotationPresent(ConfigAnnotations.FileComment.class)) {
+				entryMap.put((!category.isEmpty() ? category + "." : "") + field.getName(), info);
+				info.fileComment = true;
+				try
+				{
+					info.value = info.defaultValue = field.get(null);
+				}
+				catch (IllegalAccessException ignored) {}
+			}
+
+			info.field = field;
+		}
+	}
+
+	/** This adds the buttons to the queue to be rendered */
+	private static void initClient(Field field, EntryInfo info, String category)
+	{
+		Class<?> fieldClass = field.getType();
+		ConfigAnnotations.Entry entry = field.getAnnotation(ConfigAnnotations.Entry.class);
+		ConfigAnnotations.ScreenEntry screenEntry = field.getAnnotation(ConfigAnnotations.ScreenEntry.class);
+
+		if (entry != null)
+			info.width = entry.width();
+		else if (screenEntry != null)
+			info.width = screenEntry.width();
+
+		if (entry != null)
+		{
+			if (!entry.name().equals(""))
+				info.name = new TranslatableComponent(entry.name());
+
+
+			if (fieldClass == int.class)
+			{
+				// For int
+				textField(info, Integer::parseInt, INTEGER_ONLY_REGEX, entry.minValue(), entry.maxValue(), true);
+			}
+			else if (fieldClass == double.class)
+			{
+				// For double
+				textField(info, Double::parseDouble, DECIMAL_ONLY_REGEX, entry.minValue(), entry.maxValue(), false);
+			}
+			else if (fieldClass == String.class || fieldClass == List.class)
+			{
+				// For string or list
+				info.max = entry.maxValue() == Double.MAX_VALUE ? Integer.MAX_VALUE : (int) entry.maxValue();
+				textField(info, String::length, null, Math.min(entry.minValue(), 0), Math.max(entry.maxValue(), 1), true);
+			}
+			else if (fieldClass == boolean.class)
+			{
+				// For boolean
+				Function<Object, Component> func = value -> new TextComponent((Boolean) value ? "True" : "False").withStyle((Boolean) value ? ChatFormatting.GREEN : ChatFormatting.RED);
+				info.widget = new AbstractMap.SimpleEntry<Button.OnPress, Function<Object, Component>>(button -> {
+					info.value = !(Boolean) info.value;
+					button.setMessage(func.apply(info.value));
+				}, func);
+			}
+			else if (fieldClass.isEnum())
+			{
+				// For enum
+				List<?> values = Arrays.asList(field.getType().getEnumConstants());
+				Function<Object, Component> func = value -> new TranslatableComponent(MOD_NAME + ".config." + "enum." + fieldClass.getSimpleName() + "." + info.value.toString());
+				info.widget = new AbstractMap.SimpleEntry<Button.OnPress, Function<Object, Component>>(button -> {
+					int index = values.indexOf(info.value) + 1;
+					info.value = values.get(index >= values.size() ? 0 : index);
+					button.setMessage(func.apply(info.value));
+				}, func);
+			}
+		}
+		else if (screenEntry != null)
+		{
+			if (!screenEntry.name().equals(""))
+				info.name = new TranslatableComponent(screenEntry.name());
+
+			info.screenButton = true;
+			info.gotoScreen = (!info.category.isEmpty() ? info.category + "." : "") + field.getName();
+		}
+		entries.add(info);
+	}
+
+
+
+
+	/** creates a text field */
+	private static void textField(EntryInfo info, Function<String, Number> func, Pattern pattern, double minValue, double maxValue, boolean cast)
+	{
+		boolean isNumber = pattern != null;
+		info.widget = (BiFunction<EditBox, Button, Predicate<String>>) (editBox, button) -> stringValue ->
+		{
+			stringValue = stringValue.trim();
+			if (!(stringValue.isEmpty() || !isNumber || pattern.matcher(stringValue).matches()))
+				return false;
+
+			Number value = 0;
+			boolean inLimits = false;
+			info.error = null;
+			if (isNumber && !stringValue.isEmpty() && !stringValue.equals("-") && !stringValue.equals("."))
+			{
+				value = func.apply(stringValue);
+				inLimits = value.doubleValue() >= minValue && value.doubleValue() <= maxValue;
+				info.error = inLimits ? null : new AbstractMap.SimpleEntry<>(editBox, new TextComponent(value.doubleValue() < minValue ?
+						"§cMinimum " + "length" + (cast ? " is " + (int) minValue : " is " + minValue) :
+						"§cMaximum " + "length" + (cast ? " is " + (int) maxValue : " is " + maxValue)));
+			}
+
+			info.tempValue = stringValue;
+			editBox.setTextColor(inLimits ? 0xFFFFFFFF : 0xFFFF7777);
+			info.inLimits = inLimits;
+			button.active = entries.stream().allMatch(e -> e.inLimits);
+
+
+			if (inLimits && info.field.getType() != List.class)
+			{
+				info.value = value;
+			}
+			else if (inLimits)
+			{
+				if (((List<String>) info.value).size() == info.index)
+					((List<String>) info.value).add("");
+				((List<String>) info.value).set(info.index, Arrays.stream(info.tempValue.replace("[", "").replace("]", "").split(", ")).collect(Collectors.toList()).get(0));
+			}
+
+			return true;
+		};
+	}
+
+
+
+
+	//===============//
+	// File Handling //
+	//===============//
+
+	/** Grabs what is in the config and puts it in modid.toml */
+	public static void saveToFile()
+	{
+		CommentedFileConfig config = CommentedFileConfig.builder(configFilePath.toFile()).build();
+
+		// First try to create a config file
+		try {
+			if (!Files.exists(configFilePath))
+				Files.createFile(configFilePath);
+		}
+		catch (Exception e) {
+			LOGGER.info("Failed creating config file for " + MOD_NAME_READABLE + " at the path [" + configFilePath.toString() + "].");
+			e.printStackTrace();
+		}
+
+		loadFileWithErrorCheck(config);
+
+
+		// Just put this here for the future
+		config.setComment("_Version", " DONT TOUCH THIS, IF YOU DO THEN CONFIG FILE WOULD BREAK");
+		config.set("_Versions", ModInfo.VERSION);
+
+
+		for (EntryInfo info : entries) {
+			if (info.field.isAnnotationPresent(ConfigAnnotations.Entry.class)) {
+				editSingleOption.saveOption(info, config);
+
+				if (editSingleOption.getEntry((info.category.isEmpty() ? "" : info.category + ".") + "_" + info.field.getName()) != null)
+					config.setComment((info.category.isEmpty() ? "" : info.category + ".") + info.field.getName(), String.valueOf(editSingleOption.getEntry((info.category.isEmpty() ? "" : info.category + ".") + "_" + info.field.getName()).defaultValue));
+			}
+		}
+
+		config.save();
+		config.close();
+	}
+
+	/**
+	 * Grabs what is in modid.toml and puts it into the config
+	 * If the file doesn't exist then it runs saveToFile
+	 */
+	public static void loadFromFile()
+	{
+		CommentedFileConfig config = CommentedFileConfig.builder(configFilePath.toFile()).autosave().build();
+
+		// First checks if the config file was already made
+		if (!Files.exists(configFilePath)) {
+			LOGGER.info("Config file not found for " + MOD_NAME_READABLE + ". Creating config...");
+			saveToFile();
+			return;
+		}
+
+		loadFileWithErrorCheck(config);
+
+
+		// Just put this here for the future
+		config.setComment("_Version", " DONT TOUCH THIS, IF YOU DO THEN CONFIG FILE WOULD BREAK");
+		config.set("_Versions", ModInfo.VERSION);
+		
+
+		// Puts everything into its variable
+		for (EntryInfo info : entries) {
+			if (info.field.isAnnotationPresent(ConfigAnnotations.Entry.class)) {
+				editSingleOption.loadOption(info, config);
+
+				// File comments (WILL REMOVE SOON)
+				if (editSingleOption.getEntry((info.category.isEmpty() ? "" : info.category + ".") + "_" + info.field.getName()) != null)
+					config.setComment((info.category.isEmpty() ? "" : info.category + ".") + info.field.getName(), String.valueOf(editSingleOption.getEntry((info.category.isEmpty() ? "" : info.category + ".") + "_" + info.field.getName()).defaultValue));
+			}
+		}
+
+		config.close();
+	}
+
+	public static class editSingleOption {
+		/** Get the entry info of an item using its string name */
+		public static EntryInfo getEntry(String name)
+		{
+			return entryMap.get(name);
+		}
+
+		/** Save a single item using its string name */
+		public static void saveOption(String name)
+		{
+			saveOption(entryMap.get(name));
+		}
+
+		/** Saves a single item using entry info */
+		public static void saveOption(EntryInfo info)
+		{
+			CommentedFileConfig config = CommentedFileConfig.builder(configFilePath.toFile()).autosave().build();
+
+			loadFileWithErrorCheck(config);
+
+			saveOption(info, config);
+
+			config.close();
+		}
+
+		/** Saves a single item using its entry info and its config builder */
+		public static void saveOption(EntryInfo info, CommentedFileConfig config)
+		{
+			config.set((info.category.isEmpty() ? "" : info.category + ".") + info.field.getName(), info.value);
+		}
+
+		/** Load a single item using its string name */
+		public static void loadOption(String name)
+		{
+			loadOption(entryMap.get(name));
+		}
+
+		/** Load a single item using entry info */
+		public static void loadOption(EntryInfo info)
+		{
+			CommentedFileConfig config = CommentedFileConfig.builder(configFilePath.toFile()).autosave().build();
+
+			loadFileWithErrorCheck(config);
+
+			loadOption(info, config);
+
+			config.close();
+		}
+
+		/** Loads a single item using its entry info and its config builder */
+		public static void loadOption(EntryInfo info, CommentedFileConfig config)
+		{
+			String itemPath = (info.category.isEmpty() ? "" : info.category + ".") + info.field.getName();
+			if (config.contains(itemPath)) {
+				if (info.field.getType().isEnum())
+					info.value = config.getEnum(itemPath, info.varClass);
+				else
+					info.value = config.get(itemPath);
+			} else
+				config.set(itemPath, info.value);
+
+			try {
+				info.field.set(null, info.value);
+			} catch (IllegalAccessException ignored) {
+			}
+		}
+	}
+
+	/** Dose config.load(); but with error checking to avoid crashes */
+	public static void loadFileWithErrorCheck(CommentedFileConfig config) {
+		try {
+			config.load();
+		} catch (Exception e) {
+			LOGGER.info("Error loading config for " + MOD_NAME_READABLE + " at the path [" + configFilePath.toString() + "].");
+			LOGGER.info("Creating a new config...");
+			try {
+				Files.deleteIfExists(configFilePath);
+				saveToFile();
+			} catch (Exception f) {
+				LOGGER.info("Failed creating config file for " + MOD_NAME_READABLE + " at the path [" + configFilePath.toString() + "].");
+				f.printStackTrace();
+			}
+		}
+	}
+
+
+
+
+	//==============//
+	// GUI handling //
+	//==============//
+
+	public static Screen getScreen(Screen parent, String category)
+	{
+		return new ConfigScreen(parent, category);
+	}
+
+	private static class ConfigScreen extends Screen
+	{
+		protected ConfigScreen(Screen parent, String category)
+		{
+			super(new TranslatableComponent(
+					I18n.exists(MOD_NAME + ".config" + (category.isEmpty()? "." + category : "") + ".title") ?
+							MOD_NAME + ".config.title" :
+							MOD_NAME + ".config" + (category.isEmpty() ? "" : "." + category) + ".title")
+			);
+			this.parent = parent;
+			this.category = category;
+			this.translationPrefix = MOD_NAME + ".config.";
+		}
+
+		private final String translationPrefix;
+		private final Screen parent;
+		private final String category;
+		private ConfigListWidget list;
+		private boolean reload = false;
+
+		// Real Time config update //
+		@Override
+		public void tick()
+		{
+			super.tick();
+		}
+
+
+		/** When you close it, it goes to the previous screen and saves */
+		@Override
+		public void onClose()
+		{
+			saveToFile();
+			Objects.requireNonNull(minecraft).setScreen(this.parent);
+		}
+
+		@Override
+		protected void init()
+		{
+			super.init();
+			if (!reload)
+				loadFromFile();
+
+			// addRenderableWidget in 1.17 and over
+			// addButton in 1.16 and below
+			this.addRenderableWidget(new Button(this.width / 2 - 154, this.height - 28, 150, 20, CommonComponents.GUI_CANCEL, button -> {
+				loadFromFile();
+				Objects.requireNonNull(minecraft).setScreen(parent);
+			}));
+
+			Button done = this.addRenderableWidget(new Button(this.width / 2 + 4, this.height - 28, 150, 20, CommonComponents.GUI_DONE, (button) -> {
+				saveToFile();
+				Objects.requireNonNull(minecraft).setScreen(parent);
+			}));
+
+			this.list = new ConfigListWidget(this.minecraft, this.width * 2, this.height, 32, this.height - 32, 25);
+			if (this.minecraft != null && this.minecraft.level != null)
+				this.list.setRenderBackground(false);
+			this.addWidget(this.list);
+			for (EntryInfo info : entries)
+			{
+				if (info.category.matches(category) && !info.hideOption)
+				{
+					TranslatableComponent name = (info.name == null ? new TranslatableComponent(translationPrefix + (!info.category.isEmpty() ? info.category + "." : "") + info.field.getName()) : info.name);
+					Button resetButton = new Button(this.width - ConfigScreenConfigs.SpaceFromRightScreen - info.width - ConfigScreenConfigs.ButtonWidthSpacing - ConfigScreenConfigs.ResetButtonWidth, 0, ConfigScreenConfigs.ResetButtonWidth, 20, new TextComponent("Reset").withStyle(ChatFormatting.RED), (button -> {
+						info.value = info.defaultValue;
+						info.tempValue = info.defaultValue.toString();
+						info.index = 0;
+						this.reload = true;
+						Objects.requireNonNull(minecraft).setScreen(this);
+					}));
+
+					if (info.widget instanceof Map.Entry)
+					{
+						Map.Entry<Button.OnPress, Function<Object, Component>> widget = (Map.Entry<Button.OnPress, Function<Object, Component>>) info.widget;
+						if (info.field.getType().isEnum())
+							widget.setValue(value -> new TranslatableComponent(translationPrefix + "enum." + info.field.getType().getSimpleName() + "." + info.value.toString()));
+						this.list.addButton(new Button(this.width - info.width - ConfigScreenConfigs.SpaceFromRightScreen, 0, info.width, 20, widget.getValue().apply(info.value), widget.getKey()), resetButton, null, name);
+					}
+					else if (info.field.getType() == List.class)
+					{
+						if (!reload)
+							info.index = 0;
+						EditBox widget = new EditBox(font, this.width - info.width - ConfigScreenConfigs.SpaceFromRightScreen, 0, info.width, 20, null);
+						widget.setMaxLength(info.width);
+						if (info.index < ((List<String>) info.value).size())
+							widget.insertText((String.valueOf(((List<String>) info.value).get(info.index))));
+						else
+							widget.insertText("");
+						Predicate<String> processor = ((BiFunction<EditBox, Button, Predicate<String>>) info.widget).apply(widget, done);
+						widget.setFilter(processor);
+						resetButton.setWidth(20);
+						resetButton.setMessage(new TextComponent("R").withStyle(ChatFormatting.RED));
+						Button cycleButton = new Button(this.width - 185, 0, 20, 20, new TextComponent(String.valueOf(info.index)).withStyle(ChatFormatting.GOLD), (button -> {
+							((List<String>) info.value).remove("");
+							this.reload = true;
+							info.index = info.index + 1;
+							if (info.index > ((List<String>) info.value).size())
+								info.index = 0;
+							Objects.requireNonNull(minecraft).setScreen(this);
+						}));
+						this.list.addButton(widget, resetButton, cycleButton, name);
+					}
+					else if (info.widget != null)
+					{
+						EditBox widget = new EditBox(font, this.width - info.width - ConfigScreenConfigs.SpaceFromRightScreen + 2, 0, info.width - 4, 20, null);
+						widget.setMaxLength(info.width);
+						widget.insertText(String.valueOf(info.value));
+						Predicate<String> processor = ((BiFunction<EditBox, Button, Predicate<String>>) info.widget).apply(widget, done);
+						widget.setFilter(processor);
+						this.list.addButton(widget, resetButton, null, name);
+					}
+					else if (info.screenButton)
+					{
+						Button widget = new Button(this.width / 2 - info.width, this.height - 28, info.width * 2, 20, name, (button -> {
+							Objects.requireNonNull(minecraft).setScreen(ConfigGui.getScreen(this, info.gotoScreen));
+						}));
+						this.list.addButton(widget, null, null, null);
+					}
+					else if (!info.fileComment)
+					{
+						this.list.addButton(null, null, null, name);
+					}
+				}
+			}
+
+		}
+
+		@Override
+		public void render(PoseStack matrices, int mouseX, int mouseY, float delta)
+		{
+			this.renderBackground(matrices); // Renders background
+			this.list.render(matrices, mouseX, mouseY, delta); // Render buttons
+			drawCenteredString(matrices, font, title, width / 2, 15, 0xFFFFFF); // Render title
+
+			// Render the tooltip only if it can find a tooltip in the language file
+			for (EntryInfo info : entries) {
+				if (info.category.matches(category) && !info.hideOption) {
+					if (list.getHoveredButton(mouseX,mouseY).isPresent()) {
+						AbstractWidget buttonWidget = list.getHoveredButton(mouseX,mouseY).get();
+						Component text = ButtonEntry.buttonsWithText.get(buttonWidget);
+						TranslatableComponent name = new TranslatableComponent(this.translationPrefix + (info.category.isEmpty() ? "" : info.category + ".") + info.field.getName());
+						String key = translationPrefix + (info.category.isEmpty() ? "" : info.category + ".") + info.field.getName() + ".@tooltip";
+
+						if (info.error != null && text.equals(name)) renderTooltip(matrices, (Component) info.error.getValue(), mouseX, mouseY);
+						else if (I18n.exists(key) && (text != null && text.equals(name))) {
+							List<Component> list = new ArrayList<>();
+							for (String str : I18n.get(key).split("\n"))
+								list.add(new TextComponent(str));
+							renderComponentTooltip(matrices, list, mouseX, mouseY);
+						}
+					}
+				}
+			}
+			super.render(matrices, mouseX, mouseY, delta);
+		}
+	}
+
+
+
+
+	public static class ConfigListWidget extends ContainerObjectSelectionList<ButtonEntry>
+	{
+		Font textRenderer;
+
+		public ConfigListWidget(Minecraft minecraftClient, int i, int j, int k, int l, int m)
+		{
+			super(minecraftClient, i, j, k, l, m);
+			this.centerListVertically = false;
+			textRenderer = minecraftClient.font;
+		}
+
+		public void addButton(AbstractWidget button, AbstractWidget resetButton, AbstractWidget indexButton, Component text)
+		{
+			this.addEntry(ButtonEntry.create(button, text, resetButton, indexButton));
+		}
+
+		@Override
+		public int getRowWidth()
+		{
+			return 10000;
+		}
+
+		public Optional<AbstractWidget> getHoveredButton(double mouseX, double mouseY)
+		{
+			for (ButtonEntry buttonEntry : this.children())
+			{
+				if (buttonEntry.button != null && buttonEntry.button.isMouseOver(mouseX, mouseY))
+				{
+					return Optional.of(buttonEntry.button);
+				}
+			}
+			return Optional.empty();
+		}
+	}
+
+
+
+
+
+	public static class ButtonEntry extends ContainerObjectSelectionList.Entry<ButtonEntry>
+	{
+		private static final Font textRenderer = Minecraft.getInstance().font;
+		public final AbstractWidget button;
+		private final AbstractWidget resetButton;
+		private final AbstractWidget indexButton;
+		private final Component text;
+		private final List<AbstractWidget> children = new ArrayList<>();
+		public static final Map<AbstractWidget, Component> buttonsWithText = new HashMap<>();
+
+		private ButtonEntry(AbstractWidget button, Component text, AbstractWidget resetButton, AbstractWidget indexButton)
+		{
+			buttonsWithText.put(button, text);
+			this.button = button;
+			this.resetButton = resetButton;
+			this.text = text;
+			this.indexButton = indexButton;
+			if (button != null)
+				children.add(button);
+			if (resetButton != null)
+				children.add(resetButton);
+			if (indexButton != null)
+				children.add(indexButton);
+		}
+
+		public static ButtonEntry create(AbstractWidget button, Component text, AbstractWidget resetButton, AbstractWidget indexButton)
+		{
+			return new ButtonEntry(button, text, resetButton, indexButton);
+		}
+
+		@Override
+		public void render(PoseStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta)
+		{
+			if (button != null)
+			{
+				button.y = y;
+				button.render(matrices, mouseX, mouseY, tickDelta);
+			}
+			if (resetButton != null)
+			{
+				resetButton.y = y;
+				resetButton.render(matrices, mouseX, mouseY, tickDelta);
+			}
+			if (indexButton != null)
+			{
+				indexButton.y = y;
+				indexButton.render(matrices, mouseX, mouseY, tickDelta);
+			}
+			if (text != null && (!text.getString().contains("spacer") || button != null))
+				GuiComponent.drawString(matrices, textRenderer, text, 12, y + 5, 0xFFFFFF);
+		}
+
+		@Override
+		public List<? extends GuiEventListener> children()
+		{
+			return children;
+		}
+
+		// Only for 1.17 and over
+		// Remove in 1.16 and below
+		@Override
+		public List<? extends NarratableEntry> narratables()
+		{
+			return children;
+		}
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/config/LodConfigWrapperSingleton.java

@@ -0,0 +1,543 @@
+package com.seibel.lod.common.wrappers.config;
+
+import com.seibel.lod.core.enums.config.*;
+import com.seibel.lod.core.enums.rendering.*;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.common.Config;
+
+/**
+ * This holds the config defaults and setters/getters
+ * that should be hooked into the host mod loader (Fabric, Forge, etc.).
+ *
+ * @author James Seibel
+ * @version 11-16-2021
+ */
+public class LodConfigWrapperSingleton implements ILodConfigWrapperSingleton
+{
+	public static final LodConfigWrapperSingleton INSTANCE = new LodConfigWrapperSingleton();
+
+
+	private static final Client client = new Client();
+	@Override
+	public IClient client()
+	{
+		return client;
+	}
+
+	public static class Client implements IClient
+	{
+		public final IGraphics graphics;
+		public final IWorldGenerator worldGenerator;
+		public final IAdvanced advanced;
+
+
+		@Override
+		public IGraphics graphics()
+		{
+			return graphics;
+		}
+
+		@Override
+		public IWorldGenerator worldGenerator()
+		{
+			return worldGenerator;
+		}
+
+		@Override
+		public IAdvanced advanced()
+		{
+			return advanced;
+		}
+
+
+		@Override
+		public boolean getOptionsButton()
+		{
+			return Config.optionsButton;
+		}
+		@Override
+		public void setOptionsButton(boolean newOptionsButton)
+		{
+			ConfigGui.editSingleOption.getEntry("optionsButton").value = newOptionsButton;
+			ConfigGui.editSingleOption.saveOption("optionsButton");
+		}
+
+
+		//================//
+		// Client Configs //
+		//================//
+		public Client()
+		{
+			graphics = new Graphics();
+			worldGenerator = new WorldGenerator();
+			advanced = new Advanced();
+		}
+
+
+		//==================//
+		// Graphics Configs //
+		//==================//
+		public static class Graphics implements IGraphics
+		{
+			public final IQuality quality;
+			public final IFogQuality fogQuality;
+			public final IAdvancedGraphics advancedGraphics;
+
+
+
+			@Override
+			public IQuality quality()
+			{
+				return quality;
+			}
+
+			@Override
+			public IFogQuality fogQuality()
+			{
+				return fogQuality;
+			}
+
+			@Override
+			public IAdvancedGraphics advancedGraphics()
+			{
+				return advancedGraphics;
+			}
+
+
+			Graphics()
+			{
+				quality = new Quality();
+				fogQuality = new FogQuality();
+				advancedGraphics = new AdvancedGraphics();
+			}
+
+
+			public static class Quality implements IQuality
+			{
+				@Override
+				public HorizontalResolution getDrawResolution()
+				{
+					return Config.Client.Graphics.Quality.drawResolution;
+				}
+				@Override
+				public void setDrawResolution(HorizontalResolution newHorizontalResolution)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.quality.drawResolution").value = newHorizontalResolution;
+					ConfigGui.editSingleOption.saveOption("client.graphics.quality.drawResolution");
+				}
+
+
+				@Override
+				public int getLodChunkRenderDistance()
+				{
+					return Config.Client.Graphics.Quality.lodChunkRenderDistance;
+				}
+				@Override
+				public void setLodChunkRenderDistance(int newLodChunkRenderDistance)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.quality.lodChunkRenderDistance").value = newLodChunkRenderDistance;
+					ConfigGui.editSingleOption.saveOption("client.graphics.quality.lodChunkRenderDistance");
+				}
+
+
+				@Override
+				public VerticalQuality getVerticalQuality()
+				{
+					return Config.Client.Graphics.Quality.verticalQuality;
+				}
+				@Override
+				public void setVerticalQuality(VerticalQuality newVerticalQuality)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.quality.verticalQuality").value = newVerticalQuality;
+					ConfigGui.editSingleOption.saveOption("client.graphics.quality.verticalQuality");
+				}
+
+
+				@Override
+				public int getHorizontalScale()
+				{
+					return Config.Client.Graphics.Quality.horizontalScale;
+				}
+				@Override
+				public void setHorizontalScale(int newHorizontalScale)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.quality.horizontalScale").value = newHorizontalScale;
+					ConfigGui.editSingleOption.saveOption("client.graphics.quality.horizontalScale");
+				}
+
+
+				@Override
+				public HorizontalQuality getHorizontalQuality()
+				{
+					return Config.Client.Graphics.Quality.horizontalQuality;
+				}
+				@Override
+				public void setHorizontalQuality(HorizontalQuality newHorizontalQuality)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.quality.horizontalQuality").value = newHorizontalQuality;
+					ConfigGui.editSingleOption.saveOption("client.graphics.quality.horizontalQuality");
+				}
+				
+				@Override
+				public DropoffQuality getDropoffQuality() {
+					return Config.Client.Graphics.Quality.dropoffQuality;
+				}
+				@Override
+				public void setDropoffQuality(DropoffQuality newDropoffQuality) {
+					ConfigGui.editSingleOption.getEntry("client.graphics.quality.dropoffQuality").value = newDropoffQuality;
+					ConfigGui.editSingleOption.saveOption("client.graphics.quality.dropoffQuality");
+				}
+			}
+
+
+			public static class FogQuality implements IFogQuality
+			{
+				@Override
+				public FogDistance getFogDistance()
+				{
+					return Config.Client.Graphics.FogQuality.fogDistance;
+				}
+				@Override
+				public void setFogDistance(FogDistance newFogDistance)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.fogQuality.fogDistance").value = newFogDistance;
+					ConfigGui.editSingleOption.saveOption("client.graphics.fogQuality.fogDistance");
+				}
+
+
+				@Override
+				public FogDrawMode getFogDrawMode()
+				{
+					return Config.Client.Graphics.FogQuality.fogDrawMode;
+				}
+
+				@Override
+				public void setFogDrawMode(FogDrawMode setFogDrawMode)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.fogQuality.fogDrawMode").value = setFogDrawMode;
+					ConfigGui.editSingleOption.saveOption("client.graphics.fogQuality.fogDrawMode");
+				}
+
+
+				@Override
+				public FogColorMode getFogColorMode()
+				{
+					return Config.Client.Graphics.FogQuality.fogColorMode;
+				}
+
+				@Override
+				public void setFogColorMode(FogColorMode newFogColorMode)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.fogQuality.fogColorMode").value = newFogColorMode;
+					ConfigGui.editSingleOption.saveOption("client.graphics.fogQuality.fogColorMode");
+				}
+
+
+				@Override
+				public boolean getDisableVanillaFog()
+				{
+					return Config.Client.Graphics.FogQuality.disableVanillaFog;
+				}
+				@Override
+				public void setDisableVanillaFog(boolean newDisableVanillaFog)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.fogQuality.disableVanillaFog").value = newDisableVanillaFog;
+					ConfigGui.editSingleOption.saveOption("client.graphics.fogQuality.disableVanillaFog");
+				}
+			}
+
+
+			public static class AdvancedGraphics implements IAdvancedGraphics
+			{
+				@Override
+				public boolean getDisableDirectionalCulling()
+				{
+					return Config.Client.Graphics.AdvancedGraphics.disableDirectionalCulling;
+				}
+				@Override
+				public void setDisableDirectionalCulling(boolean newDisableDirectionalCulling)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.advancedGraphics.disableDirectionalCulling").value = newDisableDirectionalCulling;
+					ConfigGui.editSingleOption.saveOption("client.graphics.advancedGraphics.disableDirectionalCulling");
+				}
+
+				@Override
+				public VanillaOverdraw getVanillaOverdraw()
+				{
+					return Config.Client.Graphics.AdvancedGraphics.vanillaOverdraw;
+				}
+				@Override
+				public void setVanillaOverdraw(VanillaOverdraw newVanillaOverdraw)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.advancedGraphics.vanillaOverdraw").value = newVanillaOverdraw;
+					ConfigGui.editSingleOption.saveOption("client.graphics.advancedGraphics.vanillaOverdraw");
+				}
+				/*
+				@Override
+				public int getBacksideCullingRange()
+				{
+					return Config.Client.Graphics.AdvancedGraphics.backsideCullingRange;
+				}
+				@Override
+				public void setBacksideCullingRange(int newBacksideCullingRange)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.advancedGraphics.backsideCullingRange").value = newBacksideCullingRange;
+					ConfigGui.editSingleOption.saveOption("client.graphics.advancedGraphics.backsideCullingRange");
+				}*/
+				
+				@Override
+				public boolean getUseExtendedNearClipPlane()
+				{
+					return Config.Client.Graphics.AdvancedGraphics.useExtendedNearClipPlane;
+				}
+				@Override
+				public void setUseExtendedNearClipPlane(boolean newUseExtendedNearClipPlane)
+				{
+					ConfigGui.editSingleOption.getEntry("client.graphics.advancedGraphics.useExtendedNearClipPlane").value = newUseExtendedNearClipPlane;
+					ConfigGui.editSingleOption.saveOption("client.graphics.advancedGraphics.useExtendedNearClipPlane");
+				}
+			}
+		}
+
+
+
+
+		//========================//
+		// WorldGenerator Configs //
+		//========================//
+		public static class WorldGenerator implements IWorldGenerator
+		{
+			@Override
+			public GenerationPriority getGenerationPriority()
+			{
+				return Config.Client.WorldGenerator.generationPriority;
+			}
+			@Override
+			public void setGenerationPriority(GenerationPriority newGenerationPriority)
+			{
+				ConfigGui.editSingleOption.getEntry("client.worldGenerator.generationPriority").value = newGenerationPriority;
+				ConfigGui.editSingleOption.saveOption("client.worldGenerator.generationPriority");
+			}
+
+
+			@Override
+			public DistanceGenerationMode getDistanceGenerationMode()
+			{
+				return Config.Client.WorldGenerator.distanceGenerationMode;
+			}
+			@Override
+			public void setDistanceGenerationMode(DistanceGenerationMode newDistanceGenerationMode)
+			{
+				ConfigGui.editSingleOption.getEntry("client.worldGenerator.distanceGenerationMode").value = newDistanceGenerationMode;
+				ConfigGui.editSingleOption.saveOption("client.worldGenerator.distanceGenerationMode");
+			}
+
+			/*
+			@Override
+			public boolean getAllowUnstableFeatureGeneration()
+			{
+				return Config.Client.WorldGenerator.allowUnstableFeatureGeneration;
+			}
+			@Override
+			public void setAllowUnstableFeatureGeneration(boolean newAllowUnstableFeatureGeneration)
+			{
+				ConfigGui.editSingleOption.getEntry("client.worldGenerator.allowUnstableFeatureGeneration").value = newAllowUnstableFeatureGeneration;
+				ConfigGui.editSingleOption.saveOption("client.worldGenerator.allowUnstableFeatureGeneration");
+			}*/
+
+
+			@Override
+			public BlocksToAvoid getBlocksToAvoid()
+			{
+				return Config.Client.WorldGenerator.blocksToAvoid;
+			}
+			@Override
+			public void setBlockToAvoid(BlocksToAvoid newBlockToAvoid)
+			{
+				ConfigGui.editSingleOption.getEntry("client.worldGenerator.blocksToAvoid").value = newBlockToAvoid;
+				ConfigGui.editSingleOption.saveOption("client.worldGenerator.blocksToAvoid");
+			}
+			@Override
+			public boolean getEnableDistantGeneration()
+			{
+				return Config.Client.WorldGenerator.enableDistantGeneration;
+			}
+			@Override
+			public void setEnableDistantGeneration(boolean newEnableDistantGeneration)
+			{
+				ConfigGui.editSingleOption.getEntry("client.worldGenerator.enableDistantGeneration").value = newEnableDistantGeneration;
+				ConfigGui.editSingleOption.saveOption("client.worldGenerator.enableDistantGeneration");
+			}
+			@Override
+			public LightGenerationMode getLightGenerationMode()
+			{
+				return Config.Client.WorldGenerator.lightGenerationMode;
+			}
+			@Override
+			public void setLightGenerationMode(LightGenerationMode newLightGenerationMode)
+			{
+				ConfigGui.editSingleOption.getEntry("client.worldGenerator.lightGenerationMode").value = newLightGenerationMode;
+				ConfigGui.editSingleOption.saveOption("client.worldGenerator.lightGenerationMode");
+			}
+		}
+
+
+
+
+		//============================//
+		// AdvancedModOptions Configs //
+		//============================//
+		public static class Advanced implements IAdvanced
+		{
+			public final IThreading threading;
+			public final IDebugging debugging;
+			public final IBuffers buffers;
+
+
+			@Override
+			public IThreading threading()
+			{
+				return threading;
+			}
+
+
+			@Override
+			public IDebugging debugging()
+			{
+				return debugging;
+			}
+
+
+			@Override
+			public IBuffers buffers()
+			{
+				return buffers;
+			}
+
+
+			public Advanced()
+			{
+				threading = new Threading();
+				debugging = new Debugging();
+				buffers = new Buffers();
+			}
+
+			public static class Threading implements IThreading
+			{
+				@Override
+				public int getNumberOfWorldGenerationThreads()
+				{
+					return Config.Client.Advanced.Threading.numberOfWorldGenerationThreads;
+				}
+				@Override
+				public void setNumberOfWorldGenerationThreads(int newNumberOfWorldGenerationThreads)
+				{
+					ConfigGui.editSingleOption.getEntry("client.advanced.threading.numberOfWorldGenerationThreads").value = newNumberOfWorldGenerationThreads;
+					ConfigGui.editSingleOption.saveOption("client.advanced.threading.numberOfWorldGenerationThreads");
+				}
+
+
+				@Override
+				public int getNumberOfBufferBuilderThreads()
+				{
+					return Config.Client.Advanced.Threading.numberOfBufferBuilderThreads;
+				}
+				@Override
+				public void setNumberOfBufferBuilderThreads(int newNumberOfWorldBuilderThreads)
+				{
+					ConfigGui.editSingleOption.getEntry("client.advanced.threading.numberOfBufferBuilderThreads").value = newNumberOfWorldBuilderThreads;
+					ConfigGui.editSingleOption.saveOption("client.advanced.threading.numberOfBufferBuilderThreads");
+				}
+			}
+
+
+
+
+			//===============//
+			// Debug Options //
+			//===============//
+			public static class Debugging implements IDebugging
+			{
+				@Override
+				public boolean getDrawLods()
+				{
+					return (boolean) ConfigGui.editSingleOption.getEntry("client.advanced.debugging.drawLods").value;
+				}
+				@Override
+				public void setDrawLods(boolean newDrawLods)
+				{
+					ConfigGui.editSingleOption.getEntry("client.advanced.debugging.drawLods").value = newDrawLods;
+					ConfigGui.editSingleOption.saveOption("client.advanced.debugging.drawLods");
+				}
+
+
+				@Override
+				public DebugMode getDebugMode()
+				{
+					return (DebugMode) ConfigGui.editSingleOption.getEntry("client.advanced.debugging.debugMode").value;
+				}
+				@Override
+				public void setDebugMode(DebugMode newDebugMode)
+				{
+					ConfigGui.editSingleOption.getEntry("client.advanced.debugging.debugMode").value = newDebugMode;
+					ConfigGui.editSingleOption.saveOption("client.advanced.debugging.debugMode");
+				}
+
+
+				@Override
+				public boolean getDebugKeybindingsEnabled()
+				{
+					return (boolean) ConfigGui.editSingleOption.getEntry("client.advanced.debugging.enableDebugKeybindings").value;
+				}
+				@Override
+				public void setDebugKeybindingsEnabled(boolean newEnableDebugKeybindings)
+				{
+					ConfigGui.editSingleOption.getEntry("client.advanced.debugging.enableDebugKeybindings").value = newEnableDebugKeybindings;
+					ConfigGui.editSingleOption.saveOption("client.advanced.debugging.enableDebugKeybindings");
+				}
+			}
+
+
+			public static class Buffers implements IBuffers
+			{
+
+				@Override
+				public GpuUploadMethod getGpuUploadMethod()
+				{
+					return Config.Client.Advanced.Buffers.gpuUploadMethod;
+				}
+				@Override
+				public void setGpuUploadMethod(GpuUploadMethod newDisableVanillaFog)
+				{
+					ConfigGui.editSingleOption.getEntry("client.advanced.buffers.gpuUploadMethod").value = newDisableVanillaFog;
+					ConfigGui.editSingleOption.saveOption("client.advanced.buffers.gpuUploadMethod");
+				}
+
+
+				@Override
+				public int getGpuUploadPerMegabyteInMilliseconds()
+				{
+					return Config.Client.Advanced.Buffers.gpuUploadPerMegabyteInMilliseconds;
+				}
+				@Override
+				public void setGpuUploadPerMegabyteInMilliseconds(int newMilliseconds) {
+					ConfigGui.editSingleOption.getEntry("client.advanced.buffers.gpuUploadPerMegabyteInMilliseconds").value = newMilliseconds;
+					ConfigGui.editSingleOption.saveOption("client.advanced.buffers.gpuUploadPerMegabyteInMilliseconds");
+				}
+
+
+				@Override
+				public BufferRebuildTimes getRebuildTimes()
+				{
+					return Config.Client.Advanced.Buffers.rebuildTimes;
+				}
+				@Override
+				public void setRebuildTimes(BufferRebuildTimes newBufferRebuildTimes)
+				{
+					ConfigGui.editSingleOption.getEntry("client.advanced.buffers.newBufferRebuildTimes").value = newBufferRebuildTimes;
+					ConfigGui.editSingleOption.saveOption("client.advanced.buffers.newBufferRebuildTimes");
+				}
+			}
+		}
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/config/TexturedButtonWidget.java

@@ -0,0 +1,43 @@
+package com.seibel.lod.common.wrappers.config;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.gui.components.ImageButton;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+
+/**
+ * Creates a button with a texture on it
+ */
+public class TexturedButtonWidget extends ImageButton {
+    public TexturedButtonWidget(int x, int y, int width, int height, int u, int v, ResourceLocation texture, OnPress pressAction) {
+        super(x, y, width, height, u, v, texture, pressAction);
+    }
+    public TexturedButtonWidget(int x, int y, int width, int height, int u, int v, int hoveredVOffset, ResourceLocation texture, int textureWidth, int textureHeight, OnPress pressAction) {
+        super(x, y, width, height, u, v, hoveredVOffset, texture, textureWidth, textureHeight, pressAction);
+    }
+
+    public TexturedButtonWidget(int x, int y, int width, int height, int u, int v, int hoveredVOffset, ResourceLocation texture, int textureWidth, int textureHeight, OnPress pressAction, Component text) {
+        super(x, y, width, height, u, v, hoveredVOffset, texture, textureWidth, textureHeight, pressAction, text);
+    }
+
+    public TexturedButtonWidget(int x, int y, int width, int height, int u, int v, int hoveredVOffset, ResourceLocation texture, int textureWidth, int textureHeight, OnPress pressAction, OnTooltip tooltipSupplier, Component text) {
+        super(x, y, width, height, u, v, hoveredVOffset, texture, textureWidth, textureHeight, pressAction, tooltipSupplier, text);
+    }
+
+    @Override
+    public void renderButton(PoseStack matrices, int mouseX, int mouseY, float delta) {
+        RenderSystem.setShader(GameRenderer::getPositionTexShader);
+        RenderSystem.setShaderTexture(0, WIDGETS_LOCATION);
+        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, this.alpha);
+        int i = this.getYImage(this.isHovered);
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
+        RenderSystem.enableDepthTest();
+        this.blit(matrices, this.x, this.y, 0, 46 + i * 20, this.width / 2, this.height);
+        this.blit(matrices, this.x + this.width / 2, this.y, 200 - this.width / 2, 46 + i * 20, this.width / 2, this.height);
+
+        super.renderButton(matrices, mouseX, mouseY, delta);
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/minecraft/MinecraftRenderWrapper.java

@@ -0,0 +1,315 @@
+package com.seibel.lod.common.wrappers.minecraft;
+
+import java.awt.*;
+import java.util.HashSet;
+import java.util.stream.Collectors;
+
+import com.mojang.blaze3d.platform.NativeImage;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.seibel.lod.common.wrappers.misc.LightMapWrapper;
+import com.seibel.lod.core.api.ModAccessorApi;
+import com.seibel.lod.core.util.LodUtil;
+
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.IWrapperFactory;
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftWrapper;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import net.minecraft.client.renderer.LightTexture;
+
+import com.mojang.math.Vector3f;
+import com.seibel.lod.core.objects.math.Mat4f;
+import com.seibel.lod.core.objects.math.Vec3d;
+import com.seibel.lod.core.objects.math.Vec3f;
+import com.seibel.lod.core.wrapperInterfaces.block.AbstractBlockPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.ISodiumAccessor;
+import com.seibel.lod.common.wrappers.McObjectConverter;
+import com.seibel.lod.common.wrappers.WrapperFactory;
+import com.seibel.lod.common.wrappers.block.BlockPosWrapper;
+
+import net.minecraft.client.Camera;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.FogRenderer;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.client.renderer.LevelRenderer;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.level.material.FogType;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+
+
+/**
+ * A singleton that contains everything
+ * related to rendering in Minecraft.
+ *
+ * @author James Seibel
+ * @version 12-12-2021
+ */
+public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
+{
+    public static final MinecraftRenderWrapper INSTANCE = new MinecraftRenderWrapper();
+
+    private static final Minecraft MC = Minecraft.getInstance();
+    private static final GameRenderer GAME_RENDERER = MC.gameRenderer;
+    private static final WrapperFactory FACTORY = WrapperFactory.INSTANCE;
+
+    @Override
+    public Vec3f getLookAtVector()
+    {
+        Camera camera = GAME_RENDERER.getMainCamera();
+        Vector3f cameraDir = camera.getLookVector();
+        return new Vec3f(cameraDir.x(), cameraDir.y(), cameraDir.z());
+    }
+
+    @Override
+    public AbstractBlockPosWrapper getCameraBlockPosition()
+    {
+        Camera camera = GAME_RENDERER.getMainCamera();
+        BlockPos blockPos = camera.getBlockPosition();
+        return new BlockPosWrapper(blockPos.getX(), blockPos.getY(), blockPos.getZ());
+    }
+
+    @Override
+    public boolean playerHasBlindnessEffect()
+    {
+        return MC.player.getActiveEffectsMap().get(MobEffects.BLINDNESS) != null;
+    }
+
+    @Override
+    public Vec3d getCameraExactPosition()
+    {
+        Camera camera = GAME_RENDERER.getMainCamera();
+        Vec3 projectedView = camera.getPosition();
+
+        return new Vec3d(projectedView.x, projectedView.y, projectedView.z);
+    }
+
+    @Override
+    public Mat4f getDefaultProjectionMatrix(float partialTicks)
+    {
+        return McObjectConverter.Convert(GAME_RENDERER.getProjectionMatrix(GAME_RENDERER.getFov(GAME_RENDERER.getMainCamera(), partialTicks, true)));
+    }
+
+    @Override
+    public double getGamma()
+    {
+        return MC.options.gamma;
+    }
+
+    @Override
+    public Color getFogColor(float partialTicks) {
+        FogRenderer.setupColor(GAME_RENDERER.getMainCamera(), partialTicks, MC.level, 1, GAME_RENDERER.getDarkenWorldAmount(partialTicks));
+        float[] colorValues = RenderSystem.getShaderFogColor();
+        return new Color(colorValues[0], colorValues[1], colorValues[2], colorValues[3]);
+    }
+    // getSpecialFogColor() is the same as getFogColor()
+
+    @Override
+    public Color getSkyColor() {
+        if (MC.level.dimensionType().hasSkyLight()) {
+            Vec3 colorValues = MC.level.getSkyColor(MC.gameRenderer.getMainCamera().getPosition(), MC.getFrameTime());
+            return new Color((float) colorValues.x, (float) colorValues.y, (float) colorValues.z);
+        } else
+            return new Color(0, 0, 0);
+    }
+
+    @Override
+    public double getFov(float partialTicks)
+    {
+        return GAME_RENDERER.getFov(GAME_RENDERER.getMainCamera(), partialTicks, true);
+    }
+
+    /** Measured in chunks */
+    @Override
+    public int getRenderDistance()
+    {
+        return MC.options.renderDistance;
+    }
+
+    @Override
+    public int getScreenWidth()
+    {
+        return MC.getWindow().getWidth();
+    }
+    @Override
+    public int getScreenHeight()
+    {
+        return MC.getWindow().getHeight();
+    }
+
+    /**
+     * This method returns the ChunkPos of all chunks that Minecraft
+     * is going to render this frame. <br><br>
+     * <p>
+     */
+
+    @Override
+    public HashSet<AbstractChunkPosWrapper> getVanillaRenderedChunks()
+    {
+        ISodiumAccessor sodium = ModAccessorApi.get(ISodiumAccessor.class);
+        if (sodium != null)
+        {
+            return sodium.getNormalRenderedChunks();
+        }
+        IOptifineAccessor optifine = ModAccessorApi.get(IOptifineAccessor.class);
+        if (optifine != null)
+        {
+            HashSet<AbstractChunkPosWrapper> pos = optifine.getNormalRenderedChunks();
+            if (pos==null)
+                pos = getMaximumRenderedChunks();
+            return pos;
+        }
+
+        LevelRenderer levelRenderer = MC.levelRenderer;
+        ObjectArrayList<LevelRenderer.RenderChunkInfo> chunks = levelRenderer.renderChunks;
+        return (chunks.stream().map((chunk) -> {
+            AABB chunkBoundingBox = chunk.chunk.bb;
+            return FACTORY.createChunkPos(Math.floorDiv((int) chunkBoundingBox.minX, 16),
+                    Math.floorDiv((int) chunkBoundingBox.minZ, 16));
+        }).collect(Collectors.toCollection(HashSet::new)));
+    }
+
+    @Override
+    public HashSet<AbstractChunkPosWrapper> getMaximumRenderedChunks()
+    {
+        //TODO: Make this a circle
+        IMinecraftWrapper mcWrapper = SingletonHandler.get(IMinecraftWrapper.class);
+        IWrapperFactory factory = SingletonHandler.get(IWrapperFactory.class);
+
+        int chunkRenderDist = this.getRenderDistance();
+
+        AbstractChunkPosWrapper centerChunkPos = mcWrapper.getPlayerChunkPos();
+        int startChunkX = centerChunkPos.getX() - chunkRenderDist;
+        int startChunkZ = centerChunkPos.getZ() - chunkRenderDist;
+
+        // add every position within render distance
+        HashSet<AbstractChunkPosWrapper> renderedPos = new HashSet<AbstractChunkPosWrapper>();
+        for (int chunkX = 0; chunkX < (chunkRenderDist * 2+1); chunkX++)
+        {
+            for(int chunkZ = 0; chunkZ < (chunkRenderDist * 2+1); chunkZ++)
+            {
+                renderedPos.add(factory.createChunkPos(startChunkX + chunkX, startChunkZ + chunkZ));
+            }
+        }
+
+        return renderedPos;
+    }
+
+
+
+    @Override
+    public int[] getLightmapPixels()
+    {
+        LightTexture tex = GAME_RENDERER.lightTexture();
+        tex.tick(); // This call makes no sense, but it fixes pause menu flicker bug
+        NativeImage lightMapPixels = tex.lightPixels;
+        LightMapWrapper lightMap = new LightMapWrapper(lightMapPixels);
+
+
+        int lightMapHeight = getLightmapTextureHeight();
+        int lightMapWidth = getLightmapTextureWidth();
+
+        int[] pixels = new int[lightMapWidth * lightMapHeight];
+        for (int u = 0; u < lightMapWidth; u++)
+        {
+            for (int v = 0; v < lightMapWidth; v++)
+            {
+                // this could probably be kept as an int, but
+                // it is easier to test and see the colors when debugging this way.
+                // When creating a new release this should be changed to the int version.
+                Color c = LodUtil.intToColor(lightMap.getLightValue(u, v));
+
+                // these should both create a totally white image
+//					int col =
+//							Integer.MAX_VALUE;
+//					int col =
+//							0b11111111 + // red
+//							(0b11111111 << 8) + // green
+//							(0b11111111 << 16) + // blue
+//							(0b11111111 << 24); // blue
+
+                int col =
+                        ((c.getRed() & 0xFF) << 16) | // blue
+                                ((c.getGreen() & 0xFF) << 8) | // green
+                                ((c.getBlue() & 0xFF)) | // red
+                                ((c.getAlpha() & 0xFF) << 24); // alpha
+
+                // 2D array stored in a 1D array.
+                // Thank you Tim from College ;)
+                pixels[u * lightMapWidth + v] = col;
+            }
+        }
+
+        return pixels;
+    }
+
+
+    @Override
+    public int getLightmapTextureHeight()
+    {
+        int height = -1;
+
+        LightTexture lightTexture = GAME_RENDERER.lightTexture();
+        if (lightTexture != null)
+        {
+            NativeImage tex = lightTexture.lightPixels;
+            if (tex != null)
+            {
+                height = tex.getHeight();
+            }
+        }
+
+        return height;
+    }
+
+    @Override
+    public int getLightmapTextureWidth()
+    {
+        int width = -1;
+
+        LightTexture lightTexture = GAME_RENDERER.lightTexture();
+        if (lightTexture != null)
+        {
+            NativeImage tex = lightTexture.lightPixels;
+            if (tex != null)
+            {
+                width = tex.getWidth();
+            }
+        }
+
+        return width;
+    }
+
+
+    @Override
+    public int getLightmapGLFormat() {
+        int glFormat = -1;
+
+        LightTexture lightTexture = GAME_RENDERER.lightTexture();
+        if (lightTexture != null) {
+            NativeImage tex = lightTexture.lightPixels;
+            if (tex != null) {
+                glFormat = tex.format().glFormat();
+            }
+        }
+
+        return glFormat;
+    }
+
+    @Override
+    public boolean isFogStateSpecial() {
+	    Entity entity = GAME_RENDERER.getMainCamera().getEntity();
+	    boolean isBlind = (entity instanceof LivingEntity) && ((LivingEntity)entity).hasEffect(MobEffects.BLINDNESS);
+    	return GAME_RENDERER.getMainCamera().getFluidInCamera() != FogType.NONE || isBlind;
+    }
+
+	@Override
+	public boolean tryDisableVanillaFog() {
+		return true; // Handled via MixinFogRenderer in both Fabric and Forge
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/minecraft/MinecraftWrapper.java

@@ -0,0 +1,430 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers.minecraft;
+
+import java.awt.Color;
+import java.io.File;
+import java.util.ArrayList;
+
+import com.mojang.blaze3d.platform.NativeImage;
+import com.mojang.blaze3d.platform.Window;
+import com.seibel.lod.core.ModInfo;
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.enums.LodDirection;
+import com.seibel.lod.core.util.LodUtil;
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftWrapper;
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IProfilerWrapper;
+import com.seibel.lod.core.wrapperInterfaces.misc.ILightMapWrapper;
+import com.seibel.lod.core.wrapperInterfaces.world.IDimensionTypeWrapper;
+import com.seibel.lod.core.wrapperInterfaces.world.IWorldWrapper;
+import com.seibel.lod.common.wrappers.McObjectConverter;
+import com.seibel.lod.common.wrappers.block.BlockPosWrapper;
+import com.seibel.lod.common.wrappers.chunk.ChunkPosWrapper;
+import com.seibel.lod.common.wrappers.misc.LightMapWrapper;
+import com.seibel.lod.common.wrappers.world.DimensionTypeWrapper;
+import com.seibel.lod.common.wrappers.world.WorldWrapper;
+
+import net.minecraft.CrashReport;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.Options;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.client.multiplayer.ServerData;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.client.renderer.LevelRenderer;
+import net.minecraft.client.renderer.LightTexture;
+import net.minecraft.client.resources.model.ModelManager;
+import net.minecraft.client.server.IntegratedServer;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.network.chat.TextComponent;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.dimension.DimensionType;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A singleton that wraps the Minecraft class
+ * to allow for easier movement between Minecraft versions.
+ *
+ * @author James Seibel
+ * @version 9-16-2021
+ */
+public class MinecraftWrapper implements IMinecraftWrapper
+{
+    public static final MinecraftWrapper INSTANCE = new MinecraftWrapper();
+
+    public final Minecraft mc = Minecraft.getInstance();
+
+    /**
+     * The lightmap for the current:
+     * Time, dimension, brightness setting, etc.
+     */
+    private NativeImage lightMap = null;
+
+    private ProfilerWrapper profilerWrapper;
+
+
+    private MinecraftWrapper()
+    {
+
+    }
+
+
+
+    //================//
+    // helper methods //
+    //================//
+
+    /**
+     * This should be called at the beginning of every frame to
+     * clear any Minecraft data that becomes out of date after a frame. <br> <br>
+     * <p>
+     * LightMaps and other time sensitive objects fall in this category. <br> <br>
+     * <p>
+     * This doesn't affect OpenGL objects in any way.
+     */
+    @Override
+    public void clearFrameObjectCache()
+    {
+        lightMap = null;
+    }
+
+
+
+    //=================//
+    // method wrappers //
+    //=================//
+
+    @Override
+    public float getShade(LodDirection lodDirection) {
+        if (mc.level != null)
+        {
+            Direction mcDir = McObjectConverter.Convert(lodDirection);
+            return mc.level.getShade(mcDir, true);
+        }
+        else return 0.0f;
+    }
+
+    @Override
+    public boolean hasSinglePlayerServer()
+    {
+        return mc.hasSingleplayerServer();
+    }
+
+    @Override
+    public String getCurrentServerName()
+    {
+        return mc.getCurrentServer().name;
+    }
+
+    @Override
+    public String getCurrentServerIp()
+    {
+        return mc.getCurrentServer().ip;
+    }
+
+    @Override
+    public String getCurrentServerVersion()
+    {
+        return mc.getCurrentServer().version.getString();
+    }
+
+    /** Returns the dimension the player is currently in */
+    @Override
+    public IDimensionTypeWrapper getCurrentDimension()
+    {
+        if (mc.player != null)
+            return DimensionTypeWrapper.getDimensionTypeWrapper(mc.player.level.dimensionType());
+        else return null;
+    }
+
+    @Override
+    public String getCurrentDimensionId()
+    {
+        return LodUtil.getDimensionIDFromWorld(WorldWrapper.getWorldWrapper(mc.level));
+    }
+
+    /** This texture changes every frame */
+    @Override
+    public ILightMapWrapper getCurrentLightMap()
+    {
+        // get the current lightMap if the cache is empty
+        if (lightMap == null)
+        {
+            LightTexture tex = mc.gameRenderer.lightTexture();
+            lightMap = tex.lightPixels;
+        }
+        return new LightMapWrapper(lightMap);
+    }
+
+    /**
+     * Returns the color int at the given pixel coordinates
+     * from the current lightmap.
+     * @param blockLight x location in texture space
+     * @param skyLight z location in texture space
+     */
+    @Override
+    public int getColorIntFromLightMap(int blockLight, int skyLight)
+    {
+        if (lightMap == null)
+        {
+            sendChatMessage("new");
+            // make sure the lightMap is up-to-date
+            getCurrentLightMap();
+        }
+
+        return lightMap.getPixelRGBA(blockLight, skyLight);
+    }
+
+    /**
+     * Returns the Color at the given pixel coordinates
+     * from the current lightmap.
+     * @param blockLight x location in texture space
+     * @param skyLight z location in texture space
+     */
+    @Override
+    public Color getColorFromLightMap(int blockLight, int skyLight) {
+        if (lightMap == null) {
+            // make sure the lightMap is up-to-date
+            getCurrentLightMap();
+        }
+
+        return LodUtil.intToColor(lightMap.getPixelRGBA(blockLight, skyLight));
+    }
+
+
+
+
+    //=============//
+    // Simple gets //
+    //=============//
+
+    public LocalPlayer getPlayer()
+    {
+        return mc.player;
+    }
+
+    @Override
+    public boolean playerExists()
+    {
+        return mc.player != null;
+    }
+
+    @Override
+    public BlockPosWrapper getPlayerBlockPos()
+    {
+        BlockPos playerPos = getPlayer().blockPosition();
+        return new BlockPosWrapper(playerPos.getX(), playerPos.getY(), playerPos.getZ());
+    }
+
+    @Override
+    public ChunkPosWrapper getPlayerChunkPos()
+    {
+        ChunkPos playerPos = getPlayer().chunkPosition();
+        return new ChunkPosWrapper(playerPos.x, playerPos.z);
+    }
+
+    public Options getOptions()
+    {
+        return mc.options;
+    }
+
+    public ModelManager getModelManager()
+    {
+        return mc.getModelManager();
+    }
+
+    public ClientLevel getClientLevel()
+    {
+        return mc.level;
+    }
+
+    @Override
+    public IWorldWrapper getWrappedServerWorld()
+    {
+        if (mc.level == null)
+            return null;
+
+        DimensionType dimension = mc.level.dimensionType();
+        IntegratedServer server = mc.getSingleplayerServer();
+
+        if (server == null)
+            return null;
+
+        ServerLevel serverWorld = null;
+        Iterable<ServerLevel> worlds = server.getAllLevels();
+        for (ServerLevel world : worlds)
+        {
+            if (world.dimensionType() == dimension)
+            {
+                serverWorld = world;
+                break;
+            }
+        }
+        return WorldWrapper.getWorldWrapper(serverWorld);
+    }
+
+    public WorldWrapper getWrappedClientLevel()
+    {
+        return WorldWrapper.getWorldWrapper(mc.level);
+    }
+
+    public WorldWrapper getWrappedServerLevel()
+    {
+
+        if (mc.level == null)
+            return null;
+        DimensionType dimension = mc.level.dimensionType();
+        IntegratedServer server = mc.getSingleplayerServer();
+        if (server == null)
+            return null;
+
+        Iterable<ServerLevel> worlds = server.getAllLevels();
+        ServerLevel returnWorld = null;
+
+        for (ServerLevel world : worlds)
+        {
+            if (world.dimensionType() == dimension)
+            {
+                returnWorld = world;
+                break;
+            }
+        }
+
+        return WorldWrapper.getWorldWrapper(returnWorld);
+    }
+
+    @Nullable
+    @Override
+    public IWorldWrapper getWrappedClientWorld()
+    {
+        return WorldWrapper.getWorldWrapper(mc.level);
+    }
+
+    @Override
+    public File getGameDirectory()
+    {
+        return mc.gameDirectory;
+    }
+
+    @Override
+    public IProfilerWrapper getProfiler()
+    {
+        if (profilerWrapper == null)
+            profilerWrapper = new ProfilerWrapper(mc.getProfiler());
+        else if (mc.getProfiler() != profilerWrapper.profiler)
+            profilerWrapper.profiler = mc.getProfiler();
+
+        return profilerWrapper;	}
+
+    public ClientPacketListener getConnection()
+    {
+        return mc.getConnection();
+    }
+
+    public GameRenderer getGameRenderer()
+    {
+        return mc.gameRenderer;
+    }
+
+    public Entity getCameraEntity()
+    {
+        return mc.cameraEntity;
+    }
+
+    public Window getWindow()
+    {
+        return mc.getWindow();
+    }
+
+    @Override
+    public float getSkyDarken(float partialTicks)
+    {
+        return mc.level.getSkyDarken(partialTicks);
+    }
+
+    public IntegratedServer getSinglePlayerServer()
+    {
+        return mc.getSingleplayerServer();
+    }
+
+    @Override
+    public boolean connectedToServer()
+    {
+        return mc.getCurrentServer() != null;
+    }
+
+    public ServerData getCurrentServer()
+    {
+        return mc.getCurrentServer();
+    }
+
+    public LevelRenderer getLevelRenderer()
+    {
+        return mc.levelRenderer;
+    }
+
+    /** Returns all worlds available to the server */
+    @Override
+    public ArrayList<IWorldWrapper> getAllServerWorlds()
+    {
+        ArrayList<IWorldWrapper> worlds = new ArrayList<IWorldWrapper>();
+
+        Iterable<ServerLevel> serverWorlds = mc.getSingleplayerServer().getAllLevels();
+        for (ServerLevel world : serverWorlds)
+        {
+            worlds.add(WorldWrapper.getWorldWrapper(world));
+        }
+
+        return worlds;
+    }
+
+
+
+    @Override
+    public void sendChatMessage(String string)
+    {
+        getPlayer().sendMessage(new TextComponent(string), getPlayer().getUUID());
+    }
+
+    /**
+     * Crashes Minecraft, displaying the given errorMessage <br> <br>
+     * In the following format: <br>
+     *
+     * The game crashed whilst <strong>errorMessage</strong>  <br>
+     * Error: <strong>ExceptionClass: exceptionErrorMessage</strong>  <br>
+     * Exit Code: -1  <br>
+     */
+    @Override
+    public void crashMinecraft(String errorMessage, Throwable exception)
+    {
+        ClientApi.LOGGER.error(ModInfo.READABLE_NAME + " had the following error: [" + errorMessage + "]. Crashing Minecraft...");
+        CrashReport report = new CrashReport(errorMessage, exception);
+        Minecraft.crash(report);
+    }
+
+
+
+
+
+}

common/src/main/java/com/seibel/lod/common/wrappers/minecraft/ProfilerWrapper.java

@@ -0,0 +1,41 @@
+package com.seibel.lod.common.wrappers.minecraft;
+
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IProfilerWrapper;
+
+import net.minecraft.util.profiling.ProfilerFiller;
+
+/**
+ * @author James Seibel
+ * @version 11-20-2021
+ */
+public class ProfilerWrapper implements IProfilerWrapper
+{
+    public ProfilerFiller profiler;
+
+    public ProfilerWrapper(ProfilerFiller newProfiler)
+    {
+        profiler = newProfiler;
+    }
+
+
+    /** starts a new section inside the currently running section */
+    @Override
+    public void push(String newSection)
+    {
+        profiler.push(newSection);
+    }
+
+    /** ends the currently running section and starts a new one */
+    @Override
+    public void popPush(String newSection)
+    {
+        profiler.popPush(newSection);
+    }
+
+    /** ends the currently running section */
+    @Override
+    public void pop()
+    {
+        profiler.pop();
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/misc/LightMapWrapper.java

@@ -0,0 +1,29 @@
+package com.seibel.lod.common.wrappers.misc;
+
+import com.mojang.blaze3d.platform.NativeImage;
+import com.seibel.lod.core.wrapperInterfaces.misc.ILightMapWrapper;
+
+/**
+ * @author James Seibel
+ * @version 11-21-2021
+ */
+public class LightMapWrapper implements ILightMapWrapper
+{
+    static NativeImage lightMap = null;
+
+    public LightMapWrapper(NativeImage newLightMap)
+    {
+        lightMap = newLightMap;
+    }
+
+    public static void setLightMap(NativeImage newLightMap)
+    {
+        lightMap = newLightMap;
+    }
+
+    @Override
+    public int getLightValue(int skyLight, int blockLight)
+    {
+        return lightMap.getPixelRGBA(skyLight, blockLight);
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/world/BiomeWrapper.java

@@ -0,0 +1,162 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers.world;
+
+import java.awt.Color;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import com.seibel.lod.core.util.LodUtil;
+import com.seibel.lod.core.wrapperInterfaces.world.IBiomeWrapper;
+
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.material.MaterialColor;
+
+//This class wraps the minecraft BlockPos.Mutable (and BlockPos) class
+public class BiomeWrapper implements IBiomeWrapper
+{
+
+    public static final ConcurrentMap<Biome, BiomeWrapper> biomeWrapperMap = new ConcurrentHashMap<>();
+    private Biome biome;
+
+    public BiomeWrapper(Biome biome)
+    {
+        this.biome = biome;
+    }
+
+    static public IBiomeWrapper getBiomeWrapper(Biome biome)
+    {
+        //first we check if the biome has already been wrapped
+        if(biomeWrapperMap.containsKey(biome) && biomeWrapperMap.get(biome) != null)
+            return biomeWrapperMap.get(biome);
+
+
+        //if it hasn't been created yet, we create it and save it in the map
+        BiomeWrapper biomeWrapper = new BiomeWrapper(biome);
+        biomeWrapperMap.put(biome, biomeWrapper);
+
+        //we return the newly created wrapper
+        return biomeWrapper;
+    }
+
+
+    /** Returns a color int for the given biome. */
+    @Override
+    public int getColorForBiome(int x, int z)
+    {
+        int colorInt;
+
+        switch (biome.getBiomeCategory())
+        {
+
+            case NETHER:
+                colorInt = Blocks.NETHERRACK.defaultBlockState().getMaterial().getColor().col;
+                break;
+
+            case THEEND:
+                colorInt = Blocks.END_STONE.defaultBlockState().getMaterial().getColor().col;
+                break;
+
+            case BEACH:
+            case DESERT:
+                colorInt = Blocks.SAND.defaultBlockState().getMaterial().getColor().col;
+                break;
+
+            case EXTREME_HILLS:
+                colorInt = Blocks.STONE.defaultMaterialColor().col;
+                break;
+
+            case MUSHROOM:
+                colorInt = MaterialColor.COLOR_LIGHT_GRAY.col;
+                break;
+
+            case ICY:
+                colorInt = Blocks.SNOW.defaultMaterialColor().col;
+                break;
+
+            case MESA:
+                colorInt = Blocks.RED_SAND.defaultMaterialColor().col;
+                break;
+
+            case OCEAN:
+            case RIVER:
+                colorInt = biome.getWaterColor();
+                break;
+
+            case NONE:
+            case FOREST:
+            case TAIGA:
+            case JUNGLE:
+            case PLAINS:
+            case SAVANNA:
+            case SWAMP:
+            default:
+                Color tmp = LodUtil.intToColor(biome.getGrassColor(x, z));
+                tmp = tmp.darker();
+                colorInt = LodUtil.colorToInt(tmp);
+                break;
+
+        }
+
+        return colorInt;
+    }
+
+    @Override
+    public String getName() {
+        return biome.toString();
+    }
+
+    @Override
+    public int getGrassTint(int x, int z)
+    {
+        return biome.getGrassColor(x, z);
+    }
+
+    @Override
+    public int getFolliageTint()
+    {
+        return biome.getFoliageColor();
+    }
+
+    @Override
+    public int getWaterTint()
+    {
+        return biome.getWaterColor();
+    }
+
+
+    @Override public boolean equals(Object obj)
+    {
+        if (this == obj)
+            return true;
+        if (!(obj instanceof BiomeWrapper))
+            return false;
+        BiomeWrapper that = (BiomeWrapper) obj;
+        return Objects.equals(biome, that.biome);
+    }
+
+    @Override public int hashCode()
+    {
+        return Objects.hash(biome);
+    }
+
+}

common/src/main/java/com/seibel/lod/common/wrappers/world/DimensionTypeWrapper.java

@@ -0,0 +1,82 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers.world;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import com.seibel.lod.core.wrapperInterfaces.world.IDimensionTypeWrapper;
+
+import net.minecraft.world.level.dimension.DimensionType;
+
+/**
+ *
+ * @author James Seibel
+ * @version 11-21-2021
+ */
+public class DimensionTypeWrapper implements IDimensionTypeWrapper
+{
+    private static final ConcurrentMap<DimensionType, DimensionTypeWrapper> dimensionTypeWrapperMap = new ConcurrentHashMap<>();
+    private DimensionType dimensionType;
+
+    public DimensionTypeWrapper(DimensionType dimensionType)
+    {
+        this.dimensionType = dimensionType;
+    }
+
+    public static DimensionTypeWrapper getDimensionTypeWrapper(DimensionType dimensionType)
+    {
+        //first we check if the biome has already been wrapped
+        if(dimensionTypeWrapperMap.containsKey(dimensionType) && dimensionTypeWrapperMap.get(dimensionType) != null)
+            return dimensionTypeWrapperMap.get(dimensionType);
+
+
+        //if it hasn't been created yet, we create it and save it in the map
+        DimensionTypeWrapper dimensionTypeWrapper = new DimensionTypeWrapper(dimensionType);
+        dimensionTypeWrapperMap.put(dimensionType, dimensionTypeWrapper);
+
+        //we return the newly created wrapper
+        return dimensionTypeWrapper;
+    }
+
+    public static void clearMap()
+    {
+        dimensionTypeWrapperMap.clear();
+    }
+
+
+    @Override
+    public String getDimensionName()
+    {
+        return dimensionType.effectsLocation().getPath();
+    }
+
+    @Override
+    public boolean hasCeiling()
+    {
+        return dimensionType.hasCeiling();
+    }
+
+    @Override
+    public boolean hasSkyLight()
+    {
+        return dimensionType.hasSkyLight();
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/world/WorldWrapper.java

@@ -0,0 +1,185 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers.world;
+
+import java.io.File;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import com.seibel.lod.core.enums.WorldType;
+import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper;
+import com.seibel.lod.core.wrapperInterfaces.world.IWorldWrapper;
+import com.seibel.lod.common.wrappers.chunk.ChunkWrapper;
+
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerChunkCache;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.LightLayer;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author James Seibel
+ * @author ??
+ * @version 11-21-2021
+ */
+public class WorldWrapper implements IWorldWrapper
+{
+    private static final ConcurrentMap<LevelAccessor, WorldWrapper> worldWrapperMap = new ConcurrentHashMap<>();
+    private final LevelAccessor world;
+    public final WorldType worldType;
+
+
+    public WorldWrapper(LevelAccessor newWorld)
+    {
+        world = newWorld;
+
+        if (world.getClass() == ServerLevel.class)
+            worldType = WorldType.ServerWorld;
+        else if (world.getClass() == ClientLevel.class)
+            worldType = WorldType.ClientWorld;
+        else
+            worldType = WorldType.Unknown;
+    }
+
+
+    @Nullable
+    public static WorldWrapper getWorldWrapper(LevelAccessor world)
+    {
+        if (world == null) return null;
+        //first we check if the biome has already been wrapped
+        if(worldWrapperMap.containsKey(world) && worldWrapperMap.get(world) != null)
+            return worldWrapperMap.get(world);
+
+
+        //if it hasn't been created yet, we create it and save it in the map
+        WorldWrapper worldWrapper = new WorldWrapper(world);
+        worldWrapperMap.put(world, worldWrapper);
+
+        //we return the newly created wrapper
+        return worldWrapper;
+    }
+
+    public static void clearMap()
+    {
+        worldWrapperMap.clear();
+    }
+
+    @Override
+    public WorldType getWorldType()
+    {
+        return worldType;
+    }
+
+    @Override
+    public DimensionTypeWrapper getDimensionType()
+    {
+        return DimensionTypeWrapper.getDimensionTypeWrapper(world.dimensionType());
+    }
+
+    @Override
+    public int getBlockLight(int x, int y, int z)
+    {
+        return world.getBrightness(LightLayer.BLOCK, new BlockPos(x,y,z));
+    }
+
+    @Override
+    public int getSkyLight(int x, int y, int z)
+    {
+        return world.getBrightness(LightLayer.SKY, new BlockPos(x,y,z));
+    }
+
+    public LevelAccessor getWorld()
+    {
+        return world;
+    }
+
+    @Override
+    public boolean hasCeiling()
+    {
+        return world.dimensionType().hasCeiling();
+    }
+
+    @Override
+    public boolean hasSkyLight()
+    {
+        return world.dimensionType().hasSkyLight();
+    }
+
+    @Override
+    public boolean isEmpty()
+    {
+        return world == null;
+    }
+
+    @Override
+    public int getHeight()
+    {
+        return world.getHeight();
+    }
+
+    @Override
+    public short getMinHeight()
+    {
+        return (short) world.getMinBuildHeight();
+    }
+
+    /** @throws UnsupportedOperationException if the WorldWrapper isn't for a ServerWorld */
+    @Override
+    public File getSaveFolder() throws UnsupportedOperationException
+    {
+        if (worldType != WorldType.ServerWorld)
+            throw new UnsupportedOperationException("getSaveFolder can only be called for ServerWorlds.");
+
+        ServerChunkCache chunkSource = ((ServerLevel) world).getChunkSource();
+        return chunkSource.getDataStorage().dataFolder;
+    }
+
+
+    /** @throws UnsupportedOperationException if the WorldWrapper isn't for a ServerWorld */
+    public ServerLevel getServerWorld() throws UnsupportedOperationException
+    {
+        if (worldType != WorldType.ServerWorld)
+            throw new UnsupportedOperationException("getSaveFolder can only be called for ServerWorlds.");
+
+        return (ServerLevel) world;
+    }
+
+    @Override
+    public int getSeaLevel()
+    {
+        // TODO this is depreciated, what should we use instead?
+        return world.getSeaLevel();
+    }
+
+    @Override
+    public IChunkWrapper tryGetChunk(AbstractChunkPosWrapper pos) {
+        ChunkAccess chunk = world.getChunk(pos.getX(), pos.getZ(), ChunkStatus.EMPTY, false);
+        if (chunk == null) return null;
+        return new ChunkWrapper(chunk, world);
+    }
+
+
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/BatchGenerationEnvironment.java

@@ -0,0 +1,553 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2021 Tom Lee (TomTheFurry)
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.common.wrappers.worldGeneration;
+
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.builders.lodBuilding.LodBuilder;
+import com.seibel.lod.core.builders.lodBuilding.LodBuilderConfig;
+import com.seibel.lod.core.enums.config.DistanceGenerationMode;
+import com.seibel.lod.core.enums.config.LightGenerationMode;
+import com.seibel.lod.core.objects.lod.LodDimension;
+import com.seibel.lod.core.util.GridList;
+import com.seibel.lod.core.util.LodThreadFactory;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.core.wrapperInterfaces.world.IWorldWrapper;
+import com.seibel.lod.core.wrapperInterfaces.worldGeneration.AbstractBatchGenerationEnvionmentWrapper;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import com.seibel.lod.common.wrappers.chunk.ChunkWrapper;
+import com.seibel.lod.common.wrappers.world.WorldWrapper;
+import com.seibel.lod.common.wrappers.worldGeneration.mimicObject.ChunkLoader;
+import com.seibel.lod.common.wrappers.worldGeneration.mimicObject.LightGetterAdaptor;
+import com.seibel.lod.common.wrappers.worldGeneration.mimicObject.LightedWorldGenRegion;
+import com.seibel.lod.common.wrappers.worldGeneration.mimicObject.WorldGenLevelLightEngine;
+import com.seibel.lod.common.wrappers.worldGeneration.step.StepBiomes;
+import com.seibel.lod.common.wrappers.worldGeneration.step.StepFeatures;
+import com.seibel.lod.common.wrappers.worldGeneration.step.StepLight;
+import com.seibel.lod.common.wrappers.worldGeneration.step.StepNoise;
+import com.seibel.lod.common.wrappers.worldGeneration.step.StepStructureReference;
+import com.seibel.lod.common.wrappers.worldGeneration.step.StepStructureStart;
+import com.seibel.lod.common.wrappers.worldGeneration.step.StepSurface;
+
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.ProtoChunk;
+import net.minecraft.world.level.chunk.UpgradeData;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+
+/*
+Total:                   3.135214124s
+=====================================
+Empty Chunks:            0.000558328s
+StructureStart Step:     0.025177207s
+StructureReference Step: 0.00189559s
+Biome Step:              0.13789155s
+Noise Step:              1.570347555s
+Surface Step:            0.741238194s
+Carver Step:             0.000009923s
+Feature Step:            0.389072425s
+Lod Generation:          0.269023348s
+*/
+
+public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnvionmentWrapper
+{
+	public static final boolean ENABLE_PERF_LOGGING = false;
+	public static final boolean ENABLE_EVENT_LOGGING = false;
+	public static final boolean ENABLE_LOAD_EVENT_LOGGING = false;
+	//TODO: Make actual proper support for StarLight
+	
+	public static class PrefEvent
+	{
+		long beginNano = 0;
+		long emptyNano = 0;
+		long structStartNano = 0;
+		long structRefNano = 0;
+		long biomeNano = 0;
+		long noiseNano = 0;
+		long surfaceNano = 0;
+		long carverNano = 0;
+		long featureNano = 0;
+		long lightNano = 0;
+		long endNano = 0;
+		
+		@Override
+		public String toString()
+		{
+			return "beginNano: " + beginNano + ",\n" +
+					"emptyNano: " + emptyNano + ",\n" +
+					"structStartNano: " + structStartNano + ",\n" +
+					"structRefNano: " + structRefNano + ",\n" +
+					"biomeNano: " + biomeNano + ",\n" +
+					"noiseNano: " + noiseNano + ",\n" +
+					"surfaceNano: " + surfaceNano + ",\n" +
+					"carverNano: " + carverNano + ",\n" +
+					"featureNano: " + featureNano + ",\n" +
+					"lightNano: " + lightNano + ",\n" +
+					"endNano: " + endNano + "\n";
+		}
+	}
+	
+	public static class PerfCalculator
+	{
+		public static final int SIZE = 50;
+		Rolling totalTime = new Rolling(SIZE);
+		Rolling emptyTime = new Rolling(SIZE);
+		Rolling structStartTime = new Rolling(SIZE);
+		Rolling structRefTime = new Rolling(SIZE);
+		Rolling biomeTime = new Rolling(SIZE);
+		Rolling noiseTime = new Rolling(SIZE);
+		Rolling surfaceTime = new Rolling(SIZE);
+		Rolling carverTime = new Rolling(SIZE);
+		Rolling featureTime = new Rolling(SIZE);
+		Rolling lightTime = new Rolling(SIZE);
+		Rolling lodTime = new Rolling(SIZE);
+		
+		public void recordEvent(PrefEvent e)
+		{
+			long preTime = e.beginNano;
+			totalTime.add(e.endNano - preTime);
+			if (e.emptyNano != 0)
+			{
+				emptyTime.add(e.emptyNano - preTime);
+				preTime = e.emptyNano;
+			}
+			if (e.structStartNano != 0)
+			{
+				structStartTime.add(e.structStartNano - preTime);
+				preTime = e.structStartNano;
+			}
+			if (e.structRefNano != 0)
+			{
+				structRefTime.add(e.structRefNano - preTime);
+				preTime = e.structRefNano;
+			}
+			if (e.biomeNano != 0)
+			{
+				biomeTime.add(e.biomeNano - preTime);
+				preTime = e.biomeNano;
+			}
+			if (e.noiseNano != 0)
+			{
+				noiseTime.add(e.noiseNano - preTime);
+				preTime = e.noiseNano;
+			}
+			if (e.surfaceNano != 0)
+			{
+				surfaceTime.add(e.surfaceNano - preTime);
+				preTime = e.surfaceNano;
+			}
+			if (e.carverNano != 0)
+			{
+				carverTime.add(e.carverNano - preTime);
+				preTime = e.carverNano;
+			}
+			if (e.featureNano != 0)
+			{
+				featureTime.add(e.featureNano - preTime);
+				preTime = e.featureNano;
+			}
+			if (e.lightNano != 0)
+			{
+				lightTime.add(e.lightNano - preTime);
+				preTime = e.lightNano;
+			}
+			if (e.endNano != 0)
+			{
+				lodTime.add(e.endNano - preTime);
+				preTime = e.endNano;
+			}
+		}
+		
+		public String toString()
+		{
+			return "Total: " + Duration.ofNanos((long) totalTime.getAverage()) + ", Empty/LoadChunk: "
+					+ Duration.ofNanos((long) emptyTime.getAverage()) + ", StructStart: "
+					+ Duration.ofNanos((long) structStartTime.getAverage()) + ", StructRef: "
+					+ Duration.ofNanos((long) structRefTime.getAverage()) + ", Biome: "
+					+ Duration.ofNanos((long) biomeTime.getAverage()) + ", Noise: "
+					+ Duration.ofNanos((long) noiseTime.getAverage()) + ", Surface: "
+					+ Duration.ofNanos((long) surfaceTime.getAverage()) + ", Carver: "
+					+ Duration.ofNanos((long) carverTime.getAverage()) + ", Feature: "
+					+ Duration.ofNanos((long) featureTime.getAverage()) + ", Light: "
+					+ Duration.ofNanos((long) lightTime.getAverage()) + ", Lod: "
+					+ Duration.ofNanos((long) lodTime.getAverage());
+		}
+	}
+	
+	public static final int TIMEOUT_SECONDS = 30;
+	
+	//=================Generation Step===================
+	
+	public final LinkedList<GenerationEvent> events = new LinkedList<GenerationEvent>();
+	public final GlobalParameters params;
+	public final StepStructureStart stepStructureStart = new StepStructureStart(this);
+	public final StepStructureReference stepStructureReference = new StepStructureReference(this);
+	public final StepBiomes stepBiomes = new StepBiomes(this);
+	public final StepNoise stepNoise = new StepNoise(this);
+	public final StepSurface stepSurface = new StepSurface(this);
+	public final StepFeatures stepFeatures = new StepFeatures(this);
+	public final StepLight stepLight = new StepLight(this);
+	private static final ILodConfigWrapperSingleton CONFIG = SingletonHandler.get(ILodConfigWrapperSingleton.class);
+	
+	public static final LodThreadFactory threadFactory = new LodThreadFactory("Gen-Worker-Thread", Thread.MIN_PRIORITY);
+	
+	public ExecutorService executors = Executors.newFixedThreadPool(
+			CONFIG.client().advanced().threading().getNumberOfWorldGenerationThreads(), threadFactory);
+	
+	public void resizeThreadPool(int newThreadCount)
+	{
+		executors = Executors.newFixedThreadPool(newThreadCount,
+				new LodThreadFactory("Gen-Worker-Thread", Thread.MIN_PRIORITY));
+	}
+	
+	public boolean tryAddPoint(int px, int pz, int range, Steps target, boolean genAllDetails)
+	{
+		int boxSize = range * 2 + 1;
+		int x = Math.floorDiv(px, boxSize) * boxSize + range;
+		int z = Math.floorDiv(pz, boxSize) * boxSize + range;
+		
+		for (GenerationEvent event : events)
+		{
+			if (event.tooClose(x, z, range))
+				return false;
+		}
+		// System.out.println(x + ", "+z);
+		events.add(new GenerationEvent(new ChunkPos(x, z), range, this, target, genAllDetails));
+		return true;
+	}
+	
+	public void updateAllFutures()
+	{
+		// Update all current out standing jobs
+		Iterator<GenerationEvent> iter = events.iterator();
+		while (iter.hasNext())
+		{
+			GenerationEvent event = iter.next();
+			if (event.isCompleted())
+			{
+				try
+				{
+					event.join();
+				}
+				catch (Throwable e)
+				{
+					e.printStackTrace();
+					while (e.getCause() != null)
+					{
+						e = e.getCause();
+						e.printStackTrace();
+					}
+				}
+				finally
+				{
+					iter.remove();
+				}
+			}
+			else if (event.hasTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS))
+			{
+				ClientApi.LOGGER.error("Batching World Generator: " + event + " timed out and terminated!");
+				ClientApi.LOGGER.info("Dump PrefEvent: " + event.pEvent);
+				try
+				{
+					if (!event.terminate())
+						ClientApi.LOGGER.error("Failed to terminate the stuck generation event!");
+				}
+				finally
+				{
+					iter.remove();
+				}
+			}
+		}
+	}
+	
+	public BatchGenerationEnvironment(IWorldWrapper serverlevel, LodBuilder lodBuilder, LodDimension lodDim)
+	{
+		super(serverlevel, lodBuilder, lodDim);
+		ClientApi.LOGGER.info("================WORLD_GEN_STEP_INITING=============");
+		params = new GlobalParameters((ServerLevel) ((WorldWrapper) serverlevel).getWorld(), lodBuilder, lodDim);
+	}
+	
+	public void startLoadingAllRegionsFromFile(LodDimension lodDim)
+	{
+		ServerLevel level = params.level;
+		level.getChunkSource();
+		
+	}
+	
+	@SuppressWarnings("resource")
+	public static ChunkAccess loadOrMakeChunk(ChunkPos chunkPos, ServerLevel level, LevelLightEngine lightEngine)
+	{
+		CompoundTag chunkData = null;
+		try
+		{
+			chunkData = level.getChunkSource().chunkMap.readChunk(chunkPos);
+		}
+		catch (IOException e)
+		{
+			ClientApi.LOGGER.error("DistantHorizons: Couldn't load chunk {}", chunkPos, e);
+		}
+		if (chunkData == null)
+		{
+			return new ProtoChunk(chunkPos, UpgradeData.EMPTY, level);
+		}
+		else
+		{
+			return ChunkLoader.read(level, lightEngine, chunkPos, chunkData);
+		}
+		
+	}
+	
+	
+	
+	public void generateLodFromList(GenerationEvent e)
+	{
+		if (ENABLE_EVENT_LOGGING)
+			ClientApi.LOGGER.info("Lod Generate Event: " + e.pos);
+		e.pEvent.beginNano = System.nanoTime();
+		GridList<ChunkAccess> referencedChunks;
+		DistanceGenerationMode generationMode;
+		LightedWorldGenRegion region;
+		WorldGenLevelLightEngine lightEngine;
+		LightGetterAdaptor adaptor;
+		
+		try
+		{
+			adaptor = new LightGetterAdaptor(params.level);
+			lightEngine = new WorldGenLevelLightEngine(adaptor);
+			
+			int cx = e.pos.x;
+			int cy = e.pos.z;
+			int rangeEmpty = e.range + 1;
+			GridList<ChunkAccess> chunks = new GridList<ChunkAccess>(rangeEmpty);
+			
+			@SuppressWarnings("resource")
+			EmptyChunkGenerator generator = (int x, int z) ->
+			{
+				ChunkPos chunkPos = new ChunkPos(x, z);
+				ChunkAccess target = null;
+				try
+				{
+					target = loadOrMakeChunk(chunkPos, params.level, lightEngine);
+				}
+				catch (RuntimeException e2)
+				{
+					// Continue...
+					e2.printStackTrace();
+				}
+				if (target == null)
+					target = new ProtoChunk(chunkPos, UpgradeData.EMPTY, params.level);
+				return target;
+			};
+			
+			for (int oy = -rangeEmpty; oy <= rangeEmpty; oy++)
+			{
+				for (int ox = -rangeEmpty; ox <= rangeEmpty; ox++)
+				{
+					ChunkAccess target = generator.generate(cx + ox, cy + oy);
+					chunks.add(target);
+				}
+			}
+			e.pEvent.emptyNano = System.nanoTime();
+			e.refreshTimeout();
+			region = new LightedWorldGenRegion(params.level, lightEngine, e.tParam.structFeat, chunks, ChunkStatus.STRUCTURE_STARTS, rangeEmpty, e.lightMode, generator);
+			adaptor.setRegion(region);
+			e.tParam.makeStructFeat(region);
+			referencedChunks = chunks.subGrid(e.range);
+			referencedChunks = generateDirect(e, referencedChunks, e.target, region);
+			
+		}
+		catch (StepStructureStart.StructStartCorruptedException f)
+		{
+			e.tParam.markAsInvalid();
+			return;
+		}
+		
+		switch (e.target)
+		{
+		case Empty:
+		case StructureStart:
+		case StructureReference:
+			generationMode = DistanceGenerationMode.NONE;
+			break;
+		case Biomes:
+			generationMode = DistanceGenerationMode.BIOME_ONLY;
+		case Noise:
+			generationMode = DistanceGenerationMode.BIOME_ONLY_SIMULATE_HEIGHT;
+			break;
+		case Surface:
+		case Carvers:
+			generationMode = DistanceGenerationMode.SURFACE;
+			break;
+		case Features:
+			generationMode = DistanceGenerationMode.FEATURES;
+			break;
+		case Light:
+		case LiquidCarvers:
+		default:
+			return;
+		}
+		int centreIndex = referencedChunks.size() / 2;
+		
+		for (int oy = -e.range; oy <= e.range; oy++)
+		{
+			for (int ox = -e.range; ox <= e.range; ox++)
+			{
+				int targetIndex = referencedChunks.offsetOf(centreIndex, ox, oy);
+				ChunkAccess target = referencedChunks.get(targetIndex);
+				target.setLightCorrect(true);
+				//if (target instanceof LevelChunk)
+				//	((LevelChunk) target).setClientLightReady(true);
+				boolean isFull = target.getStatus() == ChunkStatus.FULL || target instanceof LevelChunk;
+				//boolean isPartial = target.isOldNoiseGeneration();
+				if (isFull)
+				{
+					if (ENABLE_LOAD_EVENT_LOGGING)
+						ClientApi.LOGGER.info("Detected full existing chunk at {}", target.getPos());
+					params.lodBuilder.generateLodNodeFromChunk(params.lodDim, new ChunkWrapper(target, region),
+							new LodBuilderConfig(DistanceGenerationMode.FULL), true, e.genAllDetails);
+				}
+				else if (target.getStatus() == ChunkStatus.EMPTY && generationMode == DistanceGenerationMode.NONE)
+				{
+					params.lodBuilder.generateLodNodeFromChunk(params.lodDim, new ChunkWrapper(target, region),
+							LodBuilderConfig.getFillVoidConfig(), true, e.genAllDetails);
+				}
+				else
+				{
+					params.lodBuilder.generateLodNodeFromChunk(params.lodDim, new ChunkWrapper(target, region),
+							new LodBuilderConfig(generationMode), true, e.genAllDetails);
+				}
+				if (e.lightMode == LightGenerationMode.FANCY || isFull)
+				{
+					lightEngine.retainData(target.getPos(), false);
+				}
+				
+			}
+		}
+		e.pEvent.endNano = System.nanoTime();
+		e.refreshTimeout();
+		if (ENABLE_PERF_LOGGING)
+		{
+			e.tParam.perf.recordEvent(e.pEvent);
+			ClientApi.LOGGER.info(e.tParam.perf);
+		}
+	}
+	
+	public GridList<ChunkAccess> generateDirect(GenerationEvent e, GridList<ChunkAccess> subRange, Steps step,
+			LightedWorldGenRegion region)
+	{
+		try
+		{
+			subRange.forEach((chunk) ->
+			{
+				if (chunk instanceof ProtoChunk)
+				{
+					((ProtoChunk) chunk).setLightEngine(region.getLightEngine());
+					region.getLightEngine().retainData(chunk.getPos(), true);
+				}
+			});
+			if (step == Steps.Empty)
+				return subRange;
+			stepStructureStart.generateGroup(e.tParam, region, subRange);
+			e.pEvent.structStartNano = System.nanoTime();
+			e.refreshTimeout();
+			if (step == Steps.StructureStart)
+				return subRange;
+			stepStructureReference.generateGroup(e.tParam, region, subRange);
+			e.pEvent.structRefNano = System.nanoTime();
+			e.refreshTimeout();
+			if (step == Steps.StructureReference)
+				return subRange;
+			stepBiomes.generateGroup(e.tParam, region, subRange);
+			e.pEvent.biomeNano = System.nanoTime();
+			e.refreshTimeout();
+			if (step == Steps.Biomes)
+				return subRange;
+			stepNoise.generateGroup(e.tParam, region, subRange);
+			e.pEvent.noiseNano = System.nanoTime();
+			e.refreshTimeout();
+			if (step == Steps.Noise)
+				return subRange;
+			stepSurface.generateGroup(e.tParam, region, subRange);
+			e.pEvent.surfaceNano = System.nanoTime();
+			e.refreshTimeout();
+			if (step == Steps.Surface)
+				return subRange;
+			if (step == Steps.Carvers)
+				return subRange;
+			stepFeatures.generateGroup(e.tParam, region, subRange);
+			e.pEvent.featureNano = System.nanoTime();
+			e.refreshTimeout();
+			return subRange;
+		}
+		finally
+		{
+			switch (region.lightMode)
+			{
+			case FANCY:
+				stepLight.generateGroup(region.getLightEngine(), subRange);
+				break;
+			case FAST:
+				subRange.forEach((p) ->
+				{
+					if (p instanceof ProtoChunk)
+						((ProtoChunk) p).setLightCorrect(true);
+				});
+				break;
+			}
+			e.pEvent.lightNano = System.nanoTime();
+			e.refreshTimeout();
+		}
+	}
+	
+	public interface EmptyChunkGenerator
+	{
+		ChunkAccess generate(int x, int z);
+	}
+
+	@Override
+	public int getEventCount() {
+		return events.size();
+	}
+
+	@Override
+	public void stop(boolean blocking) {
+		ClientApi.LOGGER.info("Batch Chunk Generator shutting down...");
+		executors.shutdownNow();
+		if (blocking) try {
+			if (!executors.awaitTermination(10, TimeUnit.SECONDS)) {
+				ClientApi.LOGGER.error("Batch Chunk Generator shutdown failed! Ignoring child threads...");
+			}
+		} catch (InterruptedException e) {
+			ClientApi.LOGGER.error("Batch Chunk Generator shutdown failed! Ignoring child threads...", e);
+		}
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/GenerationEvent.java

@@ -0,0 +1,104 @@
+
+package com.seibel.lod.common.wrappers.worldGeneration;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment.PrefEvent;
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.enums.config.LightGenerationMode;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.core.wrapperInterfaces.worldGeneration.AbstractBatchGenerationEnvionmentWrapper.Steps;
+
+import net.minecraft.world.level.ChunkPos;
+
+//======================= Main Event class======================
+public final class GenerationEvent
+{
+	static private final ILodConfigWrapperSingleton CONFIG = SingletonHandler.get(ILodConfigWrapperSingleton.class);
+	
+	private static int generationFutureDebugIDs = 0;
+	final ThreadedParameters tParam;
+	final ChunkPos pos;
+	final int range;
+	final Future<?> future;
+	long nanotime;
+	final int id;
+	final Steps target;
+	final LightGenerationMode lightMode;
+	final PrefEvent pEvent = new PrefEvent();
+	final boolean genAllDetails;
+	
+	public GenerationEvent(ChunkPos pos, int range, BatchGenerationEnvironment generationGroup, Steps target, boolean genAllDetails)
+	{
+		nanotime = System.nanoTime();
+		this.pos = pos;
+		this.range = range;
+		id = generationFutureDebugIDs++;
+		this.target = target;
+		this.tParam = ThreadedParameters.getOrMake(generationGroup.params);
+		LightGenerationMode mode = CONFIG.client().worldGenerator().getLightGenerationMode();
+		
+		this.lightMode = mode;
+		this.genAllDetails = genAllDetails;
+		
+		future = generationGroup.executors.submit(() ->
+		{
+			generationGroup.generateLodFromList(this);
+		});
+	}
+	
+	public boolean isCompleted()
+	{
+		return future.isDone();
+	}
+	
+	public boolean hasTimeout(int duration, TimeUnit unit)
+	{
+		long currentTime = System.nanoTime();
+		long delta = currentTime - nanotime;
+		return (delta > TimeUnit.NANOSECONDS.convert(duration, unit));
+	}
+	
+	public boolean terminate()
+	{
+		future.cancel(true);
+		ClientApi.LOGGER.info("======================DUMPING ALL THREADS FOR WORLD GEN=======================");
+		BatchGenerationEnvironment.threadFactory.dumpAllThreadStacks();
+		return future.isCancelled();
+	}
+	
+	public void join()
+	{
+		try
+		{
+			future.get();
+		}
+		catch (InterruptedException | ExecutionException e)
+		{
+			e.printStackTrace();
+		}
+	}
+	
+	public boolean tooClose(int cx, int cz, int cr)
+	{
+		int distX = Math.abs(cx - pos.x);
+		int distZ = Math.abs(cz - pos.z);
+		int minRange = cr + range + 1; // Need one to account for the center
+		minRange += 1 + 1; // Account for required empty chunks
+		return distX < minRange && distZ < minRange;
+	}
+	
+	public void refreshTimeout()
+	{
+		nanotime = System.nanoTime();
+	}
+	
+	@Override
+	public String toString()
+	{
+		return id + ":" + range + "@" + pos + "(" + target + ")";
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/GlobalParameters.java

@@ -0,0 +1,51 @@
+
+package com.seibel.lod.common.wrappers.worldGeneration;
+
+import com.mojang.datafixers.DataFixer;
+import com.seibel.lod.core.builders.lodBuilding.LodBuilder;
+import com.seibel.lod.core.objects.lod.LodDimension;
+
+import net.minecraft.core.Registry;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ThreadedLevelLightEngine;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.WorldGenSettings;
+import net.minecraft.world.level.levelgen.structure.templatesystem.StructureManager;
+import net.minecraft.world.level.storage.WorldData;
+
+public final class GlobalParameters
+{
+	public final ChunkGenerator generator;
+	public final StructureManager structures;
+	//public final BiomeManager biomeManager;
+	public final WorldGenSettings worldGenSettings;
+	public final ThreadedLevelLightEngine lightEngine;
+	public final LodBuilder lodBuilder;
+	public final LodDimension lodDim;
+	public final Registry<Biome> biomes;
+	public final RegistryAccess registry;
+	public final long worldSeed;
+	public final ServerLevel level; // TODO: Figure out a way to remove this. Maybe ClientLevel also works?
+	public final DataFixer fixerUpper;
+	
+	public GlobalParameters(ServerLevel level, LodBuilder lodBuilder, LodDimension lodDim)
+	{
+		this.lodBuilder = lodBuilder;
+		this.lodDim = lodDim;
+		this.level = level;
+		lightEngine = (ThreadedLevelLightEngine) level.getLightEngine();
+		MinecraftServer server = level.getServer();
+		WorldData worldData = server.getWorldData();
+		worldGenSettings = worldData.worldGenSettings();
+		registry = server.registryAccess();
+		biomes = registry.registryOrThrow(Registry.BIOME_REGISTRY);
+		worldSeed = worldGenSettings.seed();
+		//biomeManager = new BiomeManager(level, BiomeManager.obfuscateSeed(worldSeed));
+		structures = server.getStructureManager();
+		generator = level.getChunkSource().getGenerator();
+		fixerUpper = server.getFixerUpper();
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/Rolling.java

@@ -0,0 +1,34 @@
+
+package com.seibel.lod.common.wrappers.worldGeneration;
+
+//FIXME: Move this outside the WorldGenerationStep thingy
+public class Rolling
+{
+	
+	private final int size;
+	private double total = 0d;
+	private int index = 0;
+	private final double[] samples;
+	
+	public Rolling(int size)
+	{
+		this.size = size;
+		samples = new double[size];
+		for (int i = 0; i < size; i++)
+			samples[i] = 0d;
+	}
+	
+	public void add(double x)
+	{
+		total -= samples[index];
+		samples[index] = x;
+		total += x;
+		if (++index == size)
+			index = 0; // cheaper than modulus
+	}
+	
+	public double getAverage()
+	{
+		return total / size;
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/ThreadedParameters.java

@@ -0,0 +1,44 @@
+
+package com.seibel.lod.common.wrappers.worldGeneration;
+
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment.PerfCalculator;
+import com.seibel.lod.common.wrappers.worldGeneration.mimicObject.WorldGenStructFeatManager;
+
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.levelgen.WorldGenSettings;
+
+public final class ThreadedParameters
+{
+	private static final ThreadLocal<ThreadedParameters> localParam = new ThreadLocal<ThreadedParameters>();
+	final ServerLevel level;
+	public final WorldGenStructFeatManager structFeat;
+	boolean isValid = true;
+	public final PerfCalculator perf = new PerfCalculator();
+	
+	public static ThreadedParameters getOrMake(GlobalParameters param)
+	{
+		ThreadedParameters tParam = localParam.get();
+		if (tParam != null && tParam.isValid && tParam.level == param.level)
+			return tParam;
+		tParam = new ThreadedParameters(param);
+		localParam.set(tParam);
+		return tParam;
+	}
+	
+	public void markAsInvalid()
+	{
+		isValid = false;
+	}
+	
+	private ThreadedParameters(GlobalParameters param)
+	{
+		level = param.level;
+		structFeat = new WorldGenStructFeatManager(level, param.worldGenSettings, null);
+	}
+	
+	public void makeStructFeat(WorldGenLevel genLevel)
+	{
+		structFeat.setGenLevel(genLevel);
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/WorldGeneratorWrapper.java

@@ -0,0 +1,152 @@
+package com.seibel.lod.common.wrappers.worldGeneration;
+
+import com.seibel.lod.core.builders.lodBuilding.LodBuilder;
+import com.seibel.lod.core.builders.lodBuilding.LodBuilderConfig;
+import com.seibel.lod.core.enums.config.DistanceGenerationMode;
+import com.seibel.lod.core.objects.lod.LodDimension;
+//import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
+//import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.core.wrapperInterfaces.world.IWorldWrapper;
+import com.seibel.lod.core.wrapperInterfaces.worldGeneration.AbstractWorldGeneratorWrapper;
+import com.seibel.lod.common.wrappers.chunk.ChunkWrapper;
+import com.seibel.lod.common.wrappers.world.WorldWrapper;
+
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.chunk.*;
+
+/**
+ * @author James Seibel
+ * @version 11-13-2021
+ */
+public class WorldGeneratorWrapper extends AbstractWorldGeneratorWrapper
+{
+    public final ServerLevel serverWorld;
+    public final LodDimension lodDim;
+    public final LodBuilder lodBuilder;
+
+    public WorldGeneratorWrapper(LodBuilder newLodBuilder, LodDimension newLodDimension, IWorldWrapper worldWrapper)
+    {
+        super(newLodBuilder, newLodDimension, worldWrapper);
+
+        lodBuilder = newLodBuilder;
+        lodDim = newLodDimension;
+        serverWorld = ((WorldWrapper) worldWrapper).getServerWorld();
+    }
+
+
+    /** takes about 2-5 ms */
+    @Override
+    public void generateBiomesOnly(AbstractChunkPosWrapper pos, DistanceGenerationMode generationMode)
+    {
+        generate(pos.getX(), pos.getZ(), generationMode);
+    }
+
+
+    /** takes about 10 - 20 ms */
+    @Override
+    public void generateSurface(AbstractChunkPosWrapper pos)
+    {
+        generate(pos.getX(), pos.getZ(), DistanceGenerationMode.SURFACE);
+    }
+
+
+    /**
+     * takes about 15 - 20 ms
+     * <p>
+     */
+    @Override
+    public void generateFeatures(AbstractChunkPosWrapper pos)
+    {
+        generate(pos.getX(), pos.getZ(), DistanceGenerationMode.FEATURES);
+    }
+
+
+    /**
+     * Generates using MC's ServerWorld.
+     * <p>
+     * on pre generated chunks 0 - 1 ms <br>
+     * on un generated chunks 0 - 50 ms <br>
+     * with the median seeming to hover around 15 - 30 ms <br>
+     * and outliers in the 100 - 200 ms range <br>
+     * <p>
+     * Note this should not be multithreaded and does cause server/simulation lag
+     * (Higher lag for generating than loading)
+     */
+    @Override
+    public void generateFull(AbstractChunkPosWrapper pos)
+    {
+        generate(pos.getX(), pos.getZ(), DistanceGenerationMode.FULL);
+    }
+
+    private void generate(int chunkX, int chunkZ, DistanceGenerationMode generationMode) {
+
+//        long t = System.nanoTime();
+
+        ChunkStatus targetStatus;
+        switch (generationMode) {
+		case BIOME_ONLY:
+                targetStatus = ChunkStatus.BIOMES;
+                break;
+            case BIOME_ONLY_SIMULATE_HEIGHT:
+                targetStatus = ChunkStatus.NOISE;
+                break;
+            case SURFACE:
+                targetStatus = ChunkStatus.SURFACE;
+                break;
+            case FEATURES:
+                targetStatus = ChunkStatus.FEATURES;
+                break;
+            case FULL:
+                targetStatus = ChunkStatus.FULL;
+                break;
+		case NONE:
+		default:
+                return;
+        }
+
+        // The bool=true means that we want to generate chunk, and that the returned ChunkAccess must not be null
+
+        ChunkAccess ca = serverWorld.getChunkSource().getChunk(chunkX, chunkZ, targetStatus, true);
+        if (ca == null) throw new RuntimeException("This should NEVER be null due to bool being true");
+        lodBuilder.generateLodNodeFromChunk(lodDim, new ChunkWrapper(ca, serverWorld), new LodBuilderConfig(generationMode), false, true);
+
+        // long duration = System.nanoTime()-t;
+
+        // Debug print the duration
+        // System.out.println("LodChunkGenFull["+chunkX+","+chunkZ+"]: "+(double)(duration)/1000.);
+    }
+
+
+
+
+
+
+
+	/* TODO: Ask leetom to update chart
+	 * performance/generation tests related to
+	 * serverWorld.getChunk(x, z, ChunkStatus. *** )
+
+     true/false is whether they generated blocks or not
+     the time is how long it took to generate
+
+     ChunkStatus.EMPTY					0  - 1  ms	false	(empty, what did you expect? :P)
+     ChunkStatus.STRUCTURE_REFERENCES	1  - 2  ms  false	(no height, only generates some chunks)
+     ChunkStatus.BIOMES 				1  - 10 ms	false	(no height)
+     ChunkStatus.NOISE					4  - 15 ms	true	(all blocks are stone)
+     ChunkStatus.LIQUID_CARVERS			6  - 12 ms	true	(no snow/trees, just grass)
+     ChunkStatus.SURFACE				5  - 15 ms	true	(no snow/trees, just grass)
+     ChunkStatus.CARVERS				5  - 30 ms	true	(no snow/trees, just grass)
+     ChunkStatus.FEATURES				7  - 25 ms	true
+     ChunkStatus.HEIGHTMAPS 			20 - 40 ms	true
+     ChunkStatus.LIGHT					20 - 40 ms	true
+     ChunkStatus.FULL 					30 - 50 ms	true
+     ChunkStatus.SPAWN			   		50 - 80 ms	true
+
+
+     At this point I would suggest using FEATURES, as it generates snow and trees
+     (and any other object that are needed to make biomes distinct)
+
+     Otherwise, if snow/trees aren't necessary SURFACE is the next fastest (although not by much)
+	 */
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/mimicObject/ChunkLoader.java

@@ -0,0 +1,148 @@
+
+package com.seibel.lod.common.wrappers.worldGeneration.mimicObject;
+
+import com.seibel.lod.core.api.ClientApi;
+
+import java.util.Objects;
+
+import net.minecraft.core.Registry;
+import net.minecraft.core.SectionPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.ChunkTickList;
+import net.minecraft.world.level.LightLayer;
+import net.minecraft.world.level.TickList;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.chunk.ChunkBiomeContainer;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.DataLayer;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.LevelChunkSection;
+import net.minecraft.world.level.chunk.ProtoTickList;
+import net.minecraft.world.level.chunk.UpgradeData;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraft.world.level.material.Fluids;
+
+import org.apache.logging.log4j.Logger;
+
+public class ChunkLoader {
+	private static final Logger LOGGER = ClientApi.LOGGER;
+
+	private static LevelChunkSection[] readSections(WorldGenLevel level, LevelLightEngine lightEngine,
+			ChunkPos chunkPos, CompoundTag tagLevel) {
+		boolean isLightOn = tagLevel.getBoolean("isLightOn");
+		ListTag listTag = tagLevel.getList("Sections", 10);
+        int i = level.getSectionsCount();
+		LevelChunkSection[] levelChunkSections = new LevelChunkSection[i];
+		boolean bl2 = level.getLevel().dimensionType().hasSkyLight();
+		if (isLightOn)
+			lightEngine.retainData(chunkPos, true);
+		for (int j = 0; j < listTag.size(); j++) {
+			CompoundTag compoundTag3 = listTag.getCompound(j);
+			int k = compoundTag3.getByte("Y");
+			if (compoundTag3.contains("Palette", 9) && compoundTag3.contains("BlockStates", 12)) {
+				LevelChunkSection levelChunkSection = new LevelChunkSection(k << 4);
+				levelChunkSection.getStates().read(compoundTag3.getList("Palette", 10),
+						compoundTag3.getLongArray("BlockStates"));
+				levelChunkSection.recalcBlockCounts();
+				if (!levelChunkSection.isEmpty())
+					levelChunkSections[level.getSectionIndexFromSectionY(k)] = levelChunkSection;
+			}
+			if (isLightOn) {
+				if (compoundTag3.contains("BlockLight", 7))
+					lightEngine.queueSectionData(LightLayer.BLOCK, SectionPos.of(chunkPos, k),
+							new DataLayer(compoundTag3.getByteArray("BlockLight")), true);
+				if (bl2 && compoundTag3.contains("SkyLight", 7))
+					lightEngine.queueSectionData(LightLayer.SKY, SectionPos.of(chunkPos, k),
+							new DataLayer(compoundTag3.getByteArray("SkyLight")), true);
+			}
+		}
+		return levelChunkSections;
+	}
+
+	private static void readHeightmaps(LevelChunk chunk, CompoundTag chunkData) {
+		CompoundTag tagHeightmaps = chunkData.getCompound("Heightmaps");
+		for (Heightmap.Types type : ChunkStatus.FULL.heightmapsAfter()) {
+			String heightmap = type.getSerializationKey();
+			if (tagHeightmaps.contains(heightmap, 12))
+				chunk.setHeightmap(type, tagHeightmaps.getLongArray(heightmap));
+		}
+		Heightmap.primeHeightmaps(chunk, ChunkStatus.FULL.heightmapsAfter());
+	}
+
+	private static void readPostPocessings(LevelChunk chunk, CompoundTag chunkData) {
+		ListTag tagPostProcessings = chunkData.getList("PostProcessing", 9);
+		for (int n = 0; n < tagPostProcessings.size(); ++n) {
+			ListTag listTag3 = tagPostProcessings.getList(n);
+			for (int o = 0; o < listTag3.size(); ++o) {
+				chunk.addPackedPostProcess(listTag3.getShort(o), n);
+			}
+		}
+	}
+
+	public static ChunkStatus.ChunkType readChunkType(CompoundTag tagLevel) {
+		ChunkStatus chunkStatus = ChunkStatus.byName(tagLevel.getString("Status"));
+		if (chunkStatus != null) {
+			return chunkStatus.getChunkType();
+		}
+		return ChunkStatus.ChunkType.PROTOCHUNK;
+	}
+
+	public static LevelChunk read(WorldGenLevel level, LevelLightEngine lightEngine, ChunkPos chunkPos,
+			CompoundTag chunkData) {
+		CompoundTag tagLevel = chunkData.getCompound("Level");
+
+		ChunkStatus.ChunkType chunkType = readChunkType(tagLevel);
+		if (chunkType != ChunkStatus.ChunkType.LEVELCHUNK)
+			return null;
+
+		ChunkPos actualPos = new ChunkPos(tagLevel.getInt("xPos"), tagLevel.getInt("zPos"));
+		if (!Objects.equals(chunkPos, actualPos)) {
+			LOGGER.error("Distant Horizons: Chunk file at {} is in the wrong location; Ignoring. (Expected {}, got {})",
+					(Object) chunkPos, (Object) chunkPos, (Object) actualPos);
+			return null;
+		}
+
+		// ====================== Read params for making the LevelChunk
+		// ============================
+		ChunkBiomeContainer chunkBiomeContainer = new ChunkBiomeContainer(
+				level.getLevel().registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), level, chunkPos,
+				level.getLevel().getChunkSource().getGenerator().getBiomeSource(),
+				tagLevel.contains("Biomes", 11) ? tagLevel.getIntArray("Biomes") : null);
+
+		UpgradeData upgradeData = tagLevel.contains("UpgradeData", 10)
+				? new UpgradeData(tagLevel.getCompound("UpgradeData"), level)
+				: UpgradeData.EMPTY;
+
+		TickList<Block> blockTicks = tagLevel.contains("TileTicks", 9)
+				? ChunkTickList.create(tagLevel.getList("TileTicks", 10), Registry.BLOCK::getKey, Registry.BLOCK::get)
+				: new ProtoTickList<Block>(block -> (block == null || block.defaultBlockState().isAir()), chunkPos,
+						tagLevel.getList("ToBeTicked", 9), level);
+
+		TickList<Fluid> liquidTicks = tagLevel.contains("LiquidTicks", 9)
+				? ChunkTickList.create(tagLevel.getList("LiquidTicks", 10), Registry.FLUID::getKey, Registry.FLUID::get)
+				: new ProtoTickList<Fluid>(fluid -> (fluid == null || fluid == Fluids.EMPTY), chunkPos,
+						tagLevel.getList("LiquidsToBeTicked", 9), level);
+
+		long inhabitedTime = tagLevel.getLong("InhabitedTime");
+
+		LevelChunkSection[] levelChunkSections = readSections(level, lightEngine, chunkPos, tagLevel);
+
+		// ======================== Make the chunk
+		// ===========================================
+		LevelChunk chunk = new LevelChunk(level.getLevel(), chunkPos, chunkBiomeContainer, upgradeData, blockTicks,
+				liquidTicks, inhabitedTime, levelChunkSections, null);
+
+		// ========================== Post setup some chunk data
+		// ==============================
+		chunk.setLightCorrect(tagLevel.getBoolean("isLightOn"));
+		readHeightmaps(chunk, tagLevel);
+		readPostPocessings(chunk, tagLevel);
+		// ClientApi.LOGGER.info("Loaded chunk @ "+chunk.getPos());
+		return chunk;
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/mimicObject/LightGetterAdaptor.java

@@ -0,0 +1,40 @@
+package com.seibel.lod.common.wrappers.worldGeneration.mimicObject;
+
+import com.seibel.lod.core.api.ModAccessorApi;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IStarlightAccessor;
+
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.LevelHeightAccessor;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.LightChunkGetter;
+
+public class LightGetterAdaptor implements LightChunkGetter {
+	private final BlockGetter heightGetter;
+	public LightedWorldGenRegion genRegion = null;
+	final boolean shouldReturnNull;
+
+	public LightGetterAdaptor(BlockGetter heightAccessor) {
+		this.heightGetter = heightAccessor;
+		shouldReturnNull = ModAccessorApi.get(IStarlightAccessor.class) != null;
+	}
+
+	public void setRegion(LightedWorldGenRegion region) {
+		genRegion = region;
+	}
+
+	@Override
+	public BlockGetter getChunkForLighting(int chunkX, int chunkZ) {
+		if (genRegion == null)
+			throw new IllegalStateException("World Gen region has not been set!");
+		// May be null
+		return genRegion.getChunk(chunkX, chunkZ, ChunkStatus.EMPTY, false);
+	}
+
+	@Override
+	public BlockGetter getLevel() {
+		return shouldReturnNull ? null : (genRegion != null ? genRegion : heightGetter);
+	}
+	public LevelHeightAccessor getLevelHeightAccessor() {
+		return heightGetter;
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/mimicObject/LightedWorldGenRegion.java

@@ -0,0 +1,227 @@
+package com.seibel.lod.common.wrappers.worldGeneration.mimicObject;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.jetbrains.annotations.Nullable;
+
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment.EmptyChunkGenerator;
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.enums.config.LightGenerationMode;
+
+import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.SectionPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.LightLayer;
+import net.minecraft.world.level.StructureFeatureManager;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.ImposterProtoChunk;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.levelgen.feature.StructureFeature;
+import net.minecraft.world.level.levelgen.structure.StructureStart;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+
+public class LightedWorldGenRegion extends WorldGenRegion {
+	public final WorldGenLevelLightEngine light;
+	public final LightGenerationMode lightMode;
+	public final EmptyChunkGenerator generator;
+	public final int writeRadius;
+	public final int size;
+	private final ChunkPos firstPos;
+	private final List<ChunkAccess> cache;
+	private final StructureFeatureManager structFeat;
+	Long2ObjectOpenHashMap<ChunkAccess> chunkMap = new Long2ObjectOpenHashMap<ChunkAccess>();
+	private ChunkPos overrideCenterPos = null;
+	
+	public void setOverrideCenter(ChunkPos pos) {overrideCenterPos = pos;}
+	@Override
+	public ChunkPos getCenter() {
+		return overrideCenterPos==null ? super.getCenter() : overrideCenterPos;
+	}
+
+	public LightedWorldGenRegion(ServerLevel serverLevel, WorldGenLevelLightEngine lightEngine,
+			StructureFeatureManager structFeat, List<ChunkAccess> list, ChunkStatus chunkStatus, int i,
+			LightGenerationMode lightMode, EmptyChunkGenerator generator) {
+		super(serverLevel, list, chunkStatus, i);
+		this.lightMode = lightMode;
+		this.firstPos = list.get(0).getPos();
+		this.generator = generator;
+		this.structFeat = structFeat;
+		light = lightEngine;
+		writeRadius = i;
+		cache = list;
+		size = Mth.floor(Math.sqrt(list.size()));
+	}
+
+	// Bypass BCLib mixin overrides.
+    @Override
+    public boolean ensureCanWrite(BlockPos blockPos) {
+        int i = SectionPos.blockToSectionCoord(blockPos.getX());
+        int j = SectionPos.blockToSectionCoord(blockPos.getZ());
+        ChunkPos chunkPos = this.getCenter();
+        int k = Math.abs(chunkPos.x - i);
+        int l = Math.abs(chunkPos.z - j);
+        if (k > this.writeRadius || l > this.writeRadius) {
+            return false;
+        }
+        return true;
+    }
+    
+	@Override
+	public Stream<? extends StructureStart<?>> startsForFeature(SectionPos sectionPos,
+			StructureFeature<?> structureFeature) {
+		return structFeat.startsForFeature(sectionPos, structureFeature);
+	}
+
+	// Skip updating the related tile entities
+	@Override
+	public boolean setBlock(BlockPos blockPos, BlockState blockState, int i, int j) {
+		ChunkAccess chunkAccess = this.getChunk(blockPos);
+		if (chunkAccess instanceof LevelChunk)
+			return true;
+		chunkAccess.setBlockState(blockPos, blockState, false);
+		// This is for post ticking for water on gen and stuff like that. Not enabled
+		// for now.
+		// if (blockState.hasPostProcess(this, blockPos))
+		// this.getChunk(blockPos).markPosForPostprocessing(blockPos);
+		return true;
+	}
+
+	// Skip Dropping the item on destroy
+	@Override
+	public boolean destroyBlock(BlockPos blockPos, boolean bl, @Nullable Entity entity, int i) {
+		BlockState blockState = this.getBlockState(blockPos);
+		if (blockState.isAir()) {
+			return false;
+		}
+		return this.setBlock(blockPos, Blocks.AIR.defaultBlockState(), 3, i);
+	}
+
+	// Skip BlockEntity stuff. It aren't really needed
+	@Override
+	public BlockEntity getBlockEntity(BlockPos blockPos) {
+		return null;
+	}
+
+	// Skip BlockEntity stuff. It aren't really needed
+	@Override
+	public boolean addFreshEntity(Entity entity) {
+		return true;
+	}
+
+	// Allays have empty chunks even if it's outside the worldGenRegion
+	// @Override
+	// public boolean hasChunk(int i, int j) {
+	// return true;
+	// }
+
+	// Override to ensure no other mod mixins cause skipping the overrided
+	// getChunk(...)
+	@Override
+	public ChunkAccess getChunk(int i, int j) {
+		return this.getChunk(i, j, ChunkStatus.EMPTY);
+	}
+
+	// Override to ensure no other mod mixins cause skipping the overrided
+	// getChunk(...)
+	@Override
+	public ChunkAccess getChunk(int i, int j, ChunkStatus chunkStatus) {
+		return this.getChunk(i, j, chunkStatus, true);
+	}
+
+	// Use this instead of super.getChunk() to bypass C2ME concurrency checks
+	private ChunkAccess superGetChunk(int x, int z, ChunkStatus cs) {
+		int k = x - firstPos.x;
+		int l = z - firstPos.z;
+		return cache.get(k + l * size);
+	}
+
+	// Use this instead of super.hasChunk() to bypass C2ME concurrency checks
+	private boolean superHasChunk(int x, int z) {
+		int k = x - firstPos.x;
+		int l = z - firstPos.z;
+		return l >= 0 && l < size && k >= 0 && k < size;
+	}
+
+	// Allow creating empty chunks even if it's outside the worldGenRegion
+	@Override
+	@Nullable
+	public ChunkAccess getChunk(int i, int j, ChunkStatus chunkStatus, boolean bl) {
+		ChunkAccess chunk = getChunkAccess(i, j, chunkStatus, bl);
+		if (chunk instanceof LevelChunk) {
+			chunk = new ImposterProtoChunk((LevelChunk) chunk);
+		}
+		return chunk;
+	}
+
+	private static ChunkStatus debugTriggeredForStatus = null;
+
+	private ChunkAccess getChunkAccess(int i, int j, ChunkStatus chunkStatus, boolean bl) {
+		ChunkAccess chunk = superHasChunk(i, j) ? superGetChunk(i, j, ChunkStatus.EMPTY) : null;
+		if (chunk != null && chunk.getStatus().isOrAfter(chunkStatus)) {
+			return chunk;
+		}
+		if (!bl)
+			return null;
+		if (chunk == null) {
+			chunk = chunkMap.get(ChunkPos.asLong(i, j));
+			if (chunk == null) {
+				chunk = generator.generate(i, j);
+				if (chunk == null)
+					throw new NullPointerException("The provided generator should not return null!");
+				chunkMap.put(ChunkPos.asLong(i, j), chunk);
+			}
+		}
+		if (chunkStatus != ChunkStatus.EMPTY && chunkStatus != debugTriggeredForStatus) {
+			ClientApi.LOGGER.info("WorldGen requiring " + chunkStatus
+					+ " outside expected range detected. Force passing EMPTY chunk and seeing if it works.");
+			debugTriggeredForStatus = chunkStatus;
+		}
+		return chunk;
+	}
+
+	// Override force use of my own light engine
+	@Override
+	public LevelLightEngine getLightEngine() {
+		return light;
+	}
+
+	// Override force use of my own light engine
+	@Override
+	public int getBrightness(LightLayer lightLayer, BlockPos blockPos) {
+		if (lightMode != LightGenerationMode.FAST) {
+			return light.getLayerListener(lightLayer).getLightValue(blockPos);
+		}
+		if (lightLayer == LightLayer.BLOCK)
+			return 0;
+		BlockPos p = super.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, blockPos);
+		return (p.getY() <= blockPos.getY()) ? getMaxLightLevel() : 0;
+	}
+
+	// Override force use of my own light engine
+	@Override
+	public int getRawBrightness(BlockPos blockPos, int i) {
+		if (lightMode != LightGenerationMode.FAST) {
+			return light.getRawBrightness(blockPos, i);
+		}
+		BlockPos p = super.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, blockPos);
+		return (p.getY() <= blockPos.getY()) ? getMaxLightLevel() : 0;
+	}
+
+	// Override force use of my own light engine
+	@Override
+	public boolean canSeeSky(BlockPos blockPos) {
+		return (getBrightness(LightLayer.SKY, blockPos) >= getMaxLightLevel());
+	}
+
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/mimicObject/WorldGenLevelLightEngine.java

@@ -0,0 +1,177 @@
+package com.seibel.lod.common.wrappers.worldGeneration.mimicObject;
+
+import org.jetbrains.annotations.Nullable;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.SectionPos;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.LevelHeightAccessor;
+import net.minecraft.world.level.LightLayer;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.DataLayer;
+import net.minecraft.world.level.chunk.LevelChunkSection;
+import net.minecraft.world.level.lighting.BlockLightEngine;
+import net.minecraft.world.level.lighting.LayerLightEventListener;
+import net.minecraft.world.level.lighting.LevelLightEngine;
+import net.minecraft.world.level.lighting.SkyLightEngine;
+
+public class WorldGenLevelLightEngine extends LevelLightEngine {
+	public static final int MAX_SOURCE_LEVEL = 15;
+    public static final int LIGHT_SECTION_PADDING = 1;
+    protected final LevelHeightAccessor levelHeightAccessor;
+    @Nullable
+    public final BlockLightEngine blockEngine;
+    @Nullable
+    public final SkyLightEngine skyEngine;
+
+    public WorldGenLevelLightEngine(LightGetterAdaptor genRegion) {
+    	super(genRegion, false, false);
+        this.levelHeightAccessor = genRegion.getLevelHeightAccessor();
+        this.blockEngine = new BlockLightEngine(genRegion);
+        this.skyEngine = new SkyLightEngine(genRegion);
+    }
+
+    @Override
+    public void checkBlock(BlockPos blockPos) {
+        if (this.blockEngine != null) {
+            this.blockEngine.checkBlock(blockPos);
+        }
+        if (this.skyEngine != null) {
+            this.skyEngine.checkBlock(blockPos);
+        }
+    }
+
+    @Override
+    public void onBlockEmissionIncrease(BlockPos blockPos, int i) {
+        if (this.blockEngine != null) {
+            this.blockEngine.onBlockEmissionIncrease(blockPos, i);
+        }
+    }
+
+    @Override
+    public boolean hasLightWork() {
+        if (this.skyEngine != null && this.skyEngine.hasLightWork()) {
+            return true;
+        }
+        return this.blockEngine != null && this.blockEngine.hasLightWork();
+    }
+
+    @Override
+    public int runUpdates(int i, boolean bl, boolean bl2) {
+        if (this.blockEngine != null && this.skyEngine != null) {
+            int j = i / 2;
+            int k = this.blockEngine.runUpdates(j, bl, bl2);
+            int l = i - j + k;
+            int m = this.skyEngine.runUpdates(l, bl, bl2);
+            if (k == 0 && m > 0) {
+                return this.blockEngine.runUpdates(m, bl, bl2);
+            }
+            return m;
+        }
+        if (this.blockEngine != null) {
+            return this.blockEngine.runUpdates(i, bl, bl2);
+        }
+        if (this.skyEngine != null) {
+            return this.skyEngine.runUpdates(i, bl, bl2);
+        }
+        return i;
+    }
+
+    @Override
+    public void updateSectionStatus(SectionPos sectionPos, boolean bl) {
+        if (this.blockEngine != null) {
+            this.blockEngine.updateSectionStatus(sectionPos, bl);
+        }
+        if (this.skyEngine != null) {
+            this.skyEngine.updateSectionStatus(sectionPos, bl);
+        }
+    }
+
+    @Override
+    public void enableLightSources(ChunkPos chunkPos, boolean bl) {
+        if (this.blockEngine != null) {
+            this.blockEngine.enableLightSources(chunkPos, bl);
+        }
+        if (this.skyEngine != null) {
+            this.skyEngine.enableLightSources(chunkPos, bl);
+        }
+    }
+
+    @Override
+    public LayerLightEventListener getLayerListener(LightLayer lightLayer) {
+        if (lightLayer == LightLayer.BLOCK) {
+            if (this.blockEngine == null) {
+                return LayerLightEventListener.DummyLightLayerEventListener.INSTANCE;
+            }
+            return this.blockEngine;
+        }
+        if (this.skyEngine == null) {
+            return LayerLightEventListener.DummyLightLayerEventListener.INSTANCE;
+        }
+        return this.skyEngine;
+    }
+
+    @Override
+    public int getRawBrightness(BlockPos blockPos, int i) {
+        int j = this.skyEngine == null ? 0 : this.skyEngine.getLightValue(blockPos) - i;
+        int k = this.blockEngine == null ? 0 : this.blockEngine.getLightValue(blockPos);
+        return Math.max(k, j);
+    }
+
+    public void lightChunk(ChunkAccess chunkAccess, boolean needLightBlockUpdate) {
+    	ChunkPos chunkPos = chunkAccess.getPos();
+        chunkAccess.setLightCorrect(false);
+        
+        LevelChunkSection[] levelChunkSections = chunkAccess.getSections();
+        for (int i = 0; i < chunkAccess.getSectionsCount(); ++i) {
+            LevelChunkSection levelChunkSection = levelChunkSections[i];
+			if (!LevelChunkSection.isEmpty(levelChunkSection)) {
+	            int j = this.levelHeightAccessor.getSectionYFromSectionIndex(i);
+				updateSectionStatus(SectionPos.of(chunkPos, j), false);
+			}
+        }
+        enableLightSources(chunkPos, true);
+        if (needLightBlockUpdate) {
+            chunkAccess.getLights().forEach(blockPos ->
+            onBlockEmissionIncrease(blockPos, chunkAccess.getLightEmission(blockPos)));
+        }
+        
+        chunkAccess.setLightCorrect(true);
+    }
+
+    @Override
+    public String getDebugData(LightLayer lightLayer, SectionPos sectionPos) {
+    	throw new UnsupportedOperationException("This should never be used!");
+    }
+    @Override
+    public void queueSectionData(LightLayer lightLayer, SectionPos sectionPos, @Nullable DataLayer dataLayer, boolean bl) {
+        if (lightLayer == LightLayer.BLOCK) {
+            if (this.blockEngine != null) {
+                this.blockEngine.queueSectionData(sectionPos.asLong(), dataLayer, bl);
+            }
+        } else if (this.skyEngine != null) {
+            this.skyEngine.queueSectionData(sectionPos.asLong(), dataLayer, bl);
+        }
+    }
+    @Override
+    public void retainData(ChunkPos chunkPos, boolean bl) {
+        if (this.blockEngine != null) {
+            this.blockEngine.retainData(chunkPos, bl);
+        }
+        if (this.skyEngine != null) {
+            this.skyEngine.retainData(chunkPos, bl);
+        }
+    }
+    @Override
+    public int getLightSectionCount() {
+    	throw new UnsupportedOperationException("This should never be used!");
+    }
+    @Override
+    public int getMinLightSection() {
+    	throw new UnsupportedOperationException("This should never be used!");
+    }
+    @Override
+    public int getMaxLightSection() {
+    	throw new UnsupportedOperationException("This should never be used!");
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/mimicObject/WorldGenStructFeatManager.java

@@ -0,0 +1,55 @@
+package com.seibel.lod.common.wrappers.worldGeneration.mimicObject;
+
+import java.util.stream.Stream;
+
+import net.minecraft.core.SectionPos;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.StructureFeatureManager;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.levelgen.WorldGenSettings;
+import net.minecraft.world.level.levelgen.feature.StructureFeature;
+import net.minecraft.world.level.levelgen.structure.StructureStart;
+
+public class WorldGenStructFeatManager extends StructureFeatureManager {
+	WorldGenLevel genLevel;
+	WorldGenSettings worldGenSettings;
+	public WorldGenStructFeatManager(LevelAccessor levelAccessor, WorldGenSettings worldGenSettings,
+			WorldGenLevel genLevel) {
+		super(levelAccessor, worldGenSettings);
+		this.genLevel = genLevel;
+		this.worldGenSettings = worldGenSettings;
+	}
+	
+	public void setGenLevel(WorldGenLevel genLevel) {
+		this.genLevel = genLevel;
+	}
+
+	@Override
+	public WorldGenStructFeatManager forWorldGenRegion(WorldGenRegion worldGenRegion) {
+		if (worldGenRegion == genLevel)
+			return this;
+		return new WorldGenStructFeatManager(worldGenRegion, worldGenSettings, worldGenRegion);
+	}
+
+	@Override
+	public Stream<? extends StructureStart<?>> startsForFeature(SectionPos sectionPos2,
+			StructureFeature<?> structureFeature) {
+		if (genLevel == null)
+			return Stream.empty();
+		ChunkAccess chunk = genLevel.getChunk(sectionPos2.x(), sectionPos2.z(), ChunkStatus.STRUCTURE_REFERENCES,
+				false);
+		if (chunk == null)
+			return Stream.empty();
+		return chunk.getReferencesForFeature(structureFeature).stream().map(pos -> {
+			SectionPos sectPos = SectionPos.of(ChunkPos.getX(pos), 0, ChunkPos.getZ(pos));
+			ChunkAccess startChunk = genLevel.getChunk(sectPos.x(), sectPos.z(), ChunkStatus.STRUCTURE_STARTS, false);
+			if (startChunk == null)
+				return null;
+			return this.getStartForFeature(sectPos, structureFeature, startChunk);
+		}).filter(structureStart -> structureStart != null && structureStart.isValid());
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/step/StepBiomes.java

@@ -0,0 +1,45 @@
+package com.seibel.lod.common.wrappers.worldGeneration.step;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.seibel.lod.common.wrappers.worldGeneration.ThreadedParameters;
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment;
+
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.ProtoChunk;
+
+public final class StepBiomes {
+	/**
+	 * 
+	 */
+	private final BatchGenerationEnvironment envionment;
+
+	/**
+	 * @param worldGenerationEnvironment
+	 */
+	public StepBiomes(BatchGenerationEnvironment worldGenerationEnvironment) {
+		envionment = worldGenerationEnvironment;
+	}
+
+	public final ChunkStatus STATUS = ChunkStatus.BIOMES;
+
+	public void generateGroup(ThreadedParameters tParams, WorldGenRegion worldGenRegion, List<ChunkAccess> chunks) {
+
+		ArrayList<ChunkAccess> chunksToDo = new ArrayList<ChunkAccess>();
+
+		for (ChunkAccess chunk : chunks) {
+			if (chunk.getStatus().isOrAfter(STATUS))
+				continue;
+			((ProtoChunk) chunk).setStatus(STATUS);
+			chunksToDo.add(chunk);
+		}
+
+		for (ChunkAccess chunk : chunksToDo) {
+			// System.out.println("StepBiomes: "+chunk.getPos());
+			envionment.params.generator.createBiomes(envionment.params.biomes, chunk);
+		}
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/step/StepFeatures.java

@@ -0,0 +1,50 @@
+package com.seibel.lod.common.wrappers.worldGeneration.step;
+
+import java.util.ArrayList;
+
+import com.seibel.lod.common.wrappers.worldGeneration.ThreadedParameters;
+import com.seibel.lod.common.wrappers.worldGeneration.mimicObject.LightedWorldGenRegion;
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment;
+import com.seibel.lod.core.util.GridList;
+
+import net.minecraft.ReportedException;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.ProtoChunk;
+
+public final class StepFeatures {
+	/**
+	 * 
+	 */
+	private final BatchGenerationEnvironment envionment;
+
+	/**
+	 * @param worldGenerationEnvironment
+	 */
+	public StepFeatures(BatchGenerationEnvironment worldGenerationEnvironment) {
+		envionment = worldGenerationEnvironment;
+	}
+
+	public final ChunkStatus STATUS = ChunkStatus.FEATURES;
+
+	public void generateGroup(ThreadedParameters tParams, LightedWorldGenRegion worldGenRegion, GridList<ChunkAccess> chunks) {
+		ArrayList<ChunkAccess> chunksToDo = new ArrayList<ChunkAccess>();
+
+		for (ChunkAccess chunk : chunks) {
+			if (chunk.getStatus().isOrAfter(STATUS))
+				continue;
+			((ProtoChunk) chunk).setStatus(STATUS);
+			chunksToDo.add(chunk);
+		}
+
+		for (ChunkAccess chunk : chunksToDo) {
+			try {
+				worldGenRegion.setOverrideCenter(chunk.getPos());
+				envionment.params.generator.applyBiomeDecoration(worldGenRegion, tParams.structFeat);
+			} catch (ReportedException e) {
+				e.printStackTrace();
+			}
+		}
+		worldGenRegion.setOverrideCenter(null);
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/step/StepLight.java

@@ -0,0 +1,59 @@
+package com.seibel.lod.common.wrappers.worldGeneration.step;
+
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment;
+import com.seibel.lod.common.wrappers.worldGeneration.mimicObject.WorldGenLevelLightEngine;
+import com.seibel.lod.core.util.GridList;
+
+import net.minecraft.server.level.ThreadedLevelLightEngine;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.ProtoChunk;
+import net.minecraft.world.level.lighting.LightEventListener;
+
+public final class StepLight {
+	/**
+	 * 
+	 */
+	private final BatchGenerationEnvironment environment;
+
+	/**
+	 * @param batchGenerationEnvironment
+	 */
+	public StepLight(BatchGenerationEnvironment batchGenerationEnvironment)
+	{
+		environment = batchGenerationEnvironment;
+	}
+
+	public final ChunkStatus STATUS = ChunkStatus.LIGHT;
+	
+	public void generateGroup(LightEventListener lightEngine,
+			GridList<ChunkAccess> chunks) {
+		//ArrayList<ChunkAccess> chunksToDo = new ArrayList<ChunkAccess>();
+		
+		for (ChunkAccess chunk : chunks) {
+			if (chunk.getStatus().isOrAfter(STATUS)) continue;
+			((ProtoChunk) chunk).setStatus(STATUS);
+		}
+		
+		for (ChunkAccess chunk : chunks) {
+			boolean hasCorrectBlockLight = (chunk instanceof LevelChunk && chunk.isLightCorrect());
+			try {
+				if (lightEngine == null) {
+					// Do nothing
+				} else if (lightEngine instanceof WorldGenLevelLightEngine) {
+					((WorldGenLevelLightEngine)lightEngine).lightChunk(chunk, !hasCorrectBlockLight);
+				} else if (lightEngine instanceof ThreadedLevelLightEngine) {
+					((ThreadedLevelLightEngine) lightEngine).lightChunk(chunk, !hasCorrectBlockLight).join();
+				} else {
+					assert(false);
+				}
+				
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+			chunk.setLightCorrect(true);
+		}
+		lightEngine.runUpdates(Integer.MAX_VALUE, true, true);
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/step/StepNoise.java

@@ -0,0 +1,93 @@
+package com.seibel.lod.common.wrappers.worldGeneration.step;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.google.common.collect.Sets;
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment;
+import com.seibel.lod.common.wrappers.worldGeneration.ThreadedParameters;
+
+import net.minecraft.core.QuartPos;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.util.Mth;
+import net.minecraft.world.level.StructureFeatureManager;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.LevelChunkSection;
+import net.minecraft.world.level.chunk.ProtoChunk;
+import net.minecraft.world.level.levelgen.NoiseBasedChunkGenerator;
+import net.minecraft.world.level.levelgen.NoiseSettings;
+
+public final class StepNoise {
+	/**
+	 * 
+	 */
+	private final BatchGenerationEnvironment environment;
+
+	/**
+	 * @param batchGenerationEnvironment
+	 */
+	public StepNoise(BatchGenerationEnvironment batchGenerationEnvironment)
+	{
+		environment = batchGenerationEnvironment;
+	}
+	
+	private static <T> T joinSync(CompletableFuture<T> f) {
+		if (!f.isDone()) throw new RuntimeException("The future is concurrent!");
+		return f.join();
+	}
+	public final ChunkStatus STATUS = ChunkStatus.NOISE;
+
+    private ChunkAccess NoiseBased$fillFromNoise(NoiseBasedChunkGenerator generator, StructureFeatureManager structureFeatureManager, ChunkAccess chunkAccess) {
+        NoiseSettings noiseSettings = generator.settings.get().noiseSettings();
+        int i = Math.max(noiseSettings.minY(), chunkAccess.getMinBuildHeight());
+        int j = Math.min(noiseSettings.minY() + noiseSettings.height(), chunkAccess.getMaxBuildHeight());
+        int cellHeight = QuartPos.toBlock(noiseSettings.noiseSizeVertical());
+        int k = Mth.intFloorDiv(i, cellHeight);
+        int l = Mth.intFloorDiv(j - i, cellHeight);
+        if (l <= 0) {
+            return chunkAccess;
+        }
+        int m = chunkAccess.getSectionIndex(l * cellHeight - 1 + i);
+        int n = chunkAccess.getSectionIndex(i);
+        HashSet<LevelChunkSection> set = Sets.newHashSet();
+        try {
+	        for (int o = m; o >= n; --o) {
+	            LevelChunkSection levelChunkSection = chunkAccess.getOrCreateSection(o);
+	            levelChunkSection.acquire();
+	            set.add(levelChunkSection);
+	        }
+	        chunkAccess = generator.doFill(structureFeatureManager, chunkAccess, k, l);
+	        return chunkAccess;
+        } finally {
+	        for (LevelChunkSection levelChunkSection : set) {
+	            levelChunkSection.release();
+	        };
+        }
+    }
+    
+	public void generateGroup(ThreadedParameters tParams, WorldGenRegion worldGenRegion,
+			List<ChunkAccess> chunks) {
+
+		ArrayList<ChunkAccess> chunksToDo = new ArrayList<ChunkAccess>();
+		
+		for (ChunkAccess chunk : chunks) {
+			if (chunk.getStatus().isOrAfter(STATUS)) continue;
+			((ProtoChunk) chunk).setStatus(STATUS);
+			chunksToDo.add(chunk);
+		}
+		
+		for (ChunkAccess chunk : chunksToDo) {
+			// System.out.println("StepNoise: "+chunk.getPos());
+			if (environment.params.generator instanceof NoiseBasedChunkGenerator) {
+				chunk = NoiseBased$fillFromNoise((NoiseBasedChunkGenerator)environment.params.generator,
+						tParams.structFeat.forWorldGenRegion(worldGenRegion), chunk);
+			} else {
+				chunk = joinSync(environment.params.generator.fillFromNoise(Runnable::run, 
+						tParams.structFeat.forWorldGenRegion(worldGenRegion), chunk));
+			}
+		}
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/step/StepStructureReference.java

@@ -0,0 +1,92 @@
+package com.seibel.lod.common.wrappers.worldGeneration.step;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment;
+import com.seibel.lod.common.wrappers.worldGeneration.ThreadedParameters;
+
+import net.minecraft.CrashReport;
+import net.minecraft.CrashReportCategory;
+import net.minecraft.ReportedException;
+import net.minecraft.core.Registry;
+import net.minecraft.core.SectionPos;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.StructureFeatureManager;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.ProtoChunk;
+import net.minecraft.world.level.levelgen.structure.StructureStart;
+
+public final class StepStructureReference {
+	/**
+	 * 
+	 */
+	private final BatchGenerationEnvironment environment;
+
+	/**
+	 * @param batchGenerationEnvironment
+	 */
+	public StepStructureReference(BatchGenerationEnvironment batchGenerationEnvironment)
+	{
+		environment = batchGenerationEnvironment;
+	}
+
+	public final ChunkStatus STATUS = ChunkStatus.STRUCTURE_REFERENCES;
+
+	private void createReferences(WorldGenRegion worldGenLevel, StructureFeatureManager structureFeatureManager,
+			ChunkAccess chunkAccess) {
+		ChunkPos chunkPos = chunkAccess.getPos();
+		int j = chunkPos.x;
+		int k = chunkPos.z;
+		int l = chunkPos.getMinBlockX();
+		int m = chunkPos.getMinBlockZ();
+
+		SectionPos sectionPos = SectionPos.bottomOf(chunkAccess);
+
+		for (int n = j - 8; n <= j + 8; n++) {
+			for (int o = k - 8; o <= k + 8; o++) {
+				if (!worldGenLevel.hasChunk(n, o))
+					continue;
+				long p = ChunkPos.asLong(n, o);
+				for (StructureStart<?> structureStart : worldGenLevel.getChunk(n, o).getAllStarts().values()) {
+					try {
+						if (structureStart.isValid()
+								&& structureStart.getBoundingBox().intersects(l, m, l + 15, m + 15)) {
+							structureFeatureManager.addReferenceForFeature(sectionPos, structureStart.getFeature(),
+									p, chunkAccess);
+						}
+					} catch (Exception exception) {
+						CrashReport crashReport = CrashReport.forThrowable(exception,
+								"Generating structure reference");
+						CrashReportCategory crashReportCategory = crashReport.addCategory("Structure");
+						crashReportCategory.setDetail("Id",
+								() -> Registry.STRUCTURE_FEATURE.getKey(structureStart.getFeature()).toString());
+						crashReportCategory.setDetail("Name", () -> structureStart.getFeature().getFeatureName());
+						crashReportCategory.setDetail("Class",
+								() -> structureStart.getFeature().getClass().getCanonicalName());
+						throw new ReportedException(crashReport);
+					}
+				}
+			}
+		}
+	}
+
+	public void generateGroup(ThreadedParameters tParams, WorldGenRegion worldGenRegion,
+			List<ChunkAccess> chunks) {
+
+		ArrayList<ChunkAccess> chunksToDo = new ArrayList<ChunkAccess>();
+		
+		for (ChunkAccess chunk : chunks) {
+			if (chunk.getStatus().isOrAfter(STATUS)) continue;
+			((ProtoChunk) chunk).setStatus(STATUS);
+			chunksToDo.add(chunk);
+		}
+		
+		for (ChunkAccess chunk : chunksToDo) {
+			// System.out.println("StepStructureReference: "+chunk.getPos());
+			createReferences(worldGenRegion, tParams.structFeat.forWorldGenRegion(worldGenRegion), chunk);
+		}
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/step/StepStructureStart.java

@@ -0,0 +1,59 @@
+package com.seibel.lod.common.wrappers.worldGeneration.step;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment;
+import com.seibel.lod.common.wrappers.worldGeneration.ThreadedParameters;
+
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.ProtoChunk;
+
+public final class StepStructureStart {
+	/**
+	 * 
+	 */
+	private final BatchGenerationEnvironment environment;
+
+	/**
+	 * @param batchGenerationEnvironment
+	 */
+	public StepStructureStart(BatchGenerationEnvironment batchGenerationEnvironment)
+	{
+		environment = batchGenerationEnvironment;
+	}
+
+	public final ChunkStatus STATUS = ChunkStatus.STRUCTURE_STARTS;
+	
+	public static class StructStartCorruptedException extends RuntimeException {
+		private static final long serialVersionUID = -8987434342051563358L;
+
+		public StructStartCorruptedException(ArrayIndexOutOfBoundsException e) {
+			super("StructStartCorruptedException");
+			super.initCause(e);
+			fillInStackTrace();
+		}
+	}
+
+	public void generateGroup(ThreadedParameters tParams, WorldGenRegion worldGenRegion,
+			List<ChunkAccess> chunks) {
+
+		ArrayList<ChunkAccess> chunksToDo = new ArrayList<ChunkAccess>();
+		
+		for (ChunkAccess chunk : chunks) {
+			if (chunk.getStatus().isOrAfter(STATUS)) continue;
+			((ProtoChunk) chunk).setStatus(STATUS);
+			chunksToDo.add(chunk);
+		}
+		
+		if (environment.params.worldGenSettings.generateFeatures()) {
+			for (ChunkAccess chunk : chunksToDo) {
+				// System.out.println("StepStructureStart: "+chunk.getPos());
+				environment.params.generator.createStructures(environment.params.registry, tParams.structFeat, chunk, environment.params.structures,
+						environment.params.worldSeed);
+			}
+		}
+	}
+}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/step/StepSurface.java

@@ -0,0 +1,45 @@
+package com.seibel.lod.common.wrappers.worldGeneration.step;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment;
+import com.seibel.lod.common.wrappers.worldGeneration.ThreadedParameters;
+
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.ProtoChunk;
+
+public final class StepSurface {
+	/**
+	 * 
+	 */
+	private final BatchGenerationEnvironment environment;
+
+	/**
+	 * @param batchGenerationEnvironment
+	 */
+	public StepSurface(BatchGenerationEnvironment batchGenerationEnvironment)
+	{
+		environment = batchGenerationEnvironment;
+	}
+
+	public final ChunkStatus STATUS = ChunkStatus.SURFACE;
+
+	public void generateGroup(ThreadedParameters tParams, WorldGenRegion worldGenRegion,
+			List<ChunkAccess> chunks) {
+		ArrayList<ChunkAccess> chunksToDo = new ArrayList<ChunkAccess>();
+		
+		for (ChunkAccess chunk : chunks) {
+			if (chunk.getStatus().isOrAfter(STATUS)) continue;
+			((ProtoChunk) chunk).setStatus(STATUS);
+			chunksToDo.add(chunk);
+		}
+		
+		for (ChunkAccess chunk : chunksToDo) {
+			// System.out.println("StepSurface: "+chunk.getPos());
+			environment.params.generator.buildSurfaceAndBedrock(worldGenRegion, chunk);
+		}
+	}
+}

common/src/main/resources/lod.accesswidener

@@ -0,0 +1,49 @@
+accessWidener v1 named
+
+# used when determining where to save files too
+accessible field net/minecraft/world/level/storage/DimensionDataStorage dataFolder Ljava/io/File;
+
+# used when rendering
+accessible field com/mojang/blaze3d/vertex/VertexBuffer indexCount I
+accessible field com/mojang/blaze3d/vertex/VertexBuffer vertextBufferId I
+accessible method net/minecraft/client/renderer/GameRenderer getFov (Lnet/minecraft/client/Camera;FZ)D
+
+# pre-render setup
+accessible field net/minecraft/client/renderer/LevelRenderer renderChunks Lit/unimi/dsi/fastutil/objects/ObjectArrayList;
+accessible class net/minecraft/client/renderer/LevelRenderer$RenderChunkInfo
+accessible field net/minecraft/client/renderer/LevelRenderer$RenderChunkInfo chunk Lnet/minecraft/client/renderer/chunk/ChunkRenderDispatcher$RenderChunk;
+
+# used for grabbing vanilla rendered chunks
+accessible class net/minecraft/client/renderer/LevelRenderer$RenderChunkInfo
+accessible field net/minecraft/client/renderer/LevelRenderer$RenderChunkInfo chunk Lnet/minecraft/client/renderer/chunk/ChunkRenderDispatcher$RenderChunk;
+
+# lighting
+accessible field net/minecraft/client/renderer/LightTexture lightPixels Lcom/mojang/blaze3d/platform/NativeImage;
+accessible field net/minecraft/world/level/lighting/LevelLightEngine blockEngine Lnet/minecraft/world/level/lighting/LayerLightEngine;
+accessible field net/minecraft/world/level/lighting/LevelLightEngine skyEngine Lnet/minecraft/world/level/lighting/LayerLightEngine;
+
+# world generation
+accessible method net/minecraft/world/level/levelgen/Heightmap setHeight (III)V
+accessible field net/minecraft/world/level/biome/Biome generationSettings Lnet/minecraft/world/level/biome/BiomeGenerationSettings;
+accessible field net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator settings Ljava/util/function/Supplier;
+accessible method net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator doFill (Lnet/minecraft/world/level/StructureFeatureManager;Lnet/minecraft/world/level/chunk/ChunkAccess;II)Lnet/minecraft/world/level/chunk/ChunkAccess;
+
+accessible method net/minecraft/world/level/lighting/LayerLightEngine queueSectionData (JLnet/minecraft/world/level/chunk/DataLayer;Z)V
+accessible field net/minecraft/world/level/chunk/ChunkGenerator biomeSource Lnet/minecraft/world/level/biome/BiomeSource;
+
+# lod generation from save file
+accessible field net/minecraft/server/level/ChunkMap mainThreadExecutor Lnet/minecraft/util/thread/BlockableEventLoop;
+accessible method net/minecraft/server/level/ChunkMap readChunk (Lnet/minecraft/world/level/ChunkPos;)Lnet/minecraft/nbt/CompoundTag;
+
+# grabbing textures
+accessible field net/minecraft/client/renderer/texture/TextureAtlasSprite animatedTexture Lnet/minecraft/client/renderer/texture/TextureAtlasSprite$AnimatedTexture;
+accessible field net/minecraft/client/renderer/texture/TextureAtlasSprite width I
+accessible field net/minecraft/client/renderer/texture/TextureAtlasSprite height I
+accessible field net/minecraft/client/renderer/texture/TextureAtlasSprite mainImage [Lcom/mojang/blaze3d/platform/NativeImage;
+accessible method net/minecraft/client/renderer/texture/TextureAtlasSprite$AnimatedTexture getFrameX (I)I
+accessible method net/minecraft/client/renderer/texture/TextureAtlasSprite$AnimatedTexture getFrameY (I)I
+extendable class com/mojang/math/Matrix4f
+
+# hacky stuff
+accessible field net/minecraft/world/level/chunk/PalettedContainer lock Ljava/util/concurrent/Semaphore;
+mutable field net/minecraft/world/level/chunk/PalettedContainer lock Ljava/util/concurrent/Semaphore;

fabric/build.gradle

@@ -0,0 +1,184 @@
+plugins {
+    id "com.github.johnrengelman.shadow" version "7.0.0"
+}
+
+version = rootProject.mod_version+"-"+rootProject.minecraft_version+"-"+new Date().format("yyyy_MM_dd_HH_mm")
+
+loom {
+    accessWidenerPath.set(project(":common").file("src/main/resources/lod.accesswidener"))
+}
+
+architectury {
+    platformSetupLoomIde()
+    fabric()
+}
+
+configurations {
+    compileClasspath.extendsFrom common
+    runtimeClasspath.extendsFrom common
+    developmentFabric.extendsFrom common
+}
+
+repositories {
+    // Required for ModMenu
+    maven { url "https://maven.terraformersmc.com/" }
+}
+
+
+dependencies {
+    // Fabric loader
+    modImplementation "net.fabricmc:fabric-loader:${rootProject.fabric_loader_version}"
+
+    // Fabric API
+    modApi "net.fabricmc.fabric-api:fabric-api:${rootProject.fabric_api_version}"
+
+    // Mod Menu
+    modImplementation("com.terraformersmc:modmenu:${rootProject.modmenu_version}") {
+        exclude(group: "net.fabricmc.fabric-api")
+    }
+
+    // Sodium
+    modImplementation "curse.maven:sodium-394468:${rootProject.sodium_version}"
+    implementation "org.joml:joml:1.10.2"
+
+    // Lithium
+//    modImplementation "maven.modrinth:lithium:${rootProject.lithium_version}"
+
+    // Iris
+//    modImplementation "maven.modrinth:iris:${rootProject.iris_version}"
+
+    // Immersive Portals
+    /*
+    modImplementation("com.github.qouteall.ImmersivePortalsMod:build:${rootProject.immersive_portals_version}") {
+        exclude(group: "net.fabricmc.fabric-api")
+        transitive(false)
+    }
+    modImplementation("com.github.qouteall.ImmersivePortalsMod:imm_ptl_core:${rootProject.immersive_portals_version}") {
+        exclude(group: "net.fabricmc.fabric-api")
+        transitive(false)
+    }
+    modImplementation("com.github.qouteall.ImmersivePortalsMod:q_misc_util:${rootProject.immersive_portals_version}") {
+        exclude(group: "net.fabricmc.fabric-api")
+        transitive(false)
+    }
+     */
+
+
+
+    // Toml
+    shadowMe("com.electronwill.night-config:toml:${rootProject.toml_version}") {}
+
+    common(project(path: ":common", configuration: "namedElements")) { transitive false }
+    shadowMe(project(path: ":common", configuration: "transformProductionFabric")) { transitive false }
+
+    // Compression
+    common 'org.tukaani:xz:1.9'
+    common 'org.apache.commons:commons-compress:1.21'
+    shadowMe 'org.tukaani:xz:1.9'
+    shadowMe 'org.apache.commons:commons-compress:1.21'
+}
+
+// This method copies the access wideners from the common project to the fabric project. And it was generated by Github Copilot
+task copyAccessWidener(type: Copy) {
+    from project(":common").file("src/main/resources/lod.accesswidener")
+    into file("src/generated/resources")
+}
+
+task copyCoreResources(type: Copy) {
+    from fileTree(project(":core").file("src/main/resources"))
+    into file("build/resources/main")
+}
+
+task deleteResources(type: Delete) {
+    delete file("build/resources/main")
+}
+
+task copyCommonResources(type: Copy) {
+    from fileTree(project(":common").file("src/main/resources"))
+    into file("build/resources/main")
+}
+
+runClient {
+    dependsOn(copyCoreResources)
+    dependsOn(copyCommonResources)
+    jvmArgs "-XX:-OmitStackTraceInFastThrow"
+    finalizedBy(deleteResources)
+}
+
+// Put stuff from gradle.properties into the mod info stuff
+def resourceTargets = ["fabric.mod.json"]
+def intoTargets = ["$buildDir/resources/main/"]
+def replaceProperties = [
+        version: mod_version,
+        mod_name: mod_name,
+        authors: mod_authors,
+        description: mod_description
+]
+
+processResources {
+    dependsOn(copyAccessWidener)
+    inputs.properties replaceProperties
+    replaceProperties.put 'project', project
+    filesMatching(resourceTargets) {
+        expand replaceProperties
+    }
+
+    intoTargets.each { target ->
+        if (file(target).exists()) {
+            copy {
+                from(sourceSets.main.resources) {
+                    include resourceTargets
+                    expand replaceProperties
+                }
+                into target
+            }
+        }
+    }
+}
+
+shadowJar {
+    configurations = [project.configurations.shadowMe]
+    relocate 'org.tukaani', 'shaded.tukaani'
+    relocate 'org.apache.commons.compress', 'shaded.apache.commons.compress'
+    relocate 'com.electronwill.nightconfig', 'shaded.electronwill.nightconfig'
+
+    relocate 'com.seibel.lod.common', 'fabric.com.seibel.lod.common'
+
+    classifier "dev-shadow"
+}
+
+remapJar {
+    input.set shadowJar.archiveFile
+    dependsOn shadowJar
+    classifier null
+}
+
+jar {
+    classifier "dev"
+}
+
+sourcesJar {
+    def commonSources = project(":common").sourcesJar
+    dependsOn commonSources
+    from commonSources.archiveFile.map { zipTree(it) }
+}
+
+components.java {
+    withVariantsFromConfiguration(project.configurations.shadowRuntimeElements) {
+        skip()
+    }
+}
+
+publishing {
+    publications {
+        mavenFabric(MavenPublication) {
+            artifactId = rootProject.archives_base_name + "-" + project.name
+            from components.java
+        }
+    }
+
+    // See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
+    repositories {
+        // Add repositories to publish to here.
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/ClientProxy.java

@@ -0,0 +1,189 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.fabric;
+
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.api.EventApi;
+import com.mojang.blaze3d.platform.InputConstants;
+import com.seibel.lod.common.wrappers.chunk.ChunkWrapper;
+import com.seibel.lod.common.wrappers.world.DimensionTypeWrapper;
+import com.seibel.lod.common.wrappers.world.WorldWrapper;
+
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientChunkEvents;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerWorldEvents;
+import net.minecraft.client.Minecraft;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.chunk.LevelChunk;
+
+import java.util.HashSet;
+
+import org.lwjgl.glfw.GLFW;
+
+/**
+ * This handles all events sent to the client,
+ * and is the starting point for most of the mod.
+ *
+ * @author coolGi2007
+ * @author Ran
+ * @version 11-23-2021
+ */
+public class ClientProxy
+{
+	private final EventApi eventApi = EventApi.INSTANCE;
+	private final ClientApi clientApi = ClientApi.INSTANCE;
+
+
+	/**
+	 * Registers Fabric Events
+	 * @author Ran
+	 */
+	public void registerEvents() {
+		// TODO: Fix this if it's wrong
+
+		/* Registor the mod accessor*/
+
+		/* World Events */
+		//ServerTickEvents.START_SERVER_TICK.register(this::serverTickEvent);
+		ServerTickEvents.END_SERVER_TICK.register(this::serverTickEvent);
+
+		/* World Events */
+		//ServerChunkEvents.CHUNK_LOAD.register(this::chunkLoadEvent);
+		ClientChunkEvents.CHUNK_LOAD.register(this::chunkLoadEvent);
+
+		/* World Events */
+		ServerWorldEvents.LOAD.register((server, level) -> this.worldLoadEvent(level));
+		ServerWorldEvents.UNLOAD.register((server, level) -> this.worldUnloadEvent(level));
+
+		/* The Client World Events are in the mixins
+		Client world load event is in MixinClientLevel
+		Client world unload event is in MixinMinecraft */
+		/* The save events are in MixinServerLevel */
+
+		/* Keyboard Events */
+		ClientTickEvents.END_CLIENT_TICK.register(client -> {
+			if (client.player != null) onKeyInput();
+		});
+	}
+
+
+	public void serverTickEvent(MinecraftServer server)
+	{
+		eventApi.serverTickEvent();
+	}
+
+	public void chunkLoadEvent(LevelAccessor level, LevelChunk chunk)
+	{
+		clientApi.clientChunkLoadEvent(new ChunkWrapper(chunk, level),
+				WorldWrapper.getWorldWrapper(level));
+	}
+
+	public void worldSaveEvent()
+	{
+		eventApi.worldSaveEvent();
+	}
+
+	/** This is also called when a new dimension loads */
+	public void worldLoadEvent(Level level)
+	{
+		if (level != null) {
+			eventApi.worldLoadEvent(WorldWrapper.getWorldWrapper(level));
+		}
+	}
+
+	public void worldUnloadEvent(Level level)
+	{
+		if (level != null) {
+			eventApi.worldUnloadEvent(WorldWrapper.getWorldWrapper(level));
+		}
+	}
+
+	/**
+	 * Can someone tell me how to make this better
+	 * @author Ran
+	 *
+	 * public void blockChangeEvent(BlockEventData event) {
+	 * 		// we only care about certain block events
+	 * 		if (event.getClass() == BlockEventData.BreakEvent.class ||
+	 * 				event.getClass() == BlockEventData.EntityPlaceEvent.class ||
+	 * 				event.getClass() == BlockEventData.EntityMultiPlaceEvent.class ||
+	 * 				event.getClass() == BlockEventData.FluidPlaceBlockEvent.class ||
+	 * 				event.getClass() == BlockEventData.PortalSpawnEvent.class)
+	 *        {
+	 * 			IChunkWrapper chunk = new ChunkWrapper(event.getWorld().getChunk(event.getPos()));
+	 * 			DimensionTypeWrapper dimType = DimensionTypeWrapper.getDimensionTypeWrapper(event.getWorld().dimensionType());
+	 *
+	 * 			// recreate the LOD where the blocks were changed
+	 * 			eventApi.blockChangeEvent(chunk, dimType);
+	 *        }
+	 * }
+	 */
+	public void blockChangeEvent(LevelAccessor world, BlockPos pos) {
+		IChunkWrapper chunk = new ChunkWrapper(world.getChunk(pos), world);
+		DimensionTypeWrapper dimType = DimensionTypeWrapper.getDimensionTypeWrapper(world.dimensionType());
+
+		// recreate the LOD where the blocks were changed
+		eventApi.blockChangeEvent(chunk, dimType);
+	}
+
+	private static final int[] KEY_TO_CHECK_FOR = {GLFW.GLFW_KEY_F6, GLFW.GLFW_KEY_F8};
+	
+	HashSet<Integer> previousKeyDown = new HashSet<Integer>();
+	
+	public void onKeyInput() {
+		ILodConfigWrapperSingleton CONFIG = SingletonHandler.get(ILodConfigWrapperSingleton.class);
+		if (CONFIG.client().advanced().debugging().getDebugKeybindingsEnabled())
+		{
+			HashSet<Integer> currectKeyDown = new HashSet<Integer>();
+			
+			// Note: Minecraft's InputConstants is same as GLFW Key values
+			//TODO: Use mixin to hook directly into the GLFW Keyboard event in minecraft KeyboardHandler
+			// Check all keys we need
+			for (int i = GLFW.GLFW_KEY_A; i <= GLFW.GLFW_KEY_Z; i++) {
+				if (InputConstants.isKeyDown(Minecraft.getInstance().getWindow().getWindow(), i)) {
+					currectKeyDown.add(i);
+				}
+			}
+			for (int i : KEY_TO_CHECK_FOR) {
+				if (InputConstants.isKeyDown(Minecraft.getInstance().getWindow().getWindow(), i)) {
+					currectKeyDown.add(i);
+				}
+			}
+			
+			// Diff and trigger events
+			for (int c : currectKeyDown) {
+				if (!previousKeyDown.contains(c)) {
+					ClientApi.INSTANCE.keyPressedEvent(c);
+				}
+			}
+			
+			// Update the set
+			previousKeyDown = currectKeyDown;
+		}
+	}
+}

fabric/src/main/java/com/seibel/lod/fabric/Main.java

@@ -0,0 +1,86 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.fabric;
+
+import com.seibel.lod.common.LodCommonMain;
+import com.seibel.lod.core.ModInfo;
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.api.ModAccessorApi;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IModChecker;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.ISodiumAccessor;
+import com.seibel.lod.fabric.wrappers.modAccessor.ModChecker;
+import com.seibel.lod.fabric.wrappers.modAccessor.OptifineAccessor;
+import com.seibel.lod.fabric.wrappers.modAccessor.SodiumAccessor;
+import com.seibel.lod.fabric.wrappers.DependencySetup;
+
+import net.fabricmc.api.ClientModInitializer;
+
+/**
+ * Initialize and setup the Mod. <br>
+ * If you are looking for the real start of the mod
+ * check out the ClientProxy.
+ *
+ * @author coolGi2007
+ * @author Ran
+ * @version 12-1-2021
+ */
+public class Main implements ClientModInitializer
+{
+	// This is a client mod, so it should implement ClientModInitializer and in fabric.mod.json it should have "environment": "client"
+	// Once it works on servers change the implement to ModInitializer and in fabric.mod.json it should be "environment": "*"
+
+	public static ClientProxy client_proxy;
+
+
+	// Do if implements ClientModInitializer
+	// This loads the mod before minecraft loads which causes a lot of issues
+	@Override
+	public void onInitializeClient() {
+		// no.
+	}
+
+	// This loads the mod after minecraft loads which doesn't causes a lot of issues
+	public static void init() {
+		LodCommonMain.initConfig();
+		LodCommonMain.startup(null, false);
+		DependencySetup.createInitialBindings();
+		SingletonHandler.bind(IModChecker.class, ModChecker.INSTANCE);
+		ClientApi.LOGGER.info(ModInfo.READABLE_NAME + ", Version: " + ModInfo.VERSION);
+
+		// Check if this works
+		client_proxy = new ClientProxy();
+		client_proxy.registerEvents();
+		if (SingletonHandler.get(IModChecker.class).isModLoaded("sodium")) {
+			ModAccessorApi.bind(ISodiumAccessor.class, new SodiumAccessor());
+		}
+		if (SingletonHandler.get(IModChecker.class).isModLoaded("optifine")) {
+			ModAccessorApi.bind(IOptifineAccessor.class, new OptifineAccessor());
+		}
+	}
+
+	public static void initServer() {
+		LodCommonMain.initConfig();
+		LodCommonMain.startup(null, true);
+		DependencySetup.createInitialBindings();
+		ClientApi.LOGGER.info(ModInfo.READABLE_NAME + ", Version: " + ModInfo.VERSION);
+	}
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/MixinChunkGenerator.java

@@ -0,0 +1,29 @@
+package com.seibel.lod.fabric.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.world.level.StructureFeatureManager;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.WorldgenRandom;
+
+@Mixin(ChunkGenerator.class)
+public class MixinChunkGenerator {
+	@Redirect(method = "applyBiomeDecoration", at = @At(
+			value = "INVOKE",
+			target = "Lnet/minecraft/world/level/biome/Biome;generate(Lnet/minecraft/world/level/StructureFeatureManager;"
+					+ "Lnet/minecraft/world/level/chunk/ChunkGenerator;Lnet/minecraft/server/level/WorldGenRegion;J"
+					+ "Lnet/minecraft/world/level/levelgen/WorldgenRandom;Lnet/minecraft/core/BlockPos;)V"
+			
+	))
+	private void wrapBiomeGenerateCall(Biome biome, StructureFeatureManager structFeatManager, ChunkGenerator generator,
+			WorldGenRegion genRegion, long l, WorldgenRandom random, BlockPos pos) {
+		synchronized((ChunkGenerator)(Object)this) {
+			biome.generate(structFeatManager, (ChunkGenerator)(Object)this, genRegion, l, random, pos);
+		}
+	}
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/MixinFogRenderer.java

@@ -0,0 +1,40 @@
+package com.seibel.lod.fabric.mixins;
+
+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;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+
+import net.minecraft.client.Camera;
+import net.minecraft.client.renderer.FogRenderer;
+import net.minecraft.client.renderer.FogRenderer.FogMode;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.level.material.FogType;
+
+@Mixin(FogRenderer.class)
+public class MixinFogRenderer {
+    private static final ILodConfigWrapperSingleton CONFIG = SingletonHandler.get(ILodConfigWrapperSingleton.class);
+
+	// Using this instead of Float.MAX_VALUE because Sodium don't like it.
+	private static final float A_REALLY_REALLY_BIG_VALUE = 420694206942069.F;
+	private static final float A_EVEN_LARGER_VALUE = 42069420694206942069.F;
+	
+	@Inject(at = @At("RETURN"), method = "setupFog(Lnet/minecraft/client/Camera;Lnet/minecraft/client/renderer/FogRenderer$FogMode;FZ)V")
+	private static void disableSetupFog(Camera camera, FogMode fogMode, float f, boolean bl, CallbackInfo callback) {
+	    FogType fogTypes = camera.getFluidInCamera();
+	    Entity entity = camera.getEntity();
+	    boolean isUnderWater = (entity instanceof LivingEntity) && ((LivingEntity)entity).hasEffect(MobEffects.BLINDNESS);
+	    if (!isUnderWater) {
+			if (fogMode == FogMode.FOG_TERRAIN && fogTypes == FogType.NONE && CONFIG.client().graphics().fogQuality().getDisableVanillaFog()) {
+			    RenderSystem.setShaderFogStart(A_REALLY_REALLY_BIG_VALUE);
+			    RenderSystem.setShaderFogEnd(A_EVEN_LARGER_VALUE);
+			}
+	    }
+	}
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/MixinMinecraft.java

@@ -0,0 +1,21 @@
+package com.seibel.lod.fabric.mixins;
+
+import com.seibel.lod.fabric.Main;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.main.GameConfig;
+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;
+
+/**
+ * Loads the mod after minecraft loads.
+ * @author Ran
+ */
+@Mixin(value = Minecraft.class)
+public class MixinMinecraft {
+    @Inject(method = "<init>", at = @At("TAIL"))
+    private void startMod(GameConfig gameConfig, CallbackInfo ci) {
+        Main.init();
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/MixinOptionsScreen.java

@@ -0,0 +1,52 @@
+package com.seibel.lod.fabric.mixins;
+
+import com.seibel.lod.common.wrappers.config.ConfigGui;
+import com.seibel.lod.common.wrappers.config.TexturedButtonWidget;
+import com.seibel.lod.core.ModInfo;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import net.minecraft.client.gui.screens.OptionsScreen;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.resources.ResourceLocation;
+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;
+
+import java.util.Objects;
+
+/**
+ * Adds a button to the menu to goto the config
+ *
+ * @author coolGi2007
+ * @version 12-02-2021
+ */
+@Mixin(OptionsScreen.class)
+public class MixinOptionsScreen extends Screen {
+    // Get the texture for the button
+    private static final ResourceLocation ICON_TEXTURE = new ResourceLocation(ModInfo.ID,"textures/gui/button.png");
+    protected MixinOptionsScreen(Component title) {
+        super(title);
+    }
+
+    @Inject(at = @At("HEAD"),method = "init")
+    private void lodconfig$init(CallbackInfo ci) {
+        if (SingletonHandler.get(ILodConfigWrapperSingleton.class).client().getOptionsButton())
+            this.addRenderableWidget(new TexturedButtonWidget(
+                    // Where the button is on the screen
+                    this.width / 2 - 180, this.height / 6 - 12,
+                    // Width and height of the button
+                    20, 20,
+                    // Offset
+                    0, 0,
+                    // Some textuary stuff
+                    20, ICON_TEXTURE, 20, 40,
+                    // Create the button and tell it where to go
+                    // For now it goes to the client option by default
+                    (buttonWidget) -> Objects.requireNonNull(minecraft).setScreen(ConfigGui.getScreen(this, "client")),
+                    // Add a title to the screen
+                    new TranslatableComponent("text.autoconfig." + ModInfo.ID + ".title")));
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/MixinWorldRenderer.java

@@ -0,0 +1,76 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.fabric.mixins;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.math.Matrix4f;
+import com.seibel.lod.common.wrappers.McObjectConverter;
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.objects.math.Mat4f;
+import net.minecraft.client.renderer.LevelRenderer;
+import net.minecraft.client.renderer.RenderType;
+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;
+
+/**
+ * This class is used to mix in my rendering code
+ * before Minecraft starts rendering blocks.
+ * If this wasn't done, and we used Forge's
+ * render last event, the LODs would render on top
+ * of the normal terrain.
+ *
+ * This is also the mixin for rendering the clouds
+ *
+ * @author coolGi2007
+ * @author James Seibel
+ * @version 12-31-2021
+ */
+@Mixin(LevelRenderer.class)
+public class MixinWorldRenderer
+{
+	private static float previousPartialTicks = 0;
+
+	public MixinWorldRenderer() {
+		throw new NullPointerException("Null cannot be cast to non-null type.");
+	}
+
+	@Inject(method = "renderClouds", at = @At("HEAD"), cancellable = true)
+	public void renderClouds(PoseStack poseStack, Matrix4f projectionMatrix, float tickDelta, double cameraX, double cameraY, double cameraZ, CallbackInfo ci) {
+		// get the partial ticks since renderChunkLayer doesn't
+		// have access to them
+		previousPartialTicks = tickDelta;
+	}
+
+	// HEAD or RETURN
+	@Inject(at = @At("HEAD"), method = "renderChunkLayer(Lnet/minecraft/client/renderer/RenderType;Lcom/mojang/blaze3d/vertex/PoseStack;DDDLcom/mojang/math/Matrix4f;)V")
+	private void renderChunkLayer(RenderType renderType, PoseStack modelViewMatrixStack, double cameraXBlockPos, double cameraYBlockPos, double cameraZBlockPos, Matrix4f projectionMatrix, CallbackInfo callback)
+	{
+		// only render before solid blocks
+		if (renderType.equals(RenderType.solid()))
+		{
+			Mat4f mcModelViewMatrix = McObjectConverter.Convert(modelViewMatrixStack.last().pose());
+			Mat4f mcProjectionMatrix = McObjectConverter.Convert(projectionMatrix);
+
+			ClientApi.INSTANCE.renderLods(mcModelViewMatrix, mcProjectionMatrix, previousPartialTicks);
+		}
+	}
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/events/MixinBlockUpdate.java

@@ -0,0 +1,28 @@
+package com.seibel.lod.fabric.mixins.events;
+
+import com.seibel.lod.fabric.Main;
+import net.minecraft.client.Minecraft;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.protocol.game.ClientGamePacketListener;
+import net.minecraft.network.protocol.game.ClientboundBlockUpdatePacket;
+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;
+
+/**
+ * If someone has a better way to do this then please let me know.
+ *
+ * @author Ran
+ */
+@Mixin(ClientboundBlockUpdatePacket.class)
+public abstract class MixinBlockUpdate {
+    @Shadow
+    public abstract BlockPos getPos();
+
+    @Inject(method = "handle(Lnet/minecraft/network/protocol/game/ClientGamePacketListener;)V", at = @At("TAIL"))
+    private void onBlockUpdate(ClientGamePacketListener clientGamePacketListener, CallbackInfo ci) {
+        Main.client_proxy.blockChangeEvent(Minecraft.getInstance().player.clientLevel, this.getPos());
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/events/MixinClientLevel.java

@@ -0,0 +1,28 @@
+package com.seibel.lod.fabric.mixins.events;
+
+import com.seibel.lod.fabric.Main;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.client.renderer.LevelRenderer;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.util.profiling.ProfilerFiller;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.dimension.DimensionType;
+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;
+
+import java.util.function.Supplier;
+
+/**
+ * This class is used for world loading events
+ * @author Ran
+ */
+@Mixin(ClientLevel.class)
+public class MixinClientLevel {
+    @Inject(method = "<init>", at = @At("TAIL"))
+    private void loadWorldEvent(ClientPacketListener clientPacketListener, ClientLevel.ClientLevelData clientLevelData, ResourceKey<Level> resourceKey, DimensionType dimensionType, int i, Supplier<ProfilerFiller> supplier, LevelRenderer levelRenderer, boolean bl, long l, CallbackInfo ci) {
+        Main.client_proxy.worldLoadEvent((ClientLevel) (Object) this);
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/events/MixinMinecraft.java

@@ -0,0 +1,32 @@
+package com.seibel.lod.fabric.mixins.events;
+
+import com.seibel.lod.fabric.Main;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.multiplayer.ClientLevel;
+
+import org.jetbrains.annotations.Nullable;
+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;
+
+/**
+ * This class is used for world unloading events
+ * @author Ran
+ */
+@Mixin(Minecraft.class)
+public class MixinMinecraft {
+    @Shadow @Nullable public ClientLevel level;
+
+    @Inject(method = "setLevel", at = @At("HEAD"))
+    private void unloadWorldEvent_sL(ClientLevel clientLevel, CallbackInfo ci) {
+        if (level != null) Main.client_proxy.worldUnloadEvent(level);
+    }
+
+    @Inject(method = "clearLevel(Lnet/minecraft/client/gui/screens/Screen;)V", at = @At("HEAD"))
+    private void unloadWorldEvent_cL(Screen screen, CallbackInfo ci) {
+        if (this.level != null) Main.client_proxy.worldUnloadEvent(this.level);
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/events/MixinServerLevel.java

@@ -0,0 +1,26 @@
+package com.seibel.lod.fabric.mixins.events;
+
+import com.seibel.lod.fabric.Main;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.ProgressListener;
+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;
+
+/**
+ * This class is used for world saving events
+ * @author Ran
+ */
+@Mixin(ServerLevel.class)
+public class MixinServerLevel {
+    @Inject(method = "save", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/entity/PersistentEntitySectionManager;saveAll()V", shift = At.Shift.AFTER))
+    private void saveWorldEvent_sA(ProgressListener progressListener, boolean bl, boolean bl2, CallbackInfo ci) {
+        Main.client_proxy.worldSaveEvent();
+    }
+
+    @Inject(method = "save", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/entity/PersistentEntitySectionManager;autoSave()V", shift = At.Shift.AFTER))
+    private void saveWorldEvent_aS(ProgressListener progressListener, boolean bl, boolean bl2, CallbackInfo ci) {
+        Main.client_proxy.worldSaveEvent();
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/mixins/unsafe/MixinPalettedContainer.java

@@ -0,0 +1,27 @@
+package com.seibel.lod.fabric.mixins.unsafe;
+
+import net.minecraft.world.level.chunk.PalettedContainer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+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.concurrent.Semaphore;
+
+/**
+ * NOTE: THIS IS NOT A FIX TO THE PROBLEM.
+ * TODO: Do/Find an actual fix to this
+ *
+ * @author Ran
+ */
+@Mixin(PalettedContainer.class)
+public class MixinPalettedContainer {
+    @Mutable
+    private Semaphore lock;
+
+    @Inject(method = "<init>", at = @At("RETURN"))
+    private void setSemaphore(CallbackInfo ci) {
+        this.lock = new Semaphore(2);
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/wrappers/DependencySetup.java

@@ -0,0 +1,23 @@
+package com.seibel.lod.fabric.wrappers;
+
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.common.wrappers.config.LodConfigWrapperSingleton;
+
+/**
+ * Binds all necessary dependencies, so we
+ * can access them in Core. <br>
+ * This needs to be called before any Core classes
+ * are loaded.
+ * 
+ * @author James Seibel
+ * @author Ran
+ * @version 12-1-2021
+ */
+public class DependencySetup
+{
+	public static void createInitialBindings()
+	{
+		SingletonHandler.bind(ILodConfigWrapperSingleton.class, LodConfigWrapperSingleton.INSTANCE);
+	}
+}

fabric/src/main/java/com/seibel/lod/fabric/wrappers/config/ModMenuIntegration.java

@@ -0,0 +1,19 @@
+package com.seibel.lod.fabric.wrappers.config;
+
+import com.seibel.lod.common.wrappers.config.ConfigGui;
+import com.terraformersmc.modmenu.api.ConfigScreenFactory;
+import com.terraformersmc.modmenu.api.ModMenuApi;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+
+/**
+ * For making the config show up in modmenu
+ */
+@Environment(EnvType.CLIENT)
+public class ModMenuIntegration implements ModMenuApi {
+    // For the custom config code
+    @Override
+    public ConfigScreenFactory<?> getModConfigScreenFactory() {
+        return parent -> ConfigGui.getScreen(parent, "");
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/wrappers/modAccessor/ModChecker.java

@@ -0,0 +1,14 @@
+
+package com.seibel.lod.fabric.wrappers.modAccessor;
+
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IModChecker;
+import net.fabricmc.loader.api.FabricLoader;
+
+public class ModChecker implements IModChecker {
+    public static final ModChecker INSTANCE = new ModChecker();
+
+    @Override
+    public boolean isModLoaded(String modid) {
+        return FabricLoader.getInstance().isModLoaded(modid);
+    }
+}

fabric/src/main/java/com/seibel/lod/fabric/wrappers/modAccessor/OptifineAccessor.java

@@ -0,0 +1,24 @@
+package com.seibel.lod.fabric.wrappers.modAccessor;
+
+import java.util.HashSet;
+
+import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
+
+public class OptifineAccessor implements IOptifineAccessor
+{
+
+    @Override
+    public String getModName()
+    {
+        return "Optifine-Fabric-1.18.X";
+    }
+
+    @Override
+    public HashSet<AbstractChunkPosWrapper> getNormalRenderedChunks()
+    {
+        // TODO: Impl proper methods here
+        return null;
+    }
+
+}

fabric/src/main/java/com/seibel/lod/fabric/wrappers/modAccessor/SodiumAccessor.java

@@ -0,0 +1,36 @@
+package com.seibel.lod.fabric.wrappers.modAccessor;
+
+import java.util.HashSet;
+import java.util.stream.Collectors;
+
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.ISodiumAccessor;
+
+
+import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.world.level.LevelHeightAccessor;
+
+public class SodiumAccessor implements ISodiumAccessor {
+	private final IMinecraftRenderWrapper MC_RENDER = SingletonHandler.get(IMinecraftRenderWrapper.class);
+
+    @Override
+    public String getModName() {
+    	return "Sodium-Fabric-1.17.1";
+	}
+
+	@Override
+	public HashSet<AbstractChunkPosWrapper> getNormalRenderedChunks() {
+		SodiumWorldRenderer renderer = SodiumWorldRenderer.instance();
+		LevelHeightAccessor height = Minecraft.getInstance().level;
+		
+		// TODO: Maybe use a mixin to make this more efficient
+		return MC_RENDER.getMaximumRenderedChunks().stream().filter((AbstractChunkPosWrapper chunk) -> {
+			return (renderer.isBoxVisible(
+					chunk.getMinBlockX()+1, height.getMinBuildHeight()+1, chunk.getMinBlockZ()+1,
+					chunk.getMinBlockX()+15, height.getMaxBuildHeight()-1, chunk.getMinBlockZ()+15));
+		}).collect(Collectors.toCollection(HashSet::new));
+	}
+}

fabric/src/main/resources/LICENSE-MinecraftForge.txt

@@ -0,0 +1,458 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS

fabric/src/main/resources/fabric.lod.mixins.json

@@ -0,0 +1,24 @@
+{
+  "required": true,
+  "minVersion": "0.8",
+  "package": "com.seibel.lod.fabric.mixins",
+  "compatibilityLevel": "JAVA_16",
+  "mixins": [
+    "events.MixinServerLevel",
+    "unsafe.MixinPalettedContainer"
+  ],
+  "client": [
+    "MixinMinecraft",
+    "MixinOptionsScreen",
+    "MixinWorldRenderer",
+    "MixinFogRenderer",
+    "MixinChunkGenerator",
+    "events.MixinClientLevel",
+    "events.MixinMinecraft",
+    "events.MixinBlockUpdate"
+  ],
+  "server": [],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}

fabric/src/main/resources/fabric.mod.json

@@ -0,0 +1,51 @@
+{
+  "schemaVersion": 1,
+  "id": "lod",
+  "version": "${version}",
+
+  "name": "${mod_name}",
+  "description": "${description}",
+  "authors": ["${authors}"],
+
+  "contact": {
+    "homepage": "https://www.curseforge.com/minecraft/mc-mods/distant-horizons",
+    "sources": "https://gitlab.com/jeseibel/minecraft-lod-mod/",
+    "issues": "https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues"
+  },
+
+  "license": "CC0-1.0",
+  "icon": "icon.png",
+
+  "environment": "client",
+  "entrypoints": {
+    "client": [
+      "com.seibel.lod.fabric.Main"
+    ],
+    "modmenu": [
+      "com.seibel.lod.fabric.wrappers.config.ModMenuIntegration"
+    ]
+  },
+
+  "mixins": [
+    "fabric.lod.mixins.json"
+  ],
+
+  "accessWidener" : "lod.accesswidener",
+  "depends": {
+    "fabricloader": "*",
+    "fabric": "*",
+    "minecraft": "1.17.x",
+    "java": ">=16"
+  },
+  "suggests": {
+    "another-mod": "*"
+  },
+
+  "custom": {
+    "modmenu": {
+      "links": {
+        "modmenu.discord": "https://discord.gg/xAB8G4cENx"
+      }
+    }
+  }
+}

forge/build.gradle

@@ -0,0 +1,141 @@
+plugins {
+    id "com.github.johnrengelman.shadow" version "7.0.0"
+}
+
+version = rootProject.mod_version+"-"+rootProject.minecraft_version+"-"+new Date().format("yyyy_MM_dd_HH_mm")
+
+loom {
+    accessWidenerPath.set(project(":common").file("src/main/resources/lod.accesswidener"))
+
+    forge {
+        convertAccessWideners.set(true)
+        extraAccessWideners.add("lod.accesswidener")
+        mixinConfigs("lod.mixins.json")
+    }
+}
+
+architectury {
+    platformSetupLoomIde()
+    forge()
+}
+
+configurations {
+    compileClasspath.extendsFrom common
+    runtimeClasspath.extendsFrom common
+    developmentForge.extendsFrom common
+}
+
+dependencies {
+    // Forge loader
+    forge "net.minecraftforge:forge:${rootProject.minecraft_version}-${rootProject.forge_version}"
+
+    common(project(path: ":common", configuration: "namedElements")) { transitive false }
+    shadowMe(project(path: ":common", configuration: "transformProductionForge")) { transitive = false }
+
+    // Starlight
+//    modImplementation("curse.maven:starlight-forge-526854:${rootProject.starlight_version_forge}")
+
+//    forgeDependencies(project(":core")) { transitive false }
+
+
+    // Toml
+    shadowMe("com.electronwill.night-config:toml:${rootProject.toml_version}") {}
+
+    forgeDependencies('org.tukaani:xz:1.9')
+    forgeDependencies('org.apache.commons:commons-compress:1.21')
+    shadowMe 'org.tukaani:xz:1.9'
+    shadowMe 'org.apache.commons:commons-compress:1.21'
+}
+
+task copyCoreResources(type: Copy) {
+    from fileTree(project(":core").file("src/main/resources"))
+    into file("build/resources/main")
+}
+
+task copyCommonResources(type: Copy) {
+    from fileTree(project(":common").file("src/main/resources"))
+    into file("build/resources/main")
+}
+
+// Put stuff from gradle.properties into the mod info stuff
+def resourceTargets = ["META-INF/mods.toml"]
+def intoTargets = ["$buildDir/resources/main/"]
+def replaceProperties = [
+        version: mod_version,
+        mod_name: mod_name,
+        authors: mod_authors,
+        description: mod_description
+]
+
+processResources {
+    dependsOn(copyCoreResources)
+    dependsOn(copyCommonResources)
+    inputs.properties replaceProperties
+    replaceProperties.put 'project', project
+    filesMatching(resourceTargets) {
+        expand replaceProperties
+    }
+
+    intoTargets.each { target ->
+        if (file(target).exists()) {
+            copy {
+                from(sourceSets.main.resources) {
+                    include resourceTargets
+                    expand replaceProperties
+                }
+                into target
+            }
+        }
+    }
+}
+
+shadowJar {
+    dependencies {
+        exclude(dependency("net.fabricmc:fabric-loader:${rootProject.fabric_loader_version}"))
+    }
+    exclude "fabric.mod.json"
+    configurations = [project.configurations.shadowMe]
+    relocate 'org.tukaani', 'shaded.tukaani'
+    relocate 'org.apache.commons.compress', 'shaded.apache.commons.compress'
+    relocate 'com.electronwill.nightconfig', 'shaded.electronwill.nightconfig'    // This is already included with forge
+
+    relocate 'com.seibel.lod.common', 'forge.com.seibel.lod.common'
+
+    classifier "dev-shadow"
+}
+
+remapJar {
+    input.set shadowJar.archiveFile
+    dependsOn shadowJar
+    classifier null
+}
+
+jar {
+    classifier "dev"
+}
+
+sourcesJar {
+    def commonSources = project(":common").sourcesJar
+    dependsOn commonSources
+    from commonSources.archiveFile.map { zipTree(it) }
+}
+
+components.java {
+    withVariantsFromConfiguration(project.configurations.shadowRuntimeElements) {
+        skip()
+    }
+}
+
+publishing {
+    publications {
+        mavenForge(MavenPublication) {
+            artifactId = rootProject.archives_base_name + "-" + project.name
+            from components.java
+        }
+    }
+
+    // See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
+    repositories {
+        // Add repositories to publish to here.
+    }
+}

forge/gradle.properties

@@ -0,0 +1 @@
+loom.platform=forge

forge/src/main/java/com/seibel/lod/forge/ForgeClientProxy.java

@@ -0,0 +1,114 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.forge;
+
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.api.EventApi;
+import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper;
+
+import org.lwjgl.glfw.GLFW;
+
+import com.seibel.lod.common.wrappers.chunk.ChunkWrapper;
+import com.seibel.lod.common.wrappers.world.DimensionTypeWrapper;
+import com.seibel.lod.common.wrappers.world.WorldWrapper;
+
+import net.minecraft.client.Minecraft;
+import net.minecraftforge.client.event.InputEvent;
+import net.minecraftforge.event.TickEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.event.world.ChunkEvent;
+import net.minecraftforge.event.world.WorldEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+
+/**
+ * This handles all events sent to the client,
+ * and is the starting point for most of the mod.
+ *
+ * @author James_Seibel
+ * @version 11-12-2021
+ */
+public class ForgeClientProxy
+{
+	private final EventApi eventApi = EventApi.INSTANCE;
+	private final ClientApi clientApi = ClientApi.INSTANCE;
+
+
+
+	@SubscribeEvent
+	public void serverTickEvent(TickEvent.ServerTickEvent event)
+	{
+		if (event.phase != TickEvent.Phase.START) return;
+		eventApi.serverTickEvent();
+	}
+
+	@SubscribeEvent
+	public void chunkLoadEvent(ChunkEvent.Load event)
+	{
+		clientApi.clientChunkLoadEvent(new ChunkWrapper(event.getChunk(), event.getWorld()), WorldWrapper.getWorldWrapper(event.getWorld()));
+	}
+
+	@SubscribeEvent
+	public void worldSaveEvent(WorldEvent.Save event)
+	{
+		eventApi.worldSaveEvent();
+	}
+
+	/** This is also called when a new dimension loads */
+	@SubscribeEvent
+	public void worldLoadEvent(WorldEvent.Load event)
+	{
+		if (event.getWorld() != null) {
+			eventApi.worldLoadEvent(WorldWrapper.getWorldWrapper(event.getWorld()));
+		}
+	}
+
+	@SubscribeEvent
+	public void worldUnloadEvent(WorldEvent.Unload event)
+	{
+		eventApi.worldUnloadEvent(WorldWrapper.getWorldWrapper(event.getWorld()));
+	}
+
+	@SubscribeEvent
+	public void blockChangeEvent(BlockEvent event)
+	{
+		// we only care about certain block events
+		if (event.getClass() == BlockEvent.BreakEvent.class ||
+				event.getClass() == BlockEvent.EntityPlaceEvent.class ||
+				event.getClass() == BlockEvent.EntityMultiPlaceEvent.class ||
+				event.getClass() == BlockEvent.FluidPlaceBlockEvent.class ||
+				event.getClass() == BlockEvent.PortalSpawnEvent.class)
+		{
+			IChunkWrapper chunk = new ChunkWrapper(event.getWorld().getChunk(event.getPos()), event.getWorld());
+			DimensionTypeWrapper dimType = DimensionTypeWrapper.getDimensionTypeWrapper(event.getWorld().dimensionType());
+
+			// recreate the LOD where the blocks were changed
+			eventApi.blockChangeEvent(chunk, dimType);
+		}
+	}
+
+	@SubscribeEvent
+	public void onKeyInput(InputEvent.KeyInputEvent event)
+	{
+		if (Minecraft.getInstance().player == null) return;
+		if (event.getAction() != GLFW.GLFW_PRESS) return;
+		clientApi.keyPressedEvent(event.getKey());
+	}
+
+}

forge/src/main/java/com/seibel/lod/forge/ForgeMain.java

@@ -0,0 +1,112 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.forge;
+
+import com.seibel.lod.common.LodCommonMain;
+import com.seibel.lod.common.forge.LodForgeMethodCaller;
+import com.seibel.lod.common.wrappers.config.ConfigGui;
+import com.seibel.lod.common.wrappers.minecraft.MinecraftWrapper;
+import com.seibel.lod.core.ModInfo;
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.api.ModAccessorApi;
+import com.seibel.lod.core.handlers.ReflectionHandler;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IModChecker;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
+import com.seibel.lod.forge.wrappers.ForgeDependencySetup;
+
+import com.seibel.lod.forge.wrappers.modAccessor.ModChecker;
+import com.seibel.lod.forge.wrappers.modAccessor.OptifineAccessor;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.client.model.data.ModelDataMap;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.ModLoadingContext;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
+import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+import net.minecraftforge.fml.loading.FMLLoader;
+import net.minecraftforge.fmlclient.ConfigGuiHandler;
+
+import java.util.List;
+import java.util.Random;
+
+/**
+ * Initialize and setup the Mod. <br>
+ * If you are looking for the real start of the mod
+ * check out the ClientProxy.
+ *
+ * @author James Seibel
+ * @version 11-21-2021
+ */
+@Mod(ModInfo.ID)
+public class ForgeMain implements LodForgeMethodCaller
+{
+	public static ForgeClientProxy forgeClientProxy;
+
+	private void init(final FMLCommonSetupEvent event)
+	{
+		// make sure the dependencies are set up before the mod needs them
+		LodCommonMain.initConfig();
+		LodCommonMain.startup(this, !FMLLoader.getDist().isClient());
+		ForgeDependencySetup.createInitialBindings();
+		ClientApi.LOGGER.info("Distant Horizons initializing...");
+		SingletonHandler.bind(IModChecker.class, ModChecker.INSTANCE);
+
+		if (ReflectionHandler.instance.optifinePresent()) {
+			ModAccessorApi.bind(IOptifineAccessor.class, new OptifineAccessor());
+		}
+	}
+
+
+	public ForgeMain()
+	{
+		// Register the methods
+		FMLJavaModLoadingContext.get().getModEventBus().addListener(this::init);
+		FMLJavaModLoadingContext.get().getModEventBus().addListener(this::onClientStart);
+
+		// Register ourselves for server and other game events we are interested in
+		MinecraftForge.EVENT_BUS.register(this);
+	}
+
+	private void onClientStart(final FMLClientSetupEvent event)
+	{
+		ModLoadingContext.get().registerExtensionPoint(ConfigGuiHandler.ConfigGuiFactory.class,
+				() -> new ConfigGuiHandler.ConfigGuiFactory((client, parent) -> ConfigGui.getScreen(parent, "")));
+		forgeClientProxy = new ForgeClientProxy();
+		MinecraftForge.EVENT_BUS.register(forgeClientProxy);
+	}
+
+	private ModelDataMap dataMap = new ModelDataMap.Builder().build();
+	@Override
+	public List<BakedQuad> getQuads(MinecraftWrapper mc, Block block, BlockState blockState, Direction direction, Random random) {
+		return mc.getModelManager().getBlockModelShaper().getBlockModel(block.defaultBlockState()).getQuads(blockState, direction, random, dataMap);
+	}
+
+
+	@Override
+	public int getPixelRGBA(TextureAtlasSprite sprite, int frameIndex, int x, int y) {
+		return sprite.getPixelRGBA(frameIndex, x, y);
+	}
+}

forge/src/main/java/com/seibel/lod/forge/mixins/MixinChunkGenerator.java

@@ -0,0 +1,29 @@
+package com.seibel.lod.forge.mixins;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.world.level.StructureFeatureManager;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.WorldgenRandom;
+
+@Mixin(ChunkGenerator.class)
+public class MixinChunkGenerator {
+	@Redirect(method = "applyBiomeDecoration", at = @At(
+			value = "INVOKE",
+			target = "Lnet/minecraft/world/level/biome/Biome;generate(Lnet/minecraft/world/level/StructureFeatureManager;"
+					+ "Lnet/minecraft/world/level/chunk/ChunkGenerator;Lnet/minecraft/server/level/WorldGenRegion;J"
+					+ "Lnet/minecraft/world/level/levelgen/WorldgenRandom;Lnet/minecraft/core/BlockPos;)V"
+			
+	))
+	private void wrapBiomeGenerateCall(Biome biome, StructureFeatureManager structFeatManager, ChunkGenerator generator,
+			WorldGenRegion genRegion, long l, WorldgenRandom random, BlockPos pos) {
+		synchronized((ChunkGenerator)(Object)this) {
+			biome.generate(structFeatManager, (ChunkGenerator)(Object)this, genRegion, l, random, pos);
+		}
+	}
+}

forge/src/main/java/com/seibel/lod/forge/mixins/MixinFogRenderer.java

@@ -0,0 +1,46 @@
+package com.seibel.lod.forge.mixins;
+
+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;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+
+import net.minecraft.client.Camera;
+import net.minecraft.client.renderer.FogRenderer;
+import net.minecraft.client.renderer.FogRenderer.FogMode;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.level.material.FogType;
+
+@Mixin(FogRenderer.class)
+public class MixinFogRenderer {
+	// Using this instead of Float.MAX_VALUE because Sodium don't like it. (And just in case it's here also for forge)
+	private static final float A_REALLY_REALLY_BIG_VALUE = 420694206942069.F;
+	private static final float A_EVEN_LARGER_VALUE = 42069420694206942069.F;
+	
+	@Inject(at = @At("RETURN"),
+		method = "setupFog(Lnet/minecraft/client/Camera;Lnet/minecraft/client/renderer/FogRenderer$FogMode;FZF)V",
+		remap = false) // Due to this being a forge added method
+	private static void disableSetupFog(Camera camera, FogMode fogMode, float f, boolean bl, float tick, CallbackInfo callback) {
+	    ILodConfigWrapperSingleton CONFIG;
+	    try {
+	    	CONFIG = SingletonHandler.get(ILodConfigWrapperSingleton.class);
+	    } catch (NullPointerException e) {
+	    	return; // Happens on forge not loading the mod before this.
+	    }
+		FogType fogTypes = camera.getFluidInCamera();
+	    Entity entity = camera.getEntity();
+	    boolean isUnderWater = (entity instanceof LivingEntity) && ((LivingEntity)entity).hasEffect(MobEffects.BLINDNESS);
+	    if (!isUnderWater) {
+			if (fogMode == FogMode.FOG_TERRAIN && fogTypes == FogType.NONE && CONFIG.client().graphics().fogQuality().getDisableVanillaFog()) {
+			    RenderSystem.setShaderFogStart(A_REALLY_REALLY_BIG_VALUE);
+			    RenderSystem.setShaderFogEnd(A_EVEN_LARGER_VALUE);
+			}
+	    }
+	}
+}

forge/src/main/java/com/seibel/lod/forge/mixins/MixinOptionsScreen.java

@@ -0,0 +1,52 @@
+package com.seibel.lod.forge.mixins;
+
+import com.seibel.lod.common.wrappers.config.ConfigGui;
+import com.seibel.lod.common.wrappers.config.TexturedButtonWidget;
+import com.seibel.lod.core.ModInfo;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import net.minecraft.client.gui.screens.OptionsScreen;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.resources.ResourceLocation;
+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;
+
+import java.util.Objects;
+
+/**
+ * Adds a button to the menu to goto the config
+ *
+ * @author coolGi2007
+ * @version 12-02-2021
+ */
+@Mixin(OptionsScreen.class)
+public class MixinOptionsScreen extends Screen {
+    // Get the texture for the button
+    private static final ResourceLocation ICON_TEXTURE = new ResourceLocation(ModInfo.ID,"textures/gui/button.png");
+    protected MixinOptionsScreen(Component title) {
+        super(title);
+    }
+
+    @Inject(at = @At("HEAD"),method = "init")
+    private void lodconfig$init(CallbackInfo ci) {
+        if (SingletonHandler.get(ILodConfigWrapperSingleton.class).client().getOptionsButton())
+            this.addRenderableWidget(new TexturedButtonWidget(
+                    // Where the button is on the screen
+                    this.width / 2 - 180, this.height / 6 - 12,
+                    // Width and height of the button
+                    20, 20,
+                    // Offset
+                    0, 0,
+                    // Some textuary stuff
+                    20, ICON_TEXTURE, 20, 40,
+                    // Create the button and tell it where to go
+                    // For now it goes to the client option by default
+                    (buttonWidget) -> Objects.requireNonNull(minecraft).setScreen(ConfigGui.getScreen(this, "client")),
+                    // Add a title to the screen
+                    new TranslatableComponent("text.autoconfig." + ModInfo.ID + ".title")));
+    }
+}

forge/src/main/java/com/seibel/lod/forge/mixins/MixinWorldRenderer.java

@@ -0,0 +1,76 @@
+/*
+ *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
+ *    licensed under the GNU GPL v3 License.
+ *
+ *    Copyright (C) 2020  James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 3.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.lod.forge.mixins;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.math.Matrix4f;
+import com.seibel.lod.common.wrappers.McObjectConverter;
+import com.seibel.lod.core.api.ClientApi;
+import com.seibel.lod.core.objects.math.Mat4f;
+import net.minecraft.client.renderer.LevelRenderer;
+import net.minecraft.client.renderer.RenderType;
+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;
+
+/**
+ * This class is used to mix in my rendering code
+ * before Minecraft starts rendering blocks.
+ * If this wasn't done, and we used Forge's
+ * render last event, the LODs would render on top
+ * of the normal terrain.
+ *
+ * This is also the mixin for rendering the clouds
+ *
+ * @author coolGi2007
+ * @author James Seibel
+ * @version 12-31-2021
+ */
+@Mixin(LevelRenderer.class)
+public class MixinWorldRenderer
+{
+	private static float previousPartialTicks = 0;
+
+	public MixinWorldRenderer() {
+		throw new NullPointerException("Null cannot be cast to non-null type.");
+	}
+
+	@Inject(method = "renderClouds", at = @At("HEAD"), cancellable = true)
+	public void renderClouds(PoseStack poseStack, Matrix4f projectionMatrix, float tickDelta, double cameraX, double cameraY, double cameraZ, CallbackInfo ci) {
+		// get the partial ticks since renderChunkLayer doesn't
+		// have access to them
+		previousPartialTicks = tickDelta;
+	}
+
+	// HEAD or RETURN
+	@Inject(at = @At("HEAD"), method = "renderChunkLayer(Lnet/minecraft/client/renderer/RenderType;Lcom/mojang/blaze3d/vertex/PoseStack;DDDLcom/mojang/math/Matrix4f;)V")
+	private void renderChunkLayer(RenderType renderType, PoseStack modelViewMatrixStack, double cameraXBlockPos, double cameraYBlockPos, double cameraZBlockPos, Matrix4f projectionMatrix, CallbackInfo callback)
+	{
+		// only render before solid blocks
+		if (renderType.equals(RenderType.solid()))
+		{
+			Mat4f mcModelViewMatrix = McObjectConverter.Convert(modelViewMatrixStack.last().pose());
+			Mat4f mcProjectionMatrix = McObjectConverter.Convert(projectionMatrix);
+
+			ClientApi.INSTANCE.renderLods(mcModelViewMatrix, mcProjectionMatrix, previousPartialTicks);
+		}
+	}
+}

forge/src/main/java/com/seibel/lod/forge/wrappers/ForgeDependencySetup.java

@@ -0,0 +1,23 @@
+package com.seibel.lod.forge.wrappers;
+
+import com.seibel.lod.common.wrappers.config.LodConfigWrapperSingleton;
+import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+
+/**
+ * Binds all necessary dependencies, so we
+ * can access them in Core. <br>
+ * This needs to be called before any Core classes
+ * are loaded.
+ * 
+ * @author James Seibel
+ * @author Ran
+ * @version 12-1-2021
+ */
+public class ForgeDependencySetup
+{
+	public static void createInitialBindings()
+	{
+		SingletonHandler.bind(ILodConfigWrapperSingleton.class, LodConfigWrapperSingleton.INSTANCE);
+	}
+}

forge/src/main/java/com/seibel/lod/forge/wrappers/modAccessor/ModChecker.java

@@ -0,0 +1,13 @@
+package com.seibel.lod.forge.wrappers.modAccessor;
+
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IModChecker;
+import net.minecraftforge.fml.ModList;
+
+public class ModChecker implements IModChecker {
+    public static final ModChecker INSTANCE = new ModChecker();
+
+    @Override
+    public boolean isModLoaded(String modid) {
+        return ModList.get().isLoaded(modid);
+    }
+}

forge/src/main/java/com/seibel/lod/forge/wrappers/modAccessor/OptifineAccessor.java

@@ -0,0 +1,24 @@
+package com.seibel.lod.forge.wrappers.modAccessor;
+
+import java.util.HashSet;
+
+import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
+
+public class OptifineAccessor implements IOptifineAccessor
+{
+
+    @Override
+    public String getModName()
+    {
+        return "Optifine-Forge-1.18.X";
+    }
+
+    @Override
+    public HashSet<AbstractChunkPosWrapper> getNormalRenderedChunks()
+    {
+        // TODO: Impl proper methods here
+        return null;
+    }
+
+}

forge/src/main/resources/META-INF/mods.toml

@@ -0,0 +1,27 @@
+
+modLoader="javafml" #//mandatory
+loaderVersion="[36,)" # // mandatory. This is typically bumped every Minecraft version by Forge. See our download page for lists of versions.
+license="GNU GPLv3"
+issueTrackerURL="https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues"
+
+
+[[mods]] #//mandatory
+	modId="lod" #//mandatory
+	version= "${version}" #//mandatory, gets the version number from jar populated by the build.gradle script
+	displayName="${mod_name}" #//mandatory
+	#//updateJSONURL="https://change.me.example.invalid/updates.json" # A URL to query for updates for this mod. See the JSON update specification https://mcforge.readthedocs.io/en/latest/gettingstarted/autoupdate/
+	displayURL="https://www.curseforge.com/minecraft/mc-mods/distant-horizons"
+	logoFile="logo.png"
+	catalogueImageIcon="icon.png"
+	credits="Massive thanks to: Leonardo, Cola, Ran, and CoolGi. For their hard work to bring Distant Horizons to where it is today. - James"
+	authors="${authors}"
+	#//mandatory. The description text for the mod
+	description= ''' ${description} '''
+	#// if not set defaults to "false"
+	clientSideOnly="true"
+	#// if not set defaults to "BOTH"
+	#// TODO change to "BOTH" when we add server support
+	side="CLIENT"
+	#// Allow any version to be present (or not) on the server
+	acceptableRemoteVersions="*"
+

forge/src/main/resources/lod.mixins.json

@@ -0,0 +1,15 @@
+{
+	"required": true,
+	"minVersion": "0.8",
+	"package": "com.seibel.lod.forge.mixins",
+	"compatibilityLevel": "JAVA_16",
+	"mixins": [
+    	"MixinChunkGenerator"
+	],
+	"client": [
+		"MixinOptionsScreen",
+		"MixinWorldRenderer",
+		"MixinFogRenderer"
+	],
+	"server": []
+}

forge/src/main/resources/pack.mcmeta

@@ -0,0 +1,6 @@
+{
+    "pack": {
+        "description": "",
+        "pack_format": 7
+    }
+}

gradle.properties

@@ -1,4 +1,30 @@
-# Sets default memory used for gradle commands. Can be overridden by user or command line properties.
-# This is required to provide enough memory for the Minecraft decompilation process.
-org.gradle.jvmargs=-Xmx3G
-org.gradle.daemon=false
+org.gradle.jvmargs=-Xmx2048M
+
+minecraft_version=1.17.1
+
+archives_base_name=DistantHorizons
+mod_version=1.6.0a
+maven_group=com.seibel.lod
+toml_version=3.6.4
+
+# Mod info
+mod_name=Distant Horizons
+mod_description=This mod generates and renders simplified terrain beyond the normal view distance at a low performance cost. Allowing you to see much farther without turning your game into a slideshow.
+mod_authors=James Seibel, Leonardo Amato, Cola, coolGi2007, Ran, Leetom
+mod_homepage=https://www.curseforge.com/minecraft/mc-mods/distant-horizons
+
+# Fabric loader
+fabric_loader_version=0.12.6
+fabric_api_version=0.37.1+1.17
+    # Fabric mods
+    modmenu_version=2.0.14
+    starlight_version_fabric=3442770
+    lithium_version=mc1.17.1-0.7.5
+    sodium_version=3605275
+    iris_version=1.17.x-v1.1.4
+    immersive_portals_version = 0.14-1.17
+
+# Forge loader
+forge_version=37.1.1
+    # Forge mods
+    starlight_version_forge=3457784

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.3-bin.zip

gradlew

@@ -1,5 +1,21 @@
 #!/usr/bin/env sh
 
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
 ##############################################################################
 ##
 ##  Gradle start up script for UN*X
@@ -28,7 +44,7 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
@@ -56,7 +72,7 @@ case "`uname`" in
   Darwin* )
     darwin=true
     ;;
-  MINGW* )
+  MSYS* | MINGW* )
     msys=true
     ;;
   NONSTOP* )
@@ -66,6 +82,7 @@ esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
@@ -109,10 +126,11 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
     JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
@@ -138,19 +156,19 @@ if $cygwin ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=$((i+1))
+        i=`expr $i + 1`
     done
     case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
@@ -159,14 +177,9 @@ save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }
-APP_ARGS=$(save "$@")
+APP_ARGS=`save "$@"`
 
 # Collect all arguments for the java command, following the shell quoting and substitution rules
 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,3 +1,19 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -13,60 +29,49 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
 @rem Find java.exe
-if defined JAVA_MC_HOME goto findJavaFromJavaHome
+if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
-echo ERROR: JAVA_MC_HOME is not set and no 'java' command could be found in your PATH.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 echo.
-echo Please set the JAVA_MC_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the
 echo location of your Java installation.
 
 goto fail
 
 :findJavaFromJavaHome
-set JAVA_MC_HOME=%JAVA_MC_HOME:"=%
-set JAVA_EXE=%JAVA_MC_HOME%/bin/java.exe
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
-echo ERROR: JAVA_MC_HOME is set to an invalid directory: %JAVA_MC_HOME%
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
 echo.
-echo Please set the JAVA_MC_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the
 echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell