Remove the compiled jars (they are now handled by CurseForge)

Update 1.4 release notes.txt
small change to far Fog
2021-09-05 16:51:26 -05:00 · 2021-09-05 16:50:42 -05:00 · 2021-09-05 16:15:14 +02:00 · 2021-09-04 11:01:26 -05:00 · 2021-09-04 11:01:05 -05:00 · 2021-09-04 11:00:54 -05:00
118 changed files with 10664 additions and 4511 deletions
@@ -0,0 +1,5 @@
+# Disable autocrlf on generated files, they always generate with LF
+# Add any extra files or paths here to make git stop saying they
+# are changed when only line endings change.
+src/generated/**/.cache/cache text eol=lf
+src/generated/**/*.json text eol=lf
@@ -19,8 +19,8 @@ build

 # other
 eclipse
+run

-# minecraft run folder,
-# ignore everything but the mods folder
-run/*
-!run/mods
+# Files from Forge MDK
+logs
+forge*changelog.txt
@@ -1,4 +0,0 @@
-[submodule "ASMHelper"]
-	path = ASMHelper
-	url = https://github.com/squeek502/ASMHelper.git
-	branch = 1.12.x
@@ -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 he 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.
-
@@ -1,10 +0,0 @@
-IBXM is copyright (c) 2007, Martin Cameron, and is licensed under the BSD License.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-Neither the name of mumart nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
@@ -1,40 +0,0 @@
-SoundSystem CodecIBXM Class License:
-
-You are free to use this class for any purpose, commercial or otherwise.
-You may modify this class or source code, and distribute it any way you
-like, provided the following conditions are met:
-
-1) You may not falsely claim to be the author of this class or any
-   unmodified portion of it.
-2) You may not copyright this class or a modified version of it and then
-   sue me for copyright infringement.
-3) If you modify the source code, you must clearly document the changes
-   made before redistributing the modified source code, so other users know
-   it is not the original code.
-4) You are not required to give me credit for this class in any derived
-   work, but if you do, you must also mention my website:
-   http://www.paulscode.com
-5) I the author will not be responsible for any damages (physical,
-   financial, or otherwise) caused by the use if this class or any
-   portion of it.
-6) I the author do not guarantee, warrant, or make any representations,
-   either expressed or implied, regarding the use of this class or any
-   portion of it.
-
-Author: Paul Lamb
-http://www.paulscode.com
-
-
-This software is based on or using the IBXM library available from
-http://www.geocities.com/sunet2000/
-
-
-IBXM is copyright (c) 2007, Martin Cameron, and is licensed under the BSD License.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-Neither the name of mumart nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -1,8 +1,17 @@
-This program is an attempt to create Level Of Details (LODs) in Minecraft.
-The purpose is to increase the maximum view distance in game 
+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.

-Used in congunction with:
-https://gitlab.com/jeseibel/minecraft-lod-core-mod
+Or in other words: this mod let's you see farther without turning your game into a slide show.
+If you want to see a quick demo, check out the video I made here:
+https://youtu.be/CCT-3s02tYA
+
+
+Forge version: 1.16.5-36.1.0
+
+Notes:
+This version has been confirmed to work in Eclipse and Retail Minecraft.
+(Retail running forge version 1.16.5-36.1.0)


 ========================
@@ -12,30 +21,50 @@ source code installation
 See the Forge Documentation online for more detailed instructions:
 http://mcforge.readthedocs.io/en/latest/gettingstarted/

-Step 1: open a command line in the project folder
+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: run the command: "./gradlew setupDecompWorkspace"
+Step 2: replace JAVA_HOME with JAVA_MC_HOME in gradle.bat

-Step 3: run the command: "./gradlew eclipse"
+Step 3: open a command line in the project folder

-Step 4: Import project
+Step 4: run the command: "./gradlew geneclipseruns"

-Step 5: 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)
-		And make sure it is used in the build.gradle file.
-
-Step 6: Import the lodcore and lodcore_source jar files into the referenced libraries.
+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)

-
-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.
+Step 7: Import the project into eclipse



-Tip:
-	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.
+=========
+compiling
+=========

-	Current location of mcp-srg.srg:
-	"C:/Users/James Seibel/.gradle/caches/minecraft/de/oceanlabs/mcp/mcp_snapshot/20171003/1.12.2/srgs/"
+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.
+
+Source code uses mcp mappings not Mojangs.
+
+The source code can be 'created' with the ./eclipse command and can be found in the following path:
+minecraft-lod-mod\build\fg_cache\mcp\ VERSION \joined\ RANDOM_STRING \patch\output.jar
@@ -1 +0,0 @@
-these are tools needed for looking at obfuscated minecraft code.
@@ -1 +0,0 @@
-these are tools needed for deobfuscating and looking at the code of optifine.
@@ -1,3 +0,0 @@
-java -jar ./simpledeobf-0.6.jar --input ./OptiFine_1.12.2_HD_U_F5.jar --output ./OptiFine_1.12.2_HD_U_F5_dev.jar  --mapFile C:/Users/James_Seibel/.gradle/caches/minecraft/de/oceanlabs/mcp/mcp_snapshot/20171003/1.12.2/srgs/notch-mcp.srg --ref C:/Users/James_Seibel/.gradle/caches/minecraft/net/minecraft/minecraft/1.12.2/minecraft-1.12.2.jar 
-
-pause
@@ -1 +0,0 @@
-./gradlew build
@@ -1,77 +1,231 @@
 buildscript {
    repositories {
+        maven { url = 'https://files.minecraftforge.net/maven' }
        jcenter()
-        maven { url = "https://files.minecraftforge.net/maven" }
+        mavenCentral()
+        // potential replacement in case of problems:
+		// https://dist.creeper.host/Sponge/maven
+		maven { url = 'https://repo.spongepowered.org/maven/' }
+		// used to download and compile dependencies from git repos 
+		maven { url 'https://jitpack.io' }
    }
    dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
+        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.forge'
-//Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
+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'
+apply plugin: 'java' // needed for compileJava

+version = 'a1.4'
+group = 'com.seibel.lod'
+archivesBaseName = 'lod_1.16.5'

-version = "1.0"
-group = "com.backsun.lod" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
-archivesBaseName = "lod"
+sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.

-sourceCompatibility = targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
 compileJava {
-    sourceCompatibility = targetCompatibility = '1.8'
+    // release 8 is needed because otherwise FloatBuffer.flip() will crash
+    // on some machines
+    // example thread: https://github.com/eclipse/jetty.project/issues/3244
+    options.compilerArgs.addAll(['--release', '8', '-Xlint:unchecked', '-Xlint:deprecation']) 
 }

+println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
 minecraft {
-    version = "1.12.2-14.23.5.2847"
-    runDir = "run"
-    
-    // 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.
+    // 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 = "snapshot_20171003"
+    // Simply re-run your setup task after changing the mappings to update your workspace.
+	mappings channel: 'official', version: '1.16.5'
+
    // 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
+            // The markers can be changed as needed. 
+            // "SCAN": For mods scan.
+            // "REGISTRIES": For firing of registry events.
+            // "REGISTRYDUMP": For getting the contents of all registries.
+            property 'forge.logging.markers', 'REGISTRIES'
+
+            // Recommended logging level for the console
+            // You can set various levels here.
+            // Please read: https://stackoverflow.com/questions/2031163/when-to-use-the-different-log-levels
+            property 'forge.logging.console.level', 'debug'
+
+            mods {
+                examplemod {
+                    source sourceSets.main
+                }
+            }
+        }
+
+        server {
+            workingDirectory project.file('run')
+			arg "-mixin.config=lod.mixins.json"
+			
+            // Recommended logging data for a userdev environment
+            // The markers can be changed as needed. 
+            // "SCAN": For mods scan.
+            // "REGISTRIES": For firing of registry events.
+            // "REGISTRYDUMP": For getting the contents of all registries.
+            property 'forge.logging.markers', 'REGISTRIES'
+
+            // Recommended logging level for the console
+            // You can set various levels here.
+            // Please read: https://stackoverflow.com/questions/2031163/when-to-use-the-different-log-levels
+            property 'forge.logging.console.level', 'debug'
+
+            mods {
+                examplemod {
+                    source sourceSets.main
+                }
+            }
+        }
+
+        data {
+            workingDirectory project.file('run')
+
+            // Recommended logging data for a userdev environment
+            // The markers can be changed as needed. 
+            // "SCAN": For mods scan.
+            // "REGISTRIES": For firing of registry events.
+            // "REGISTRYDUMP": For getting the contents of all registries.
+            property 'forge.logging.markers', 'REGISTRIES'
+
+            // Recommended logging level for the console
+            // You can set various levels here.
+            // Please read: https://stackoverflow.com/questions/2031163/when-to-use-the-different-log-levels
+            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
+                }
+            }
+        }
+    }
+}
+
+// Include resources generated by data generators.
+sourceSets.main.resources { srcDir 'src/generated/resources' }
+
+// this is required so that we can use 
+// jitpack in the dependencies section below 
+repositories {
+    mavenCentral()
+	// used to download and compile dependencies from git repos 
+	maven { url 'https://jitpack.io' }
 }

 dependencies {
-    // 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"
+    // 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.5-36.1.0'
 	
-    // 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
+	// these aren't needed right now
+	//implementation ('com.github.KaptainWutax:TerrainUtils:1.0.0'){
+    //    transitive = false
+    //}
+	//implementation ('com.github.KaptainWutax:BiomeUtils:1.0.0'){
+    //    transitive = false
+    //}
+    //implementation ('com.github.KaptainWutax:SeedUtils:-SNAPSHOT'){
+    //    transitive = false
+    //}
+    //implementation ('com.github.KaptainWutax:MCUtils:1.0.0'){
+    //    transitive = false
+    //}
+    //implementation ('com.github.KaptainWutax:NoiseUtils:1.0.0'){
+    //    transitive = false
+    //}
+    //implementation ('com.github.KaptainWutax:MathUtils:-SNAPSHOT'){
+    //    transitive = false
+    //}
+    
+    // these were added to hopefully allow for cloning
+    // configuredFeatures to allow for safe
+    // multi threaded feature generation. Sadly I couldn't find
+    // a way to duplicate lambda functions (which features use)
+    // so for now I'm not sure what to do.
+    //implementation 'io.github.kostaskougios:cloning:1.10.3'
+    //
+    //implementation ('com.esotericsoftware:kryo:5.1.1') {
+    //  exclude group: "org.objenesis"
+    //}
+    //implementation 'org.objenesis:objenesis:3.2'

-    // 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'

-    // the deobf configurations:  'deobfCompile' and 'deobfProvided' are the same as the normal compile and provided,
-    // except that these dependencies get remapped to your current MCP mappings
-    //deobfCompile 'com.mod-buildcraft:buildcraft:6.0.8:dev'
-    //deobfProvided 'com.mod-buildcraft:buildcraft:6.0.8:dev'
+    // 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"

-    // for more info...
+    // 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

 }

-processResources {
-    // this will ensure that this task is redone when the versions change.
-    inputs.property "version", project.version
-    inputs.property "mcversion", project.minecraft.version
-
-    // replace stuff in mcmod.info, nothing else
-    from(sourceSets.main.resources.srcDirs) {
-        include 'mcmod.info'
-                
-        // replace version and mcversion
-        expand 'version':project.version, 'mcversion':project.minecraft.version
-    }
-        
-    // copy everything else except the mcmod.info
-    from(sourceSets.main.resources.srcDirs) {
-        exclude 'mcmod.info'
+// Example for how to get properties into the manifest for reading by the runtime..
+jar {
+    manifest {
+        attributes([
+            "Specification-Title": "LOD",
+            "Specification-Version": "1", // We are version 1 of ourselves
+            "Implementation-Title": project.name,
+            "Implementation-Version": "{version}",
+            "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 {
+        maven {
+            url "file:///${project.projectDir}/mcmodsrepo"
+        }
+    }
+}
+
+mixin {
+    add sourceSets.main, "lod.refmap.json"
+}
@@ -1,467 +0,0 @@
-=========
-Build: 1.12.2-14.23.5.2846 - Tue Sep 03 21:22:46 GMT 2019
-	ichttt:
-		Fix CME when removing ticket managers (#5861)
-
-=========
-Build: 1.12.2-14.23.5.2844 - Thu Aug 29 02:33:00 GMT 2019
-	Barteks2x:
-		Fix client sometimes generating biomes, causing incorrect biome
-		generation on integrated server (#5720)
-
-	bs2609:
-		Add checks for tile entities in now-unloaded chunks (#5724)
-
-=========
-Build: 1.12.2-14.23.5.2843 - Thu Aug 29 02:23:04 GMT 2019
-	bs2609:
-		Fix invalid placeholder entity attributes (MC-150405) (#5718)
-
-=========
-Build: 1.12.2-14.23.5.2842 - Thu Aug 29 02:08:57 GMT 2019
-	bs2609:
-		Allow conditional loading of advancements (#5255)
-
-=========
-Build: 1.12.2-14.23.5.2841 - Thu Aug 29 01:58:50 GMT 2019
-	bs2609:
-		Improve performance of persistent chunk checks (#5706)
-
-	jensen.derik:
-		Fix lightning not triggering EntityJoinWorldEvent (#5290)
-
-=========
-Build: 1.12.2-14.23.5.2840 - Thu Aug 29 01:19:55 GMT 2019
-	lex:
-		Fix copy paste derp
-
-
-Build 2838:
-	bs2609: Fix vanilla handling of options file (MC-117449, MC-151173) (#5725)
-
-Build 2837:
-	clienthax: Update EnumHelper to be compatible with Eclipse's OpenJ9 JVM. (#5712)
-
-Build 2836:
-	tterrag:
-		Revert "Invalidate tile entities that are queued for removal (#5512)"
-		This reverts commit 75788f63eea6c33ccef7e5cbcab27ad9ad2c2a04.
-		This solution is invalid as TEs are free to modify the world
-		tileEntities list, usually indirectly via chunkloading, from inside
-		invalidate().
-		This happens in vanilla, in TileEntityChest#invalidate, where it calls 
-		checkForAdjacentChests(), which has the potential to load neighboring 
-		chunks and cause a CME.
-		A more sophisticated solution is needed.
-
-Build 2835:
-	bs2609: Fix some vertex format changes not being handled correctly (#5368)
-
-Build 2834:
-	bs2609:
-		Transform vertex normals as well as positions when generating quads
-		(#5242)
-
-Build 2833:
-	rseifert.phone: Fix for SidedInvWrapper isItemValid using wrong slot (#5642)
-
-Build 2832:
-	bs2609: Invalidate tile entities that are queued for removal (#5512)
-
-Build 2831:
-	lclc98: Added Wool to OreDictionary (#5414)
-
-Build 2830:
-	CreativeMD: Fixed boat not taking care of block-liquid hooks (#5086)
-
-Build 2829:
-	bs2609: Add Forge dimension-changing hooks to spectator handling code (#5212)
-
-Build 2828:
-	ichttt:
-		Minor performace improvement when building chunks and rendering blocks
-		(#5286)
-
-Build 2827:
-	bs2609: Catch json parsing errors from constants/factories files (#5258)
-
-Build 2826:
-	bs2609: Allow custom DataSerializers to be registered safely (#5245)
-
-Build 2825:
-	cpw:
-		Try and make 1.13 mods more obviously wrong in 1.12..
-		Signed-off-by: cpw <cpw+github@weeksfamily.ca>
-
-Build 2824:
-	tterrag: Fix #5651 Re-add canPlaceBlockOnSide check in World#mayPlace
-
-Build 2823:
-	Pokechu022:
-		Fail fast when null is used with setTag instead of crashing in
-		writeEntry (#5257)
-
-Build 2822:
-	tterrag: Fix block placement not checking for player collision
-
-Build 2821:
-	wynprice999: Added more Constants (#5323)
-
-Build 2820:
-	python0429: [1.12.2] Add a few events pertaining to villages (#5302)
-
-Build 2819:
-	Tyler Hancock: [1.12] Fix special spawn event not firing in many cases. (#5389)
-
-Build 2818:
-	bs2609: Only prompt for missing registries on local worlds (#5348)
-
-Build 2817:
-	ckrier.3000: Add EntityPlaceEvent (#5057)
-
-Build 2816:
-	bs2609: Generalise EnumRarity to an interface (#5182)
-
-Build 2815:
-	bs2609: Apply access-level changes to inner class attributes (#5468)
-
-Build 2814:
-	bs2609: Fix small logic error in ItemTextureQuadConverter (#5463)
-
-Build 2813:
-	bs2609: Better support for custom bows (#5209)
-
-Build 2812:
-	CovertJaguar: Remove FluidStack amount from hashcode calculation (#5272)
-	molecularphylo:
-		Fixed incorrect string representation of string list config property
-		default values in their comments.
-	bs2609:
-		Improve tracking of used dimension IDs (#5249)
-		Closes #5378 Large dimension IDs bloat level.data
-
-Build 2811:
-	bs2609:
-		Fix up torch placement logic to handle more vanilla special-casing
-		(#5426)
-
-Build 2810:
-	LexManos: Written size does not include int bytes.
-
-Build 2809:
-	LexManos:
-		Extend Region files to support >1MB per chunk. If the 'sector count' is
-		255, ask the compressed data header for the proper length.
-
-Build 2808:
-	tterrag1098: Add default impl to IConfigElement#getValidValuesDisplay
-
-Build 2807:
-	tterrag: Simplify custom item rendering by removing GL emissivity hacks
-
-Build 2806:
-	tterrag: Support diffuse lighting flag in item rendering
-
-Build 2805:
-	bs2609:
-		Add a hook to allow continuously using items through stack changes
-		(#4834)
-		* Add a hook to allow continuously using items through stack changes
-		
-		* Update licences
-
-Build 2804:
-	oOMitchOo:
-		Added an additional constructor to every implementation of IFluidBlock.
-		It is now possible to create a fluid block with a Fluid, Material and
-		MapColor, so that the Material's MapColor isn't used for the blocks
-		MapColor. (#5293)
-
-Build 2803:
-	bs2609: Add redirects to PotionEffect to respect registry replacement (#5213)
-
-Build 2802:
-	alexiy.ov:
-		Add an annotation for @Config elements which will automatically create a
-		slider control (#5026)
-
-Build 2801:
-	bs2609: Fix small logic error in emissive item rendering code (#5320)
-
-Build 2800:
-	molecularphylo:
-		Allow config GUI cycling button elements generated from enums to display
-		toString return values, rather than actual values. (#5125)
-
-Build 2799:
-	bs2609: Fix incorrect indexing in mipmap generation code (#5201)
-
-Build 2798:
-	bs2609:
-		Ensure slave maps are cleaned up when handling registry overrides
-		(#5250)
-
-Build 2797:
-	d_scalzi: Fix issue with --modListFile. (#5316)
-
-Build 2796:
-	LexManos:
-		Fix potential issues with the Minecraft FakePlayer lingering around
-		after world unloads.
-
-Build 2795:
-	tterrag: Fix potion remove event not always firing, add expiry event
-
-Build 2794:
-	tterrag: Clean up CraftingHelper constants loading API
-
-Build 2793:
-	tterrag: Fix crash from CraftingHelper due to FileSystem being closed early
-
-Build 2792:
-	tterrag:
-		added PotionHooks, closes #3867, #4375 (#4614)
-		* solved merge confilct
-		
-		* improved var names & removed tabs
-		
-		* Added spaces around !=
-		
-		* fixed typo
-
-Build 2791:
-	tterrag:
-		Add a hook for farmland watering (#4891)
-		* Add a FarmlandWaterCheckEvent to allow mods to override when Farmland
-		is watered or not
-		
-		* revert 1.12.2 json
-		
-		* Move the farmland patch to a ticket based instead of a event based
-		system
-		
-		* Minor changes
-		
-		* Faster isValid checks, faster validation/invalidation if the state did
-		not change, expand test mod to include a test for the validation system
-		
-		* remove isValid boolean flag, we can express it with the tick counter
-		
-		* Fix test mod resource warnings
-		
-		* Remove tick timeout, add a javadoc note to invalidate on chunk unload,
-		cleaned up test mod
-		
-		* Allow mods to provide custom handling to determine if a pos is valid
-		or not
-		
-		* Make SimpleTicket more simple, make register public so custom tickets
-		can be registered
-		
-		* Fixes for review
-		
-		* Add missing license headers
-		
-		* Use a weak hash set
-		
-		* Split up the map into smaller chunk based maps
-		
-		* Add missing license headers
-		
-		* Make MultiTicketManager more universal for custom implementations,
-		cleanup imports
-
-Build 2790:
-	tterrag:
-		Add methods to allow loading json constants outside of _constants
-		(#4975)
-		* add interface methods for loading json constants from an arbitary file
-		
-		
-		* use try-with-resources
-		
-		* don't make modders create jsoncontext, clean up resource use
-		
-		* very minor cleanup
-
-Build 2789:
-	tterrag:
-		Compute ASMDataTable submaps parallel, speeds up contructing mods
-		(#5246)
-		* Compute submaps parallel, speeds up contructing mods by a lot
-		
-		* Use stream API better
-
-Build 2788:
-	mezz: Add logging for data manager key registration errors (#5129)
-
-Build 2787:
-	mezz: Improve support for custom block path types (#5203)
-
-Build 2786:
-	mezz: Fix missing comments in configs created with annotations (#5189)
-
-Build 2785:
-	mezz: Allow items to control the rate of repair from mending (#5102)
-
-Build 2784:
-	mezz: Improve exception handling from server starting events (#5226)
-
-Build 2783:
-	mezz: Improve context provided by potion icon rendering hooks (#5111)
-
-Build 2782:
-	mezz: Fix an ObjectHolderRef internal error message (#5214)
-
-Build 2781:
-	mezz: Implement rendering for item models with emissive quads (#5047)
-
-Build 2780:
-	mezz: Clean up logged mod states (#5227)
-	mezz: Fix minor issue in getFilledPercentage for Fluid rendering (#5206)
-
-Build 2779:
-	mezz: Improve reflection helper methods (#4853)
-	mezz: Fix inaccurate main thread name shown in client log (#5078)
-
-Build 2778:
-	mezz: Fix Baked Item models with transformations (#5241)
-
-Build 2777:
-	mezz:
-		Re-add some missing villager profession patches (#5200)
-		* Fix zombie villagers only spawning with vanilla professions
-		* Fix spawning modded villagers that do not have their own building
-	mezz: Fix missing string parameters in some log messages (#5210)
-	mezz: Stop firing LivingSetAttackTargetEvent for setRevengeTarget (#5217)
-	mezz: Prevent RecipeBook from crashing on empty modded ingredients (#5234)
-
-Build 2776:
-	mezz: Fix the bed position given to the SleepingTimeCheck event (#5107)
-
-Build 2775:
-	LexManos: Fix some null returns from defaulted registries (#5235)
-
-Build 2774:
-	LexManos:
-		Only remove synthetic lambda methods referenced in body of SideOnly
-		methods (#5127)
-
-Build 2773:
-	LexManos:
-		A different approach to my changes in
-		https://github.com/MinecraftForge/MinecraftForge/commit/8ace535995522bec0557d4217e0d98b3dc76cf1e
-		to fix #5207
-	LexManos: Fix patches from #5160 setting rotation as well as position (#5233)
-	LexManos: Use HTTPS for files website.
-
-Build 2772:
-	tterrag: Make Forge-provided default transforms accessible to custom models
-	tterrag:
-		Make Forge blockstate variants correctly inherit AO setting from vanilla
-		models (#5190)
-		* Make Forge blockstate variants correctly inherit AO setting
-		
-		* Move variant format checks into variant, check for added properties
-		
-		* Small code cleanup
-	tterrag: fixed visual bug with guislider
-	tterrag:
-		Allow IModel to express itself as a vanilla parent (#5195)
-		* Fix errors caused by fancy missing model being non-vanilla parent
-		
-		* Switch instanceof checks to a default IModel method
-		
-		* Small code tweaks
-
-Build 2771:
-	tterrag: Add CreativeTabs#getLabelColor
-
-Build 2770:
-	tterrag:
-		Allow providing a BufferedImage for banner render generation (#5041)
-		* Adds an Event to allow providing a BufferedImage for the banner render
-		generation (cached)
-		textures, since banners don't use an atlas.
-		implementation.
-		
-		* Missed some copyright; might as well absolut text match, I guess
-		
-		* Remove unneeded patch change
-		
-		* Fix event variable access convention
-		
-		* Formatting fix
-		
-		* Improve event handling registration
-		
-		* Import cleanup
-		
-		* Replace event approach with Supplier approach
-		
-		* Better name for test mod (now that it's no longer an event); adds
-		ENABLE flag
-		
-		* Moves MC code into
-		net.minecraftforge.client.MinecraftForgeClient.getImageLayer to simplify
-		patch
-		
-		* Generalize naming
-
-Build 2769:
-	mezz: Fix Mesa biome entry tags in the BiomeDictionary (#5177)
-
-Build 2768:
-	LexManos: Bump version number for RB.
-
-Build 2767:
-	LexManos:
-		Change biome spawn list entries to use factory method where possible
-		(#5075)
-	LexManos: Prevent some texture loading errors from crashing the game (#5121)
-	LexManos: Patch PotionHelper to use registry delegates (#5142)
-	LexManos: Add a notification event for handling game rule changes (#5152)
-
-Build 2766:
-	LexManos:
-		Change universal bucket support to use fluid names instead of instances
-		(#5031)
-
-Build 2765:
-	LexManos: Fix NPE on clientside entities constructed with null world (#5170)
-
-Build 2764:
-	tterrag: Fix patches from #5160 running on the client and causing stutter
-
-Build 2763:
-	LexManos:
-		Class transformer optimizations (#5159)
-		* Filter packages for deobf transformation
-		* Only serialize transformed class with TerminalTransformer if bytecode
-		changed
-
-Build 2762:
-	github: Update github stale so issues can be Assigned
-
-Build 2761:
-	LexManos:
-		Fix MC-136995 - Chunk loading and unloading issue with entities placed
-		in exact positions. (#5160)
-		Scatter gun patches to improve entity tracking and position tracking. 
-		Provided by Aikar through the Paper project, this commit of patches
-		combines the following patches:
-		 
-		https://github.com/PaperMC/Paper/blob/fd1bd5223a461b6d98280bb8f2d67280a30dd24a/Spigot-Server-Patches/0306-Mark-chunk-dirty-anytime-entities-change-to-guarante.patch
-		 
-		https://github.com/PaperMC/Paper/blob/fd1bd5223a461b6d98280bb8f2d67280a30dd24a/Spigot-Server-Patches/0315-Always-process-chunk-registration-after-moving.patch
-		 
-		https://github.com/PaperMC/Paper/blob/fd1bd5223a461b6d98280bb8f2d67280a30dd24a/Spigot-Server-Patches/0335-Ensure-chunks-are-always-loaded-on-hard-position-set.patch
-		 
-		https://github.com/PaperMC/Paper/blob/fd1bd5223a461b6d98280bb8f2d67280a30dd24a/Spigot-Server-Patches/0378-Sync-Player-Position-to-Vehicles.patch
-
-Build 2760:
-	LexManos: Fix --mods and --modListFile arguments not making it past LaunchWrapper.
-
-Build 2759:
-	LexManos: Remove BlamingTransformer (#5115)
-
@@ -1,3 +1,4 @@
 # 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
@@ -1,6 +1,5 @@
-#Mon Sep 14 12:28:28 PDT 2015
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.14-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.3-bin.zip
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh

 ##############################################################################
 ##
@@ -6,47 +6,6 @@
 ##
 ##############################################################################

-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -61,9 +20,49 @@ while [ -h "$PRG" ] ; do
    fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
+cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
+cd "$SAVED" >/dev/null
+
+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=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac

 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar

@@ -90,7 +89,7 @@ location of your Java installation."
 fi

 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
    MAX_FD_LIMIT=`ulimit -H -n`
    if [ $? -eq 0 ] ; then
        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -114,6 +113,7 @@ fi
 if $cygwin ; 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
    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
@@ -154,11 +154,19 @@ if $cygwin ; then
    esac
 fi

-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")

-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# 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" "$@"
@@ -8,14 +8,14 @@
@rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal

-@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 DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%

+@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=
+
@rem Find java.exe
 if defined JAVA_MC_HOME goto findJavaFromJavaHome

@@ -46,10 +46,9 @@ echo location of your Java installation.
 goto fail

 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants

 if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args

 :win9xME_args
@rem Slurp the command line arguments.
@@ -60,11 +59,6 @@ set _SKIP=2
 if "x%~1" == "x" goto execute

 set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$

 :execute
@rem Setup the command line
@@ -1 +0,0 @@
-include ":ASMHelper"
@@ -1,53 +0,0 @@
-package com.backsun.lod;
-
-import com.backsun.lod.proxy.ClientProxy;
-import com.backsun.lod.proxy.CommonProxy;
-import com.backsun.lod.util.Reference;
-
-import net.minecraft.client.Minecraft;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.Mod.EventHandler;
-import net.minecraftforge.fml.common.Mod.Instance;
-import net.minecraftforge.fml.common.SidedProxy;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
-import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin;
-
-/**
- * 
- * @author James Seibel
- * @version 02-07-2021
- */
-@IFMLLoadingPlugin.MCVersion("1.12.2")
-@IFMLLoadingPlugin.TransformerExclusions({"com.backsun.lod.asm"})
-@Mod(modid = Reference.MOD_ID, name = Reference.NAME, version = Reference.VERSION, dependencies = "required-after:lodcore@[1.0,)")
-public class LodMain
-{
-	@Instance
-	public static LodMain instance;
-	
-	@SidedProxy(clientSide = Reference.CLIENT_PROXY_CLASS, serverSide = Reference.COMMON_PROXY_CLASS)
-	public static CommonProxy common_proxy;
-	public static ClientProxy client_proxy;
-	
-	@EventHandler
-	public static void PreInit(FMLPreInitializationEvent event)
-	{
-		Minecraft.getMinecraft().getFramebuffer().enableStencil();
-	}
-	
-	@EventHandler
-	public static void Init(FMLInitializationEvent event)
-	{
-		MinecraftForge.EVENT_BUS.register(common_proxy);
-		client_proxy = new ClientProxy();
-	}
-	
-	@EventHandler
-	public static void PostInit(FMLPostInitializationEvent event)
-	{
-		
-	}
-}
@@ -1,755 +0,0 @@
-package com.backsun.lod.objects;
-
-import java.awt.Color;
-
-import com.backsun.lod.util.enums.ColorDirection;
-import com.backsun.lod.util.enums.LodLocation;
-
-import net.minecraft.block.Block;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.color.BlockColors;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
-
-/**
- * This object contains position
- * and color data for an LOD object.
- * 
- * @author James Seibel
- * @version 02-13-2021
- */
-public class LodChunk
-{
-	/** how many different pieces of data are in one line */
-	private static final int DATA_DELIMITER_COUNT = 28;
-
-	/** This is what separates each piece of data in the toData method */
-	public static final char DATA_DELIMITER = ',';
-	
-	public static final int WIDTH = 16;
-	
-	private static final int CHUNK_DATA_WIDTH = WIDTH;
-	private static final int CHUNK_DATA_HEIGHT = WIDTH;
-	
-	private final int airBlockId = Block.getIdFromBlock(Block.getBlockFromName("air"));
-	private final int waterBlockId = Block.getIdFromBlock(Block.getBlockFromName("water"));
-	private final int waterColor = colorToInt(new Color(36, 50, 171));
-	
-	/**
-	 * This is how many blocks are
-	 * required at a specific y-value
-	 * to constitute a LOD point
-	 */
-	private final int LOD_BLOCK_REQ = 16;
-	// the max number of blocks per layer = 64 (8*8)
-	// since each layer is 1/4 the chunk
-	
-	
-	/** The x coordinate of the chunk. */
-	public int x;
-	/** The z coordinate of the chunk. */
-	public int z;
-	
-	// each short is the height of
-	// that 8th of the chunk.
-	public short top[];
-	public short bottom[];
-	
-	/** The average color of each 6 cardinal directions */
-	public Color colors[];
-	
-	
-	
-	
-	
-	
-	
-	
-	
-	//==============//
-	// constructors //
-	//==============//
-	
-	/**
-	 * Create an empty LodChunk
-	 */
-	public LodChunk()
-	{
-		x = 0;
-		z = 0;
-		
-		top = new short[4];
-		bottom = new short[4];
-		colors = new Color[6];
-		
-		// by default have the colors invisible
-		for(ColorDirection dir : ColorDirection.values())
-		{
-			colors[dir.value] = new Color(0, 0, 0, 0);
-		}
-	}
-	
-	/**
-	 * Creates an LodChunk from the string
-	 * generated by the toData method.
-	 * 
-	 * @throws IllegalArgumentException if the data isn't valid to create a LodChunk
-	 * @throws NumberFormatException if the data can't be converted into an int at any point
-	 */
-	public LodChunk(String data) throws IllegalArgumentException, NumberFormatException
-	{
-		/*
-		 * data format:
-		 * x, z, top data, bottom data, rgb color data
-		 * 
-		 * example:
-		 * 5,8, 4,4,4,4, 0,0,0,0, 255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255,
-		 */
-		
-		// make sure there are the correct number of entries
-		// in the data string (28)
-		int count = 0;
-		
-		for(int i = 0; i < data.length(); i++)
-		{
-			if(data.charAt(i) == DATA_DELIMITER)
-			{
-				count++;
-			}
-		}
-		
-		if(count != DATA_DELIMITER_COUNT)
-		{
-			throw new IllegalArgumentException("LodChunk constructor givin an invalid string. The data given had " + count + " delimiters when it should have had " + DATA_DELIMITER_COUNT + ".");
-		}
-		
-		
-		
-		// index we will use when going through the String
-		int index = 0;
-		int lastIndex = 0;
-		
-		
-		
-		// x and z position
-		index = data.indexOf(DATA_DELIMITER, 0);
-		x = Integer.parseInt(data.substring(0,index));
-		
-		lastIndex = index;
-		index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
-		z = Integer.parseInt(data.substring(lastIndex+1,index));
-		
-		
-		
-		// top
-		top = new short[4];
-		for(LodLocation loc : LodLocation.values())
-		{
-			lastIndex = index;
-			index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
-			
-			top[loc.value] = Short.parseShort(data.substring(lastIndex+1,index));
-		}
-		
-		
-		// bottom
-		bottom = new short[4];
-		for(LodLocation loc : LodLocation.values())
-		{
-			lastIndex = index;
-			index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
-			
-			bottom[loc.value] = Short.parseShort(data.substring(lastIndex+1,index));
-		}
-		
-		
-		// color
-		colors = new Color[6];
-		for(ColorDirection dir : ColorDirection.values())
-		{
-			int red = 0;
-			int green = 0;
-			int blue = 0;
-			
-			// get r,g,b
-			for(int i = 0; i < 3; i++)
-			{
-				lastIndex = index;
-				index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
-				
-				String raw = "";
-				switch(i)
-				{
-				case 0:
-					raw = data.substring(lastIndex+1,index);
-					red = Short.parseShort(raw);
-					break;
-				case 1:
-					raw = data.substring(lastIndex+1,index);
-					green = Short.parseShort(raw);
-					break;
-				case 2:
-					raw = data.substring(lastIndex+1,index);
-					blue = Short.parseShort(raw);
-					break;
-				}
-			}
-			
-			colors[dir.value] = new Color(red, green, blue);
-		}
-	}
-	
-	/**
-	 * Illegal argument is thrown if either the
-	 * chunk or world is null. The reason the world
-	 * can't be null is because it's required to determine
-	 * a block's color.
-	 * @throws IllegalArgumentException
-	 */
-	public LodChunk(Chunk chunk, World world) throws IllegalArgumentException
-	{
-		if(chunk == null)
-		{
-			throw new IllegalArgumentException("LodChunk constructor given a null chunk");
-		}
-		if(world == null)
-		{
-			throw new IllegalArgumentException("LodChunk constructor given a null world");
-		}
-		
-		
-		x = chunk.x;
-		z = chunk.z;
-		
-		top = new short[4];
-		bottom = new short[4];
-		colors = new Color[6];
-		
-		// generate the top and bottom points of this LOD
-		for(LodLocation loc : LodLocation.values())
-		{
-			top[loc.value] = generateLodSection(chunk, true, loc);
-			bottom[loc.value] = generateLodSection(chunk, false, loc);
-		}
-		
-		// determine the average color for each direction
-		for(ColorDirection dir : ColorDirection.values())
-		{
-			colors[dir.value] = generateLodColorSection(chunk, world, dir);
-		}
-	}
-	
-	
-	
-	
-	
-	
-	
-	//=====================//
-	// constructor helpers //
-	//=====================//
-	
-	
-	/**
-	 * If invalid/null/empty chunks are given 
-	 * crashes may occur.
-	 */
-	public short generateLodSection(Chunk chunk, boolean getTopSection, LodLocation lodLoc)
-	{
-		// should have a length of 16
-		// (each storage is 16x16x16 and the
-		// world height is 256)
-		ExtendedBlockStorage[] data = chunk.getBlockStorageArray();
-		
-		
-		
-		int startX = 0;
-		int endX = 0;
-		
-		int startZ = 0;
-		int endZ = 0;
-		
-		// determine where we should look in this
-		// chunk
-		switch(lodLoc)
-		{
-			case NE:
-				// -N
-				startZ = 0;
-				endZ = (CHUNK_DATA_WIDTH / 2) - 1;
-				// +E
-				startX = CHUNK_DATA_WIDTH / 2;
-				endX = CHUNK_DATA_WIDTH - 1;
-				break;
-				
-			case SE:
-				// +S
-				startZ = CHUNK_DATA_WIDTH / 2;
-				endZ = CHUNK_DATA_WIDTH;
-				// +E
-				startX = CHUNK_DATA_WIDTH / 2;
-				endX = CHUNK_DATA_WIDTH;
-				break;
-				
-			case SW:
-				// +S
-				startZ = CHUNK_DATA_WIDTH / 2;
-				endZ = CHUNK_DATA_WIDTH;
-				// -W
-				startX = 0;
-				endX = (CHUNK_DATA_WIDTH / 2) - 1;
-				break;
-				
-			case NW:
-				// -N
-				startZ = 0;
-				endZ = CHUNK_DATA_WIDTH / 2;
-				// -W
-				startX = 0;
-				endX = CHUNK_DATA_WIDTH / 2;
-				break;
-		}
-		
-		
-		if(getTopSection)
-			return determineTopPoint(data, startX, endX, startZ, endZ);
-		else
-			return determineBottomPoint(data, startX, endX, startZ, endZ);
-	}
-	
-	private short determineBottomPoint(ExtendedBlockStorage[] data, int startX, int endX, int startZ, int endZ)
-	{
-		// search from the bottom up
-		for(int i = 0; i < data.length; i++)
-		{
-			for(int y = 0; y < CHUNK_DATA_HEIGHT; y++)
-			{
-				
-				if(isLayerValidLodPoint(data, startX, endX, startZ, endZ, i, y))
-				{
-					// we found
-					// enough blocks in this
-					// layer to count as an
-					// LOD point
-					return (short) (y + (i * CHUNK_DATA_HEIGHT));
-				}
-				
-			} // y
-		} // data
-		
-		
-		// we never found a valid LOD point
-		return -1;
-	}
-	
-	private short determineTopPoint(ExtendedBlockStorage[] data, int startX, int endX, int startZ, int endZ)
-	{
-		// search from the top down
-		for(int i = data.length - 1; i >= 0; i--)
-		{
-			for(int y = CHUNK_DATA_WIDTH - 1; y >= 0; y--)
-			{
-				if(isLayerValidLodPoint(data, startX, endX, startZ, endZ, i, y))
-				{
-					// we found
-					// enough blocks in this
-					// layer to count as an
-					// LOD point
-					return (short) (y + (i * CHUNK_DATA_HEIGHT));
-				}
-			} // y
-		} // data
-		
-		
-		
-		// we never found a valid LOD point
-		return -1;
-	}
-	
-	/**
-	 * Is the layer between the given X, Z, and dataIndex
-	 * values a valid LOD point?
-	 */
-	private boolean isLayerValidLodPoint(
-			ExtendedBlockStorage[] data, 
-			int startX, int endX, 
-			int startZ, int endZ, 
-			int dataIndex, int y)
-	{
-		// search through this layer
-		int layerBlocks = 0;
-		
-		for(int x = startX; x < endX; x++)
-		{
-			for(int z = startZ; z < endZ; z++)
-			{
-				if(data[dataIndex] == null)
-				{
-					// this section doesn't have any blocks,
-					// it is not a valid section
-					return false;
-				}
-				else
-				{
-					if(data[dataIndex].get(x, y, z) != null && Block.getIdFromBlock(data[dataIndex].get(x, y, z).getBlock()) != airBlockId)
-					{
-						// we found a valid block in
-						// in this layer
-						layerBlocks++;
-						
-						if(layerBlocks >= LOD_BLOCK_REQ)
-						{
-							return true;
-						}
-					}
-				}
-				
-			} // z
-		} // x
-		
-		return false;
-	}
-	
-	
-	
-	private Color generateLodColorSection(Chunk chunk, World world, ColorDirection colorDir)
-	{
-		Minecraft mc =  Minecraft.getMinecraft();
-		BlockColors bc = mc.getBlockColors();
-		
-		switch (colorDir)
-		{
-			case TOP:
-				return generateLodColorVertical(chunk, colorDir, world, bc);
-			case BOTTOM:
-				return generateLodColorVertical(chunk, colorDir, world, bc);
-				
-			case N:
-				return generateLodColorHorizontal(chunk, colorDir, world, bc);
-			case S:
-				return generateLodColorHorizontal(chunk, colorDir, world, bc);
-				
-			case E:
-				return generateLodColorHorizontal(chunk, colorDir, world, bc);
-			case W:
-				return generateLodColorHorizontal(chunk, colorDir, world, bc);
-		}
-		
-		return new Color(0, 0, 0, 0);
-	}
-	
-	/**
-	 * Only accepts TOP and BOTTOM as ColorPositions
-	 */
-	private Color generateLodColorVertical(Chunk chunk, ColorDirection colorDir, World world, BlockColors bc)
-	{
-		ExtendedBlockStorage[] data = chunk.getBlockStorageArray();
-		
-		int numbOfBlocks = 0;
-		int red = 0;
-		int green = 0;
-		int blue = 0;
-		
-		boolean goTopDown = (colorDir == ColorDirection.TOP);
-		
-		
-		// either go top down or bottom up
-		int dataStart = goTopDown? data.length - 1 : 0;
-		int dataMax = data.length; 
-		int dataMin = 0;
-		int dataIncrement = goTopDown? -1 : 1;
-		
-		int topStart = goTopDown? CHUNK_DATA_HEIGHT - 1 : 0;
-		int topMax = CHUNK_DATA_HEIGHT;
-		int topMin = 0;
-		int topIncrement =  goTopDown? -1 : 1;
-		
-		for(int x = 0; x < CHUNK_DATA_WIDTH; x++)
-		{
-			for(int z = 0; z < CHUNK_DATA_WIDTH; z++)
-			{
-				boolean foundBlock = false;
-				
-				for(int di = dataStart; !foundBlock && di >= dataMin && di < dataMax; di += dataIncrement)
-				{
-					if(!foundBlock && data[di] != null)
-					{
-						for(int y = topStart; !foundBlock && y >= topMin && y < topMax; y += topIncrement)
-						{
-							int ci;
-							if(Block.getIdFromBlock(data[di].get(x, y, z).getBlock()) == waterBlockId)
-								// this is a special case since getColor on water generally returns white
-								ci = waterColor;
-							else
-								ci = bc.getColor(data[di].get(x, y, z), world, new BlockPos(x,y,z));
-							
-							if(ci == 0)
-							{
-								// skip air or invisible blocks
-								continue;
-							}
-							
-							Color c = intToColor(ci);
-							
-							red += c.getRed();
-							green += c.getGreen();
-							blue += c.getBlue();
-							
-							numbOfBlocks++;
-							
-							
-							// we found a valid block, skip to the
-							// next x and z
-							foundBlock = true;
-						}
-					}
-				}
-				
-			}
-		}
-		
-		if(numbOfBlocks == 0)
-			numbOfBlocks = 1;
-		
-		red /= numbOfBlocks;
-		green /= numbOfBlocks;
-		blue /= numbOfBlocks;
-		
-		return new Color(red, green, blue);
-	}
-
-	private Color generateLodColorHorizontal(Chunk chunk, ColorDirection colorDir, World world, BlockColors bc)
-	{
-		ExtendedBlockStorage[] data = chunk.getBlockStorageArray();
-		
-		int numbOfBlocks = 0;
-		int red = 0;
-		int green = 0;
-		int blue = 0;
-		
-		
-		// these don't change since the over direction doesn't matter
-		int overStart = 0;
-		int overIncrement = 1;
-		
-		// determine which direction is "in"
-		int inStart = 0;
-		int inIncrement = 1;
-		switch (colorDir)
-		{
-		case N:
-			inStart = 0;
-			inIncrement = 1;
-			break;
-		case S:
-			inStart = CHUNK_DATA_WIDTH - 1;
-			inIncrement = -1;
-			break;
-		case E:
-			inStart = 0;
-			inIncrement = 1;
-			break;
-		case W:
-			inStart = CHUNK_DATA_WIDTH - 1;
-			inIncrement = -1;
-			break;
-		default:
-			// we were given an invalid position, return invisible.
-			// this shouldn't happen and is mostly here to make the
-			// compiler happy
-			return new Color(0,0,0,0);
-		}
-		
-		
-		for (int di = 0; di < data.length; di++)
-		{
-			if (data[di] != null)
-			{
-				for (int y = 0; y < CHUNK_DATA_HEIGHT; y++)
-				{
-					boolean foundBlock = false;
-					
-					// over moves "over" the side of the chunk
-					// in moves "into" the chunk until it finds a block
-					
-					for (int over = overStart; !foundBlock && over >= 0 && over < CHUNK_DATA_WIDTH; over += overIncrement)
-					{
-						for (int in = inStart; !foundBlock && in >= 0 && in < CHUNK_DATA_WIDTH; in += inIncrement)
-						{
-							int x = -1;
-							int z = -1;
-							
-							// determine which should be X and Z							
-							switch(colorDir)
-							{
-							case N:
-								x = over;
-								z = in;
-								break;
-							case S:
-								x = over;
-								z = in;
-								break;
-							case E:
-								x = in;
-								z = over;
-								break;
-							case W:
-								x = in;
-								z = over;
-								break;
-							default:
-								// this will never happen, it would have
-								// been caught by the switch before the loops
-								break;
-							}
-							
-							int ci;
-							if(Block.getIdFromBlock(data[di].get(x, y, z).getBlock()) == waterBlockId)
-								// this is a special case since getColor on water generally returns white
-								ci = waterColor;
-							else
-								ci = bc.getColor(data[di].get(x, y, z), world, new BlockPos(x,y,z));
-							
-							if (ci == 0) {
-								// skip air or invisible blocks
-								continue;
-							}
-							
-							Color c = intToColor(ci);
-							
-							red += c.getRed();
-							green += c.getGreen();
-							blue += c.getBlue();
-							
-							numbOfBlocks++;
-							
-							// we found a valid block, skip to the
-							// next x and z
-							foundBlock = true;
-						}
-					}
-				}
-				
-			}
-		}
-		
-		if(numbOfBlocks == 0)
-			numbOfBlocks = 1;
-		
-		red /= numbOfBlocks;
-		green /= numbOfBlocks;
-		blue /= numbOfBlocks;
-		
-		return new Color(red, green, blue);
-	}
-	
-	/**
-	 * Convert a BlockColors int into a Color object.
-	 */
-	private Color intToColor(int num)
-	{
-		int filter = 0b11111111;
-		
-		int red = (num >> 16 ) & filter;
-		int green = (num >> 8 ) & filter;
-		int blue = num & filter;
-		
-		return new Color(red, green, blue);
-	}
-	
-	/**
-	 * Convert a Color into a BlockColors object.
-	 */
-	private int colorToInt(Color color)
-	{
-		return color.getRGB();
-	}
-	
-	
-	
-	
-	
-	
-	
-	
-	
-	//========//
-	// output //
-	//========//
-	
-	
-	
-	/**
-	 * Outputs all data in csv format
-	 * with the given delimiter.
-	 * <br>
-	 * Exports data in the form:
-	 * <br>
-	 * x, z, top data, bottom data, rgb color data
-	 * 
-	 * <br>
-	 * example output:
-	 * <br>
-	 * 5,8, 4,4,4,4, 0,0,0,0 255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255,
-	 */
-	public String toData()
-	{
-		String s = "";
-		
-		s += Integer.toString(x) + DATA_DELIMITER +  Integer.toString(z) + DATA_DELIMITER;
-		
-		for(int i = 0; i < top.length; i++)
-		{
-			s += Short.toString(top[i]) + DATA_DELIMITER;
-		}
-		
-		for(int i = 0; i < bottom.length; i++)
-		{
-			s += Short.toString(bottom[i]) + DATA_DELIMITER;
-		}
-		
-		for(int i = 0; i < colors.length; i++)
-		{
-			s += Integer.toString(colors[i].getRed()) + DATA_DELIMITER + Integer.toString(colors[i].getGreen()) + DATA_DELIMITER + Integer.toString(colors[i].getBlue()) + DATA_DELIMITER;
-		}
-		
-		return s;
-	}
-	
-	
-	@Override
-	public String toString()
-	{
-		String s = "";
-		
-		s += "x: " + x + " z: " + z + "\t";
-		
-//		s += "top: ";
-//		for(int i = 0; i < top.length; i++)
-//		{
-//			s += top[i] + " ";
-//		}
-//		s += "\t";
-		
-//		s += "bottom: ";
-//		for(int i = 0; i < bottom.length; i++)
-//		{
-//			s += bottom[i] + " ";
-//		}
-//		s += "\t";
-		
-//		s += "colors ";
-//		for(int i = 0; i < colors.length; i++)
-//		{
-//			if(colors[i] != null)
-//				s += "(" + colors[i].getRed() + ", " + colors[i].getGreen() + ", " + colors[i].getBlue() + "), ";
-//		}
-		
-		s += "(" + colors[ColorDirection.TOP.value].getRed() + ", " + colors[ColorDirection.TOP.value].getGreen() + ", " + colors[ColorDirection.TOP.value].getBlue() + "), ";
-		
-		return s;
-	}
-}
@@ -1,319 +0,0 @@
-package com.backsun.lod.objects;
-
-import com.backsun.lod.util.LodFileHandler;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.world.DimensionType;
-
-/**
- * This object holds all loaded LOD regions
- * for a given dimension.
- * 
- * @author James Seibel
- * @version 01-31-2021
- */
-public class LodDimension
-{
-	public final DimensionType dimension;
-	
-	private volatile int width; // if this ever changes make sure to update the halfWidth too
-	private volatile int halfWidth;
-	
-	public LodRegion regions[][];
-	public boolean isRegionDirty[][];
-	
-	private int centerX;
-	private int centerZ;
-	
-	private LodFileHandler rfHandler;
-	
-	public LodDimension(DimensionType newDimension, int newMaxWidth)
-	{
-		dimension = newDimension;
-		width = newMaxWidth;
-		
-		// dimension 0 works here since we are just looking for the save handler anyway
-		rfHandler = new LodFileHandler(Minecraft.getMinecraft().getIntegratedServer().getWorld(0).getSaveHandler(), this);
-		
-		regions = new LodRegion[width][width];
-		isRegionDirty = new boolean[width][width];
-		
-		// populate isRegionDirty
-		for(int i = 0; i < width; i++)
-			for(int j = 0; j < width; j++)
-				isRegionDirty[i][j] = false;
-		
-		centerX = 0;
-		centerZ = 0;
-		
-		halfWidth = (int)Math.floor(width / 2);
-	}
-	
-	
-	
-	public void move(int xOffset, int zOffset)
-	{		
-		// if the x or z offset is equal to or greater than
-		// the total size, just delete the current data
-		// and update the centerX and/or centerZ
-		if (Math.abs(xOffset) >= width || Math.abs(zOffset) >= width)
-		{
-			for(int x = 0; x < width; x++)
-			{
-				for(int z = 0; z < width; z++)
-				{
-					regions[x][z] = null;
-				}
-			}
-			
-			// update the new center
-			centerX += xOffset;
-			centerZ += zOffset;
-			
-			return;
-		}
-		
-		
-		// X
-		if(xOffset > 0)
-		{
-			// move everything over to the left (as the center moves to the right)
-			for(int x = 0; x < width; x++)
-			{
-				for(int z = 0; z < width; z++)
-				{
-					if(x + xOffset < width)
-						regions[x][z] = regions[x + xOffset][z];
-					else
-						regions[x][z] = null;
-				}
-			}
-		}
-		else
-		{
-			// move everything over to the right (as the center moves to the left)
-			for(int x = width - 1; x >= 0; x--)
-			{
-				for(int z = 0; z < width; z++)
-				{
-					if(x + xOffset >= 0)
-						regions[x][z] = regions[x + xOffset][z];
-					else
-						regions[x][z] = null;
-				}
-			}
-		}
-		
-		
-		
-		// Z
-		if(zOffset > 0)
-		{
-			// move everything up (as the center moves down)
-			for(int x = 0; x < width; x++)
-			{
-				for(int z = 0; z < width; z++)
-				{
-					if(z + zOffset < width)
-						regions[x][z] = regions[x][z + zOffset];
-					else
-						regions[x][z] = null;
-				}
-			}
-		}
-		else
-		{
-			// move everything down (as the center moves up)
-			for(int x = 0; x < width; x++)
-			{
-				for(int z = width - 1; z >= 0; z--)
-				{
-					if(z + zOffset >= 0)
-						regions[x][z] = regions[x][z + zOffset];
-					else
-						regions[x][z] = null;
-				}
-			}
-		}
-		
-		
-		
-		// update the new center
-		centerX += xOffset;
-		centerZ += zOffset;
-	}
-	
-	
-	public int getCenterX()
-	{
-		return centerX;
-	}
-	
-	public int getCenterZ()
-	{
-		return centerZ;
-	}
-	
-	
-	
-	
-	
-	
-	
-	public LodRegion getRegion(int regionX, int regionZ)
-	{
-		int xIndex = (regionX - centerX) + halfWidth;
-		int zIndex = (regionZ - centerZ) + halfWidth;
-		
-		if (!regionIsInRange(regionX, regionZ))
-			// out of range
-			return null;
-		
-		if (regions[xIndex][zIndex] == null)
-		{
-			regions[xIndex][zIndex] = getRegionFromFile(regionX, regionZ);
-			if (regions[xIndex][zIndex] == null)
-			{
-				regions[xIndex][zIndex] = new LodRegion(regionX, regionZ);
-			}
-		}
-		
-		return regions[xIndex][zIndex];
-	}
-	
-	/**
-	 * Overwrite the LodRegion at the location of newRegion with newRegion.
-	 * @throws ArrayIndexOutOfBoundsException if newRegion is outside what can be stored in this LodDimension.
-	 */
-	public void setRegion(LodRegion newRegion) throws ArrayIndexOutOfBoundsException
-	{
-		int xIndex = (newRegion.x - centerX) + halfWidth;
-		int zIndex = (centerZ - newRegion.z) + halfWidth;
-		
-		if (!regionIsInRange(newRegion.x, newRegion.z))
-			// out of range
-			throw new ArrayIndexOutOfBoundsException();
-		
-		regions[xIndex][zIndex] = newRegion;
-	}
-	
-	
-	
-	
-	
-	
-	public void addLod(LodChunk lod)
-	{
-		int regionX = (lod.x + centerX) / LodRegion.SIZE;
-		int regionZ = (lod.z + centerZ) / LodRegion.SIZE;
-		
-		// prevent issues if X/Z is negative and less than 16
-		if (lod.x < 0)
-		{
-			regionX = (Math.abs(regionX) * -1) - 1; 
-		}
-		if (lod.z < 0)
-		{
-			regionZ = (Math.abs(regionZ) * -1) - 1; 
-		}
-		
-		// don't continue if the region can't be saved
-		if (!regionIsInRange(regionX, regionZ))
-			return;
-		
-		LodRegion region = getRegion(regionX, regionZ);
-		
-		if (region == null)
-		{
-			// if no region exists, create it
-			region = new LodRegion(regionX, regionZ);
-			setRegion(region);
-		}
-		
-		region.addLod(lod);
-		
-		// mark the region as dirty so it will be saved to disk
-		int xIndex = (regionX - centerX) + halfWidth;
-		int zIndex = (regionZ - centerZ) + halfWidth;
-		isRegionDirty[xIndex][zIndex] = true;
-		
-		
-		
-		rfHandler.saveDirtyRegionsToFile();
-	}
-	
-	/**
-	 * Returns null if the LodChunk isn't loaded
-	 */
-	public LodChunk getLodFromCoordinates(int chunkX, int chunkZ)
-	{
-		// (chunkX + centerX) % width
-		int regionX = (chunkX + centerX) / LodRegion.SIZE;
-		int regionZ = (chunkZ + centerZ) / LodRegion.SIZE;
-		
-		// prevent issues if chunkX/Z is negative and less than width
-		if (chunkX < 0)
-		{
-			regionX = (Math.abs(regionX) * -1) - 1; 
-		}
-		if (chunkZ < 0)
-		{
-			regionZ = (Math.abs(regionZ) * -1) - 1; 
-		}
-		
-		LodRegion region = getRegion(regionX, regionZ);
-		
-		// TODO fix small render distances sometimes not having all regions loaded
-		if(region == null)
-			return null;
-		
-		return region.getLod(chunkX, chunkZ);
-	}
-	
-	
-	
-	
-	public LodRegion getRegionFromFile(int regionX, int regionZ)
-	{
-		return rfHandler.loadRegionFromFile(regionX, regionZ);
-	}
-	
-	
-	/**
-	 * Returns whether the region at the given X and Z coordinates
-	 * is within the loaded range.
-	 */
-	private boolean regionIsInRange(int regionX, int regionZ)
-	{
-		int xIndex = (regionX - centerX) + halfWidth;
-		int zIndex = (regionZ - centerZ) + halfWidth;
-		
-		return xIndex >= 0 && xIndex < width && zIndex >= 0 && zIndex < width;
-	}
-
-	
-	
-	public int getWidth()
-	{
-		return width;
-	}
-	
-	public void setRegionWidth(int newWidth)
-	{
-		width = newWidth;
-		halfWidth = (int)Math.floor(width / 2);
-		
-		regions = new LodRegion[width][width];
-		isRegionDirty = new boolean[width][width];
-		
-		// populate isRegionDirty
-		for(int i = 0; i < width; i++)
-			for(int j = 0; j < width; j++)
-				isRegionDirty[i][j] = false;
-	}
-}
-
-
-
-
-
@@ -1,76 +0,0 @@
-package com.backsun.lod.objects;
-
-/**
- * A LodRegion is the a 32x32
- * 2D array of LodChunk objects.
- * Each LodRegion corresponds to
- * one file in the file system.
- * 
- * @author James Seibel
- * @version 1-20-2021
- */
-public class LodRegion
-{
-	/** number of chunks wide */
-	public static final int SIZE = 32;
-	
-	/**	X coordinate of this region */
-	public final int x;
-	/** Z coordinate of this region */
-	public final int z;
-	
-	private LodChunk chunks[][];
-	
-	
-	public LodRegion(int regionX, int regionZ)
-	{
-		x = regionX;
-		z = regionZ;
-		
-		chunks = new LodChunk[SIZE][SIZE];
-	}
-	
-	
-	public void addLod(LodChunk lod)
-	{
-		// we use ABS since LODs can be negative, but if they are
-		// the region will negative first, therefore we don't have to
-		// store the LOD chunks at negative indexes since we search 
-		// LOD the region first
-		int xIndex = Math.abs(lod.x % SIZE);
-		int zIndex = Math.abs(lod.z % SIZE);
-		
-		chunks[xIndex][zIndex] = lod;
-	}
-	
-	public LodChunk getLod(int chunkX, int chunkZ)
-	{
-		// since we add LOD's with ABS, we get them the same way
-		int arrayX = Math.abs(chunkX % SIZE);
-		int arrayZ = Math.abs(chunkZ % SIZE);
-		
-		if(arrayX >= SIZE || arrayZ >= SIZE)
-			return null;
-		
-		return chunks[arrayX][arrayZ];
-	}
-	
-	
-	
-	public LodChunk[][] getAllLods()
-	{
-		return chunks;
-	}
-	
-	
-	
-	@Override
-	public String toString()
-	{
-		String s = "";
-		
-		s += "x: " + x + " z: " + z + "\t";
-		
-		return s;
-	}
-}
@@ -1,49 +0,0 @@
-package com.backsun.lod.objects;
-
-import java.util.Dictionary;
-import java.util.Enumeration;
-import java.util.Hashtable;
-
-/**
- * This stores all LODs for a given world.
- * 
- * @author James Seibel
- * @version 01-31-2021
- */
-public class LodWorld
-{
-	public String worldName;
-	
-	/**
-	 * Key = Dimension id (as an int)
-	 */
-	private Dictionary<Integer, LodDimension> lodDimensions;
-	
-	
-	public LodWorld(String newWorldName)
-	{
-		worldName = newWorldName;
-		lodDimensions = new Hashtable<Integer, LodDimension>();
-	}
-	
-	
-	
-	public void addLodDimension(LodDimension newStorage)
-	{
-		lodDimensions.put(newStorage.dimension.getId(), newStorage);
-	}
-	
-	public LodDimension getLodDimension(int dimensionId)
-	{
-		return lodDimensions.get(dimensionId);
-	}
-	
-	
-	public void resizeDimensionRegionWidth(int newWidth)
-	{
-		Enumeration<Integer> keys = lodDimensions.keys();
-		
-		while(keys.hasMoreElements())
-			lodDimensions.get(keys.nextElement()).setRegionWidth(newWidth);
-	}
-}
@@ -1,256 +0,0 @@
-package com.backsun.lod.proxy;
-
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import org.lwjgl.opengl.GL11;
-
-import com.backsun.lod.objects.LodChunk;
-import com.backsun.lod.objects.LodDimension;
-import com.backsun.lod.objects.LodRegion;
-import com.backsun.lod.objects.LodWorld;
-import com.backsun.lod.renderer.LodRenderer;
-import com.backsun.lod.util.LodConfig;
-import com.backsun.lod.util.LodFileHandler;
-import com.backsun.lodCore.util.RenderGlobalHook;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.WorldClient;
-import net.minecraft.world.DimensionType;
-import net.minecraft.world.World;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
-import net.minecraftforge.client.event.RenderWorldLastEvent;
-import net.minecraftforge.event.terraingen.PopulateChunkEvent;
-import net.minecraftforge.event.world.ChunkEvent;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-
-//TODO Find a way to replace getIntegratedServer so this mod could be used on non-local worlds.
-// Minecraft.getMinecraft().getIntegratedServer()
-
-/**
- * This is used by the client.
- * 
- * @author James_Seibel
- * @version 01-31-2021
- */
-public class ClientProxy extends CommonProxy
-{
-	private LodRenderer renderer;
-	private LodWorld lodWorld;
-	private ExecutorService lodGenThreadPool = Executors.newFixedThreadPool(1);
-	
-	/** Default size of any LOD regions we use */
-	private int regionWidth = 5;
-	
-	public ClientProxy()
-	{
-		
-	}
-	
-	
-	
-	
-	//==============//
-	// render event //
-	//==============//
-	
-	@SubscribeEvent
-	public void renderWorldLast(RenderWorldLastEvent event)
-	{
-		RenderGlobalHook.endRenderingStencil();
-		GL11.glStencilFunc(GL11.GL_EQUAL, 0, 0xFF);
-		
-		if (LodConfig.drawLODs)
-			renderLods(event.getPartialTicks());
-		
-		GL11.glDisable(GL11.GL_STENCIL_TEST);
-	}
-	
-	public void renderLods(float partialTicks)
-	{
-		int newWidth = Math.max(4, (Minecraft.getMinecraft().gameSettings.renderDistanceChunks * LodChunk.WIDTH * 2) / LodRegion.SIZE);
-		if (lodWorld != null && regionWidth != newWidth)
-		{
-			lodWorld.resizeDimensionRegionWidth(newWidth);
-			regionWidth = newWidth;
-			
-			// skip this frame, hopefully the lodWorld
-			// should have everything set up by then
-			return;
-		}
-		
-		Minecraft mc = Minecraft.getMinecraft();
-		if (mc == null || mc.player == null || lodWorld == null)
-			return;
-		
-		int dimId = mc.player.dimension;
-		LodDimension lodDim = lodWorld.getLodDimension(dimId);
-		if (lodDim == null)
-			return;
-		
-		
-		double playerX = mc.player.posX;
-		double playerZ = mc.player.posZ;
-		
-		int xOffset = ((int)playerX / (LodChunk.WIDTH * LodRegion.SIZE)) - lodDim.getCenterX();
-		int zOffset = ((int)playerZ / (LodChunk.WIDTH * LodRegion.SIZE)) - lodDim.getCenterZ();
-		
-		if (xOffset != 0 || zOffset != 0)
-		{
-			lodDim.move(xOffset, zOffset);
-		}
-		
-		
-		// we wait to create the renderer until the first frame
-		// to make sure that the EntityRenderer has
-		// been created, that way we can get the fovModifer
-		// method from it through reflection.
-		if (renderer == null)
-		{
-			renderer = new LodRenderer();
-		}
-		else
-		{
-			renderer.drawLODs(lodDim, partialTicks);
-		}
-	}	
-	
-	
-	
-	
-	
-	
-	
-	
-	//===============//
-	// update events //
-	//===============//
-	
-	@SubscribeEvent
-	public void chunkLoadEvent(ChunkEvent event)
-	{
-		generateLodChunk(event.getChunk());
-	}
-	
-	/**
-	 * this event is called whenever a chunk is created for the first time.
-	 */
-	@SubscribeEvent
-	public void onChunkPopulate(PopulateChunkEvent event)
-	{
-		Minecraft mc = Minecraft.getMinecraft();
-		if (mc != null && event != null)
-		{
-			WorldClient world = mc.world;
-			
-			if(world != null)
-			{
-				generateLodChunk(world.getChunkFromChunkCoords(event.getChunkX(), event.getChunkZ()));
-			}
-		}
-	}
-	
-	/*
-	 * 
-	Use this for generating chunks and maybe determining if they are loaded at all?
-	
-	Could I create my own chunk generator and multithread it? It wouldn't save to the world, but could I save it for LODs?
-	
- 	chunk = Minecraft.getMinecraft().getIntegratedServer().getWorld(0).getChunkProvider().chunkGenerator.generateChunk(chunk.x, chunk.z);
-	
-	System.out.println(chunk.x + " " + chunk.z + "\tloaded: " + chunk.isLoaded() + "\tpop: " + chunk.isPopulated() + "\tter pop: " + chunk.isTerrainPopulated());
-	 */
-	
-	private void generateLodChunk(Chunk chunk)
-	{
-		Minecraft mc = Minecraft.getMinecraft();
-		
-		// don't try to create an LOD object
-		// if for some reason we aren't
-		// given a valid chunk object
-		// (Minecraft often gives back empty
-		// or null chunks in this method)
-		if (chunk == null || !isValidChunk(chunk))
-			return;
-		
-		int dimId = chunk.getWorld().provider.getDimension();
-		World world = mc.getIntegratedServer().getWorld(dimId);
-		
-		if (world == null)
-			return;
-			
-		Thread thread = new Thread(() ->
-		{
-			try
-			{
-				LodChunk lod = new LodChunk(chunk, world);
-				LodDimension lodDim;
-				
-				if (lodWorld == null)
-				{
-					lodWorld = new LodWorld(LodFileHandler.getWorldName());
-				}
-				else
-				{
-					// if we have a lodWorld make sure 
-					// it is for this minecraft world
-					if (!lodWorld.worldName.equals(LodFileHandler.getWorldName()))
-					{
-						// this lodWorld isn't for this minecraft world
-						// delete it so we can get a new one
-						lodWorld = null;
-						
-						// skip this frame
-						// we'll get this set up next time
-						return;
-					}
-				}
-				
-				
-				if (lodWorld.getLodDimension(dimId) == null)
-				{
-					DimensionType dim = DimensionType.getById(dimId);
-					lodDim = new LodDimension(dim, regionWidth);
-					lodWorld.addLodDimension(lodDim);
-				}
-				else
-				{
-					lodDim = lodWorld.getLodDimension(dimId);
-				}
-				
-				lodDim.addLod(lod);
-			}
-			catch(IllegalArgumentException | NullPointerException e)
-			{
-				// if the world changes while LODs are being generated
-				// they will throw errors as they try to access things that no longer
-				// exist.
-			}
-			
-		});
-		
-		lodGenThreadPool.execute(thread);
-	}
-	
-	/**
-	 * Return whether the given chunk
-	 * has any data in it.
-	 */
-	private boolean isValidChunk(Chunk chunk)
-	{
-		ExtendedBlockStorage[] data = chunk.getBlockStorageArray();
-		
-		for(ExtendedBlockStorage e : data)
-		{
-			if(e != null && !e.isEmpty())
-			{
-				return true;
-			}
-		}
-		
-		return false;
-	}
-	
-	
-}
@@ -1,12 +0,0 @@
-package com.backsun.lod.proxy;
-
-/**
- * This is used by the server.
- * 
- * @author James_Seibel
- * @version 08-31-2020
- */
-public class CommonProxy
-{
-	
-}
@@ -1,333 +0,0 @@
-package com.backsun.lod.renderer;
-import java.awt.Color;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.util.concurrent.Callable;
-
-import com.backsun.lod.util.enums.FogDistance;
-
-import net.minecraft.client.renderer.GLAllocation;
-import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
-import net.minecraft.client.renderer.vertex.VertexFormat;
-import net.minecraft.client.renderer.vertex.VertexFormatElement;
-import net.minecraft.util.math.AxisAlignedBB;
-import net.minecraft.util.math.MathHelper;
-
-/**
- * 
- * 
- * @author James Seibel
- * @version 02-13-2021
- */
-public class BuildBufferThread implements Callable<NearFarBuffer>
-{
-	public ByteBuffer nearBuffer;
-	public ByteBuffer farBuffer;
-	public FogDistance distanceMode;
-	public AxisAlignedBB[][] lods;
-	public Color[][] colors;
-	
-	private int start = 0;
-	private int end = -1;
-	
-	private int vertexCount = 0;
-	private VertexFormat vertexFormat = null;
-	private int vertexFormatIndex = 0;
-	private VertexFormatElement vertexFormatElement = null; 
-	
-	
-	
-	BuildBufferThread()
-	{
-		vertexCount = 0;
-		vertexFormat = DefaultVertexFormats.POSITION_COLOR;
-		vertexFormatIndex = 0;
-		vertexFormatElement = vertexFormat.getElement(vertexFormatIndex); 
-	}
-	
-	BuildBufferThread(ByteBuffer newNearByteBuffer, ByteBuffer newFarByteBuffer, AxisAlignedBB[][] newLods, Color[][] newColors, FogDistance newDistanceMode, int threadNumber, int totalThreads)
-	{
-		setNewData(newNearByteBuffer, newFarByteBuffer, distanceMode, newLods, newColors, threadNumber, totalThreads);
-		
-		vertexCount = 0;
-		vertexFormat = DefaultVertexFormats.POSITION_COLOR;
-		vertexFormatIndex = 0;
-		vertexFormatElement = vertexFormat.getElement(vertexFormatIndex); 
-	}
-	
-	public void setNewData(ByteBuffer newNearByteBuffer, ByteBuffer newFarByteBuffer, FogDistance newDistanceMode, AxisAlignedBB[][] newLods, Color[][] newColors, int threadNumber, int totalThreads)
-	{
-		vertexCount = 0;
-        vertexFormatIndex = 0;
-		
-		nearBuffer = newNearByteBuffer;
-		farBuffer = newFarByteBuffer;
-		distanceMode = newDistanceMode;
-		lods = newLods;
-		colors = newColors;
-		
-		int numbChunksWide = lods.length;
-		int rowsToRender = numbChunksWide / totalThreads;
-		start = threadNumber * rowsToRender;
-		end = (threadNumber + 1) * rowsToRender;
-	}
-	
-	@Override
-	public NearFarBuffer call()
-	{
-		int numbChunksWide = lods.length;
-		
-		ByteBuffer currentBuffer;
-		AxisAlignedBB bb;
-		int red;
-		int green;
-		int blue;
-		int alpha;
-		
-		if (distanceMode == FogDistance.NEAR)
-		{
-			currentBuffer = nearBuffer;
-		}
-		else // if (distanceMode == FogDistance.FAR)
-		{
-			currentBuffer = farBuffer;
-		}
-		
-		
-		// x axis
-		for (int i = start; i < end; i++)
-		{
-			// z axis
-			for (int j = 0; j < numbChunksWide; j++)
-			{
-				if (lods[i][j] == null || colors[i][j] == null)
-					continue;
-				
-				bb = lods[i][j];
-				
-				// get the color of this LOD object
-				red = colors[i][j].getRed();
-				green = colors[i][j].getGreen();
-				blue = colors[i][j].getBlue();
-				alpha = colors[i][j].getAlpha();
-				
-				// choose which buffer to add these LODs too
-				if (distanceMode == FogDistance.NEAR_AND_FAR)
-				{
-					if (RenderUtil.isCoordinateInNearFogArea(i, j, numbChunksWide / 2))
-						currentBuffer = nearBuffer;
-					else
-						currentBuffer = farBuffer;
-				}
-				
-				
-				if (bb.minY != bb.maxY)
-				{
-					// top (facing up)
-					addPosAndColor(currentBuffer, bb.minX, bb.maxY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.maxY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.maxY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.maxY, bb.minZ, red, green, blue, alpha);
-					// bottom (facing down)
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
-
-					// south (facing -Z) 
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.maxY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.maxY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					// north (facing +Z)
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.maxY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.maxY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
-
-					// west (facing -X)
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.maxY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.maxY, bb.minZ, red, green, blue, alpha);
-					// east (facing +X)
-					addPosAndColor(currentBuffer, bb.maxX, bb.maxY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.maxY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
-				}
-				else
-				{
-					// render this LOD as one block thick
-					
-					// top (facing up)
-					addPosAndColor(currentBuffer, bb.minX, bb.minY+1, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY+1, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY+1, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY+1, bb.minZ, red, green, blue, alpha);
-					// bottom (facing down)
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
-
-					// south (facing -Z) 
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY+1, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY+1, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					// north (facing +Z)
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY+1, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY+1, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
-
-					// west (facing -X)
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY+1, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.minX, bb.minY+1, bb.minZ, red, green, blue, alpha);
-					// east (facing +X)
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY+1, bb.minZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY+1, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
-					addPosAndColor(currentBuffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
-				}
-				
-			} // z axis
-		} // x axis
-		
-		return new NearFarBuffer(nearBuffer, farBuffer);
-	}
-	
-	private void addPosAndColor(ByteBuffer buffer, double x, double y, double z, int red, int green, int blue, int alpha)
-	{
-		addPos(buffer, x, y, z);
-		addColor(buffer, red, green, blue, alpha);
-		endVertex();
-	}
-
-	private void addPos(ByteBuffer byteBuffer, double x, double y, double z)
-	{
-		int i = this.vertexCount * this.vertexFormat.getNextOffset() + this.vertexFormat.getOffset(this.vertexFormatIndex);
-
-        switch (this.vertexFormatElement.getType())
-        {
-            case FLOAT: // This is the one currently used
-                byteBuffer.putFloat(i, (float)(x));
-                byteBuffer.putFloat(i + 4, (float)(y));
-                byteBuffer.putFloat(i + 8, (float)(z));
-                break;
-            case UINT:
-            case INT:
-                byteBuffer.putInt(i, Float.floatToRawIntBits((float)(x)));
-                byteBuffer.putInt(i + 4, Float.floatToRawIntBits((float)(y)));
-                byteBuffer.putInt(i + 8, Float.floatToRawIntBits((float)(z)));
-                break;
-            case USHORT:
-            case SHORT:
-                byteBuffer.putShort(i, (short)((int)(x)));
-                byteBuffer.putShort(i + 2, (short)((int)(y)));
-                byteBuffer.putShort(i + 4, (short)((int)(z)));
-                break;
-            case UBYTE:
-            case BYTE:
-                byteBuffer.put(i, (byte)((int)(x)));
-                byteBuffer.put(i + 1, (byte)((int)(y)));
-                byteBuffer.put(i + 2, (byte)((int)(z)));
-        }
-        
-        nextVertexFormatIndex();
-	}
-	
-	private void addColor(ByteBuffer byteBuffer, int red, int green, int blue, int alpha)
-    {
-        int i = this.vertexCount * this.vertexFormat.getNextOffset() + this.vertexFormat.getOffset(this.vertexFormatIndex);
-
-        switch (this.vertexFormatElement.getType())
-        {
-            case FLOAT:
-            	byteBuffer.putFloat(i, red / 255.0F);
-            	byteBuffer.putFloat(i + 4, green / 255.0F);
-            	byteBuffer.putFloat(i + 8, blue / 255.0F);
-            	byteBuffer.putFloat(i + 12, alpha / 255.0F);
-                break;
-            case UINT:
-            case INT:
-            	byteBuffer.putFloat(i, red);
-            	byteBuffer.putFloat(i + 4, green);
-            	byteBuffer.putFloat(i + 8, blue);
-            	byteBuffer.putFloat(i + 12, alpha);
-                break;
-            case USHORT:
-            case SHORT:
-            	byteBuffer.putShort(i, (short)red);
-            	byteBuffer.putShort(i + 2, (short)green);
-            	byteBuffer.putShort(i + 4, (short)blue);
-            	byteBuffer.putShort(i + 6, (short)alpha);
-                break;
-            case UBYTE:
-            case BYTE:
-            	
-                if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN)
-                {
-                	// this is the one used currently
-                    byteBuffer.put(i, (byte)red);
-                    byteBuffer.put(i + 1, (byte)green);
-                    byteBuffer.put(i + 2, (byte)blue);
-                    byteBuffer.put(i + 3, (byte)alpha);
-                }
-                else
-                {
-                    byteBuffer.put(i, (byte)alpha);
-                    byteBuffer.put(i + 1, (byte)blue);
-                    byteBuffer.put(i + 2, (byte)green);
-                    byteBuffer.put(i + 3, (byte)red);
-                }
-        }
-
-        nextVertexFormatIndex();
-    }
-	
-	private void nextVertexFormatIndex()
-    {
-        ++this.vertexFormatIndex;
-        this.vertexFormatIndex %= this.vertexFormat.getElementCount();
-        this.vertexFormatElement = this.vertexFormat.getElement(this.vertexFormatIndex);
-
-        if (this.vertexFormatElement.getUsage() == VertexFormatElement.EnumUsage.PADDING)
-        {
-            this.nextVertexFormatIndex();
-        }
-    }
-	
-	private void endVertex()
-    {
-        ++this.vertexCount;
-        growBuffer(this.vertexFormat.getNextOffset());
-    }
-	
-	private void growBuffer(int p_181670_1_)
-    {
-        //if (MathHelper.roundUp(p_181670_1_, 4) / 4 > this.rawIntBuffer.remaining() || this.vertexCount * this.vertexFormat.getNextOffset() + p_181670_1_ > this.byteBuffer.capacity())
-		if (this.vertexCount * this.vertexFormat.getNextOffset() + p_181670_1_ > nearBuffer.capacity())
-        {
-            int i = nearBuffer.capacity();
-            int j = i + MathHelper.roundUp(p_181670_1_, 2097152);
-//	            int k = this.rawIntBuffer.position();
-            ByteBuffer directBytebuffer = GLAllocation.createDirectByteBuffer(j);
-            nearBuffer.position(0);
-            directBytebuffer.put(nearBuffer);
-            directBytebuffer.rewind();
-            nearBuffer = directBytebuffer;
-//	            this.rawFloatBuffer = buffer.asFloatBuffer().asReadOnlyBuffer();
-//	            this.rawIntBuffer = buffer.asIntBuffer();
-//	            this.rawIntBuffer.position(k);
-//	            this.rawShortBuffer = buffer.asShortBuffer();
-//	            this.rawShortBuffer.position(k << 1);
-        }
-    }
-	
-	
-	
-}
@@ -1,667 +0,0 @@
-package com.backsun.lod.renderer;
-
-import java.awt.Color;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.FloatBuffer;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.util.glu.Project;
-
-import com.backsun.lod.objects.LodChunk;
-import com.backsun.lod.objects.LodDimension;
-import com.backsun.lod.util.LodConfig;
-import com.backsun.lod.util.ReflectionHandler;
-import com.backsun.lod.util.enums.ColorDirection;
-import com.backsun.lod.util.enums.FogDistance;
-import com.backsun.lod.util.enums.FogQuality;
-import com.backsun.lod.util.enums.LodLocation;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.BufferBuilder;
-import net.minecraft.client.renderer.GlStateManager;
-import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
-import net.minecraft.entity.Entity;
-import net.minecraft.util.math.AxisAlignedBB;
-import net.minecraft.util.math.MathHelper;
-
-/**
- * @author James Seibel
- * @version 2-13-2021
- */
-public class LodRenderer
-{
-	/** If true the LODs colors will be replaced with
-	 * a checkerboard, this can be used for debugging. */
-	public boolean debugging = false;
-	
-	private Minecraft mc;
-	private float farPlaneDistance;
-	// make sure this is an even number, or else it won't align with the chunk grid
-	/** this is the total width of the LODs (I.E the diameter, not the radius) */
-	private static final int LOD_CHUNK_DISTANCE_RADIUS = 6;
-	
-	private Tessellator tessellator;
-	private BufferBuilder bufferBuilder;
-	
-	/**
-	 * This is an array of 0's used to clear old 
-	 * ByteBuffers when they need to be rebuilt.
-	 */
-	byte[] clearBytes;
-	
-	private ReflectionHandler reflectionHandler;
-	
-	public LodDimension lodDimension = null;
-	
-	
-	
-	private int maxNumbThreads = Runtime.getRuntime().availableProcessors();
-	/** How many threads should be used for building the render buffer. */
-	private int numbBufferThreads = maxNumbThreads;
-	private ArrayList<BuildBufferThread> bufferThreads = new ArrayList<BuildBufferThread>();
-	private volatile ByteBuffer[] nearBuffers = new ByteBuffer[maxNumbThreads];
-	private volatile ByteBuffer[] farBuffers = new ByteBuffer[maxNumbThreads];
-	private ExecutorService bufferThreadPool = Executors.newFixedThreadPool(maxNumbThreads);
-	/*
-	 * this is the maximum number of bytes a buffer
-	 * would ever have to hold at once (this prevents the buffer
-	 * from having to resize and thus save performance)
-	 */
-	private int bufferMaxCapacity = 0;
-	
-	/** This is used to determine if the LODs should be regenerated */
-	private int previousChunkRenderDistance = 0;
-	/** This is used to determine if the LODs should be regenerated */
-	private int prevChunkX = 0;
-	/** This is used to determine if the LODs should be regenerated */
-	private int prevChunkZ = 0;
-	/** This is used to determine if the LODs should be regenerated */
-	private FogDistance prevFogDistance = FogDistance.NEAR_AND_FAR;
-	
-	/** if this is true the LODs should be regenerated */
-	private boolean regen = false;
-	
-	
-	
-	
-	public LodRenderer()
-	{
-		mc = Minecraft.getMinecraft();
-		
-		// for some reason "Tessellator.getInstance()" won't work here, we have to create a new one
-		tessellator = new Tessellator(2097152);
-		bufferBuilder = tessellator.getBuffer();
-		
-		reflectionHandler = new ReflectionHandler();
-	}
-	
-	
-	
-	public void drawLODs(LodDimension newDimension, float partialTicks)
-	{
-		if (reflectionHandler.fovMethod == null)
-		{
-			// don't continue if we can't get the
-			// user's FOV
-			return;
-		}
-		
-		if (reflectionHandler.fovMethod == null)
-		{
-			// we aren't able to get the user's
-			// FOV, don't render anything
-			return;
-		}
-		
-		// should the LODs be regenerated?
-		if ((int)Minecraft.getMinecraft().player.posX / LodChunk.WIDTH != prevChunkX ||
-			(int)Minecraft.getMinecraft().player.posZ / LodChunk.WIDTH != prevChunkZ ||
-			previousChunkRenderDistance != mc.gameSettings.renderDistanceChunks ||
-			prevFogDistance != LodConfig.fogDistance ||
-			lodDimension != newDimension)
-		{
-			regen = true;
-			
-			prevChunkX = (int)Minecraft.getMinecraft().player.posX / LodChunk.WIDTH;
-			prevChunkZ = (int)Minecraft.getMinecraft().player.posZ / LodChunk.WIDTH;
-			prevFogDistance = LodConfig.fogDistance;
-		}
-		else
-		{
-			// nope, the player hasn't moved, the
-			// render distance hasn't changed, and
-			// the dimension is the same
-			regen = false;
-		}
-		
-		lodDimension = newDimension;
-		if (lodDimension == null)
-		{
-			// if there aren't any loaded LodChunks
-			// don't try drawing anything
-			return;
-		}
-		
-		
-		
-		
-		
-		
-		// used for debugging and viewing how long different processes take
-		mc.mcProfiler.endSection();
-		mc.mcProfiler.startSection("LOD");
-		mc.mcProfiler.startSection("LOD setup");
-		@SuppressWarnings("unused")
-		long startTime = System.nanoTime();
-		if (LodConfig.drawCheckerBoard)
-		{
-			if (debugging != LodConfig.drawCheckerBoard)
-				regen = true;
-			debugging = true;
-		}
-		else
-		{
-			if (debugging != LodConfig.drawCheckerBoard)
-				regen = true;
-			debugging = false;
-		}
-		
-		
-		// color setup
-		int alpha = 255; // 0 - 255
-		
-		Color red = new Color(255, 0, 0, alpha);
-		Color black = new Color(0, 0, 0, alpha);
-		Color white = new Color(255, 255, 255, alpha);
-		@SuppressWarnings("unused")
-		Color invisible = new Color(0,0,0,0);
-		@SuppressWarnings("unused")
-		Color error = new Color(255, 0, 225, alpha); // bright pink
-		
-		
-		
-		// get the camera location
-		Entity player = mc.player;
-		double cameraX = player.lastTickPosX + (player.posX - player.lastTickPosX) * partialTicks;
-		double cameraY = player.lastTickPosY + (player.posY - player.lastTickPosY) * partialTicks;
-		double cameraZ = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * partialTicks;
-
-		
-
-		
-		// determine how far the game's render distance is currently set
-		int renderDistWidth = mc.gameSettings.renderDistanceChunks;
-		farPlaneDistance = renderDistWidth * LodChunk.WIDTH;
-		
-		// set how big the LODs will be and how far they will go
-		int totalLength = (int) farPlaneDistance * LOD_CHUNK_DISTANCE_RADIUS * 2;
-		int numbChunksWide = (totalLength / LodChunk.WIDTH);
-		
-		// this seemingly useless math is required,
-		// just using (int) camera doesn't work
-		int playerXChunkOffset = ((int) cameraX / LodChunk.WIDTH) * LodChunk.WIDTH;
-		int playerZChunkOffset = ((int) cameraZ / LodChunk.WIDTH) * LodChunk.WIDTH;
-		// this where we will start drawing squares
-		// (exactly half the total width)
-		int startX = (-LodChunk.WIDTH * (numbChunksWide / 2)) + playerXChunkOffset;
-		int startZ = (-LodChunk.WIDTH * (numbChunksWide / 2)) + playerZChunkOffset;
-		
-		
-		// this is where we store the LOD objects
-		AxisAlignedBB lodArray[][] = new AxisAlignedBB[numbChunksWide][numbChunksWide];
-		// this is where we store the color for each LOD object
-		Color colorArray[][] = new Color[numbChunksWide][numbChunksWide];
-		
-		
-		
-		
-		
-		//=================//
-		// create the LODs //
-		//=================//
-		
-		if (regen)
-		{
-			mc.mcProfiler.endStartSection("LOD generation");
-			
-			// x axis
-			for (int i = 0; i < numbChunksWide; i++)
-			{
-				// z axis
-				for (int j = 0; j < numbChunksWide; j++)
-				{
-					// skip the middle
-					// (As the player moves some chunks will overlap or be missing,
-					// this is just how chunk loading/unloading works. This can hopefully
-					// be hidden with careful use of fog)
-					int middle = (numbChunksWide / 2);
-					if (RenderUtil.isCoordinateInLoadedArea(i, j, middle))
-					{
-						continue;
-					}
-					
-					
-					// set where this square will be drawn in the world
-					double xOffset = (LodChunk.WIDTH * i) + // offset by the number of LOD blocks
-									startX; // offset so the center LOD block is centered underneath the player
-					double yOffset = 0;
-					double zOffset = (LodChunk.WIDTH * j) + startZ;
-					
-					int chunkX = i + (startX / LodChunk.WIDTH);
-					int chunkZ = j + (startZ / LodChunk.WIDTH);
-					
-					LodChunk lod = lodDimension.getLodFromCoordinates(chunkX, chunkZ); // new LodChunk(); //   
-					if (lod == null)
-					{
-						// note: for some reason if any color or lod object are set here
-						// it causes the game to use 100% gpu, all of it undefined in the debug menu
-						// and drop to ~6 fps.
-//						colorArray[i][j] = null;
-//						lodArray[i][j] = null;
-						
-						continue;
-					}
-					
-					Color c = new Color(
-							(lod.colors[ColorDirection.TOP.value].getRed()),
-							(lod.colors[ColorDirection.TOP.value].getGreen()),
-							(lod.colors[ColorDirection.TOP.value].getBlue()),
-							lod.colors[ColorDirection.TOP.value].getAlpha());
-					
-					
-					
-					if (!debugging)
-					{
-						// add the color to the array
-						colorArray[i][j] = c;
-					}
-					else
-					{
-						// if debugging draw the squares as a black and white checker board
-						if ((chunkX + chunkZ) % 2 == 0)
-							c = white;
-						else
-							c = black;
-						// draw the first square as red
-						if (i == 0 && j == 0)
-							c = red;
-						
-						colorArray[i][j] = c;
-					}
-					
-					
-					// add the new box to the array
-					int topPoint = getLodHeightPoint(lod.top);
-					int bottomPoint = getLodHeightPoint(lod.bottom);
-					
-					// don't draw an LOD if it is empty
-					if (topPoint == -1 && bottomPoint == -1)
-						continue;
-					
-					lodArray[i][j] = new AxisAlignedBB(0, bottomPoint, 0, LodChunk.WIDTH, topPoint, LodChunk.WIDTH).offset(xOffset, yOffset, zOffset);
-				}
-			}
-		}
-		
-		
-		
-		
-		//===========================//
-		// GL settings for rendering //
-		//===========================//
-		
-		// set the required open GL settings
-		GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-		GL11.glLineWidth(2.0f);
-		GL11.glDisable(GL11.GL_TEXTURE_2D);
-		GL11.glEnable(GL11.GL_CULL_FACE);
-		
-		GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
-		
-		GlStateManager.translate(-cameraX, -cameraY, -cameraZ);
-		
-		setProjectionMatrix(partialTicks);
-		setupLighting(partialTicks);
-		setupBufferThreads(lodArray);
-		
-		
-		
-		
-		
-		
-		//===========//
-		// rendering //
-		//===========//
-		
-		mc.mcProfiler.endStartSection("LOD build buffer");
-		if (regen)
-			generateLodBuffers(lodArray, colorArray, LodConfig.fogDistance);
-		
-		switch(LodConfig.fogDistance)
-		{
-		case NEAR_AND_FAR:
-			mc.mcProfiler.endStartSection("LOD draw setup");
-			setupFog(FogDistance.NEAR, reflectionHandler.getFogQuality());
-			sendLodsToGpuAndDraw(nearBuffers);
-			
-			mc.mcProfiler.endStartSection("LOD draw setup");
-			setupFog(FogDistance.FAR, reflectionHandler.getFogQuality());
-			sendLodsToGpuAndDraw(farBuffers);
-			break;
-		case NEAR:
-			mc.mcProfiler.endStartSection("LOD draw setup");
-			setupFog(FogDistance.NEAR, reflectionHandler.getFogQuality());
-			sendLodsToGpuAndDraw(nearBuffers);
-			break;
-		case FAR:
-			mc.mcProfiler.endStartSection("LOD draw setup");
-			setupFog(FogDistance.FAR, reflectionHandler.getFogQuality());
-			sendLodsToGpuAndDraw(farBuffers);
-			break;
-		}
-		
-		
-		
-		
-		
-		//=========//
-		// cleanup //
-		//=========//
-		
-		mc.mcProfiler.endStartSection("LOD cleanup");
-		
-		
-		// this must be done otherwise other parts of the screen may be drawn with a fog effect
-		// IE the GUI
-		GlStateManager.disableFog();
-		
-		GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
-		GL11.glEnable(GL11.GL_TEXTURE_2D);
-		GL11.glDisable(GL11.GL_LIGHT1);
-		GL11.glDisable(GL11.GL_COLOR_MATERIAL);
-		
-		// change the perspective matrix back to prevent incompatibilities
-		// with other mods that may render during forgeRenderLast
-		Project.gluPerspective(reflectionHandler.getFov(mc, partialTicks, true), (float) this.mc.displayWidth / (float) this.mc.displayHeight, 0.05F, this.farPlaneDistance * MathHelper.SQRT_2);
-		
-		// this can't be called until after the buffers are built
-		// because otherwise the buffers may be set to the wrong size
-		previousChunkRenderDistance = mc.gameSettings.renderDistanceChunks;
-		
-		
-		
-		// This is about how long this whole process should take
-		// 16 ms = 60 hz
-		@SuppressWarnings("unused")
-		long endTime = System.nanoTime();
-		
-		// end of profiler tracking
-		mc.mcProfiler.endSection();
-	}
-
-
-
-	
-	
-	
-	
-	
-	
-	/**
-	 * draw an array of cubes (or squares) with the given colors.
-	 * @param lods bounding boxes to draw
-	 * @param colors color of each box to draw
-	 */
-	private void generateLodBuffers(AxisAlignedBB[][] lods, Color[][] colors, FogDistance fogDistance)
-	{
-		List<Future<NearFarBuffer>> bufferFutures = new ArrayList<>();
-		// TODO this should change based on whether we are using near/far or both fog settings
-		bufferMaxCapacity = (lods.length * lods.length * (6 * 4 * ((3 * 4) + (4 * 4)))) / numbBufferThreads; 
-		
-		for(int i = 0; i < numbBufferThreads; i++)
-		{
-			if (nearBuffers[i] == null || previousChunkRenderDistance != mc.gameSettings.renderDistanceChunks)
-			{
-				nearBuffers[i] = ByteBuffer.allocateDirect(bufferMaxCapacity);
-				nearBuffers[i].order(ByteOrder.LITTLE_ENDIAN);
-				
-				farBuffers[i] = ByteBuffer.allocateDirect(bufferMaxCapacity);
-				farBuffers[i].order(ByteOrder.LITTLE_ENDIAN);
-				
-				clearBytes = new byte[bufferMaxCapacity];
-			}
-			
-			if (regen)
-			{
-				// this is the best way I could find to
-				// overwrite the old data
-				// (which needs to be done otherwise old
-				// LODs may be drawn)
-				nearBuffers[i].clear();
-				nearBuffers[i].put(clearBytes);
-				nearBuffers[i].clear();
-				
-				farBuffers[i].clear();
-				farBuffers[i].put(clearBytes);
-				farBuffers[i].clear();
-			}
-			
-			int pos = bufferBuilder.getByteBuffer().position();
-			nearBuffers[i].position(pos);
-			farBuffers[i].position(pos);
-			
-			bufferThreads.get(i).setNewData(nearBuffers[i], farBuffers[i], fogDistance, lods, colors, i, numbBufferThreads);
-		}
-		
-		try
-		{
-			bufferFutures = bufferThreadPool.invokeAll(bufferThreads);
-		}
-		catch (InterruptedException e)
-		{
-			// this should never happen, but just in case
-			e.printStackTrace();
-		}
-		
-		for(int i = 0; i < numbBufferThreads; i++)
-		{
-			try
-			{
-				nearBuffers[i] = bufferFutures.get(i).get().nearBuffer;
-				farBuffers[i] = bufferFutures.get(i).get().farBuffer;
-			}
-			catch(CancellationException | ExecutionException| InterruptedException e)
-			{
-				// this should never happen, but just in case
-				e.printStackTrace();
-			}
-		}
-		
-	}
-	
-	private void sendLodsToGpuAndDraw(ByteBuffer[] buffers)
-	{
-		for(int i = 0; i < numbBufferThreads; i++)
-		{
-			int pos = bufferBuilder.getByteBuffer().position();
-			buffers[i].position(pos);
-			
-			bufferBuilder.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_COLOR);
-			bufferBuilder.getByteBuffer().clear();
-			bufferBuilder.putBulkData(buffers[i]);
-			
-			mc.mcProfiler.endStartSection("LOD draw");
-			tessellator.draw();
-			mc.mcProfiler.endStartSection("LOD draw setup");
-			
-			bufferBuilder.getByteBuffer().clear(); // this is required otherwise nothing is drawn
-		}
-	}
-	
-	
-	
-	
-	
-	
-	
-	//=================//
-	// Setup Functions //
-	//=================//
-	
-	private void setupFog(FogDistance fogDistance, FogQuality fogQuality)
-	{
-		if(fogQuality == FogQuality.OFF)
-		{
-			GlStateManager.disableFog();
-			return;
-		}
-		
-		if(fogDistance == FogDistance.NEAR_AND_FAR)
-		{
-			throw new IllegalArgumentException("setupFog only accepts NEAR or FAR fog distances.");
-		}
-
-		// the multipliers are percentages
-		// of the regular view distance.
-		
-		if(fogDistance == FogDistance.NEAR)
-		{
-			// the reason that I wrote fogEnd then fogStart backwards
-			// is because we are using fog backwards to how
-			// it is normally used, with it hiding near objects
-			// instead of far objects.
-			
-			if (fogQuality == FogQuality.FANCY)
-			{
-				GlStateManager.setFogEnd(farPlaneDistance * 0.3f * LOD_CHUNK_DISTANCE_RADIUS);
-				GlStateManager.setFogStart(farPlaneDistance * 0.35f * LOD_CHUNK_DISTANCE_RADIUS);
-			}
-			else if(fogQuality == FogQuality.FAST)
-			{
-				// for the far fog of the normal chunks
-				// to start right where the LODs' end use:
-				// end = 0.8f, start = 1.5f
-				
-				GlStateManager.setFogEnd(farPlaneDistance * 1.5f);
-				GlStateManager.setFogStart(farPlaneDistance * 2.0f);
-			}
-		}
-		else if(fogDistance == FogDistance.FAR)
-		{
-			if (fogQuality == FogQuality.FANCY)
-			{
-				GlStateManager.setFogStart(farPlaneDistance * 0.78f * LOD_CHUNK_DISTANCE_RADIUS);
-				GlStateManager.setFogEnd(farPlaneDistance * 1.0f * LOD_CHUNK_DISTANCE_RADIUS);
-			}
-			else if(fogQuality == FogQuality.FAST)
-			{
-				GlStateManager.setFogStart(farPlaneDistance * 0.5f * LOD_CHUNK_DISTANCE_RADIUS);
-				GlStateManager.setFogEnd(farPlaneDistance * 0.75f * LOD_CHUNK_DISTANCE_RADIUS);
-			}
-		}
-		
-		GlStateManager.setFogDensity(0.1f);
-		GlStateManager.enableFog();
-	}
-	
-
-	/**
-	 * create a new projection matrix and send it over to the GPU
-	 * @param partialTicks how many ticks into the frame we are
-	 * @return true if the matrix was successfully created and sent to the GPU, false otherwise
-	 */
-	private void setProjectionMatrix(float partialTicks)
-	{
-		// create a new view frustum so that the squares can be drawn outside the normal view distance
-		GlStateManager.matrixMode(GL11.GL_PROJECTION);
-		GlStateManager.loadIdentity();	
-		
-		// only continue if we can get the FOV
-		if (reflectionHandler.fovMethod != null)
-		{
-			Project.gluPerspective(reflectionHandler.getFov(mc, partialTicks, true), (float) mc.displayWidth / (float) mc.displayHeight, 0.5F, farPlaneDistance * 12);
-		}
-		
-		// we weren't able to set up the projection matrix
-		return;
-	}
-	
-	
-	/**
-	 * setup the lighting to be used for the LODs
-	 */
-	private void setupLighting(float partialTicks)
-	{
-		GL11.glEnable(GL11.GL_COLOR_MATERIAL); // set the color to be used as the material (this allows lighting to be enabled)
-		
-		// this isn't perfect right now, but it looks pretty good at 50% brightness
-		float sunBrightness = mc.world.getSunBrightness(partialTicks) * mc.world.provider.getSunBrightnessFactor(partialTicks);
-		float skyHasLight = mc.world.provider.hasSkyLight()? 1.0f : 0.15f;
-		float gammaMultiplyer = (mc.gameSettings.gammaSetting * 0.5f + 0.5f);
-		float lightStrength = sunBrightness * skyHasLight * gammaMultiplyer;
-		float lightAmbient[] = {lightStrength, lightStrength, lightStrength, 1.0f};
-        	
-		ByteBuffer temp = ByteBuffer.allocateDirect(16);
-		temp.order(ByteOrder.nativeOrder());
-		GL11.glLight(GL11.GL_LIGHT1, GL11.GL_AMBIENT, (FloatBuffer) temp.asFloatBuffer().put(lightAmbient).flip());
-		GL11.glEnable(GL11.GL_LIGHT1); // Enable the above lighting
-		
-		GlStateManager.enableLighting();
-	}
-	
-	
-	private void setupBufferThreads(AxisAlignedBB[][] lods)
-	{
-		if (numbBufferThreads != bufferThreads.size())
-		{
-			bufferMaxCapacity = (lods.length * lods.length * (6 * 4 * ((3 * 4) + (4 * 4)))) / numbBufferThreads;
-			clearBytes = new byte[bufferMaxCapacity];
-			
-			bufferThreads.clear();
-			for(int i = 0; i < numbBufferThreads; i++)
-				bufferThreads.add(new BuildBufferThread());
-			regen = true;
-			
-			for(int i = 0; i < maxNumbThreads; i++)
-			{
-				nearBuffers[i] = ByteBuffer.allocateDirect(bufferMaxCapacity);
-				nearBuffers[i].order(ByteOrder.LITTLE_ENDIAN);
-				
-				farBuffers[i] = ByteBuffer.allocateDirect(bufferMaxCapacity);
-				farBuffers[i].order(ByteOrder.LITTLE_ENDIAN);
-			}
-		}
-	}
-	
-	
-	
-	
-	
-	/**
-	 * Returns -1 if there are no valid points
-	 */
-	private int getLodHeightPoint(short[] heightPoints)
-	{
-		if (heightPoints[LodLocation.NE.value] != -1)
-			return heightPoints[LodLocation.NE.value];
-		if (heightPoints[LodLocation.NW.value] != -1)
-			return heightPoints[LodLocation.NW.value];
-		if (heightPoints[LodLocation.SE.value] != -1)
-			return heightPoints[LodLocation.NE.value];
-		return heightPoints[LodLocation.NE.value];
-	}
-	
-	
-	
-	
-	
-}
@@ -1,25 +0,0 @@
-package com.backsun.lod.renderer;
-
-import java.nio.ByteBuffer;
-
-/**
- * This object is just a replacement for an array
- * to make things easier to understand in the LodRenderer
- * and BuildBufferThread.
- * 
- * @author James Seibel
- * @version 02-13-2021
- */
-public class NearFarBuffer
-{
-	public ByteBuffer nearBuffer;
-	
-	public ByteBuffer farBuffer;
-	
-	
-	NearFarBuffer(ByteBuffer newNearBuffer, ByteBuffer newFarBuffer)
-	{
-		nearBuffer = newNearBuffer;
-		farBuffer = newFarBuffer;
-	}
-}
@@ -1,45 +0,0 @@
-package com.backsun.lod.renderer;
-
-import net.minecraft.client.Minecraft;
-
-/**
- * This holds miscellaneous helper code
- * to be used in the rendering process.
- * 
- * @author James Seibel
- * @version 2-13-2021
- */
-public class RenderUtil
-{
-	/**
-	 * Returns if the given coordinate is in the loaded area of the world.
-	 * @param centerCoordinate the center of the loaded world
-	 */
-	public static boolean isCoordinateInLoadedArea(int i, int j, int centerCoordinate)
-	{
-		Minecraft mc = Minecraft.getMinecraft();
-		
-		return (i >= centerCoordinate - mc.gameSettings.renderDistanceChunks 
-				&& i <= centerCoordinate + mc.gameSettings.renderDistanceChunks) 
-				&& 
-				(j >= centerCoordinate - mc.gameSettings.renderDistanceChunks 
-				&& j <= centerCoordinate + mc.gameSettings.renderDistanceChunks);
-	}
-	
-	
-	/**
-	 * Find the coordinates that are in the center half of the given
-	 * 2D matrix, starting at (0,0) and going to (2 * lodRadius, 2 * lodRadius).
-	 */
-	public static boolean isCoordinateInNearFogArea(int i, int j, int lodRadius)
-	{
-		int halfRadius = lodRadius / 2;
-		
-		return (i >= lodRadius - halfRadius 
-				&& i <= lodRadius + halfRadius) 
-				&& 
-				(j >= lodRadius - halfRadius
-				&& j <= lodRadius + halfRadius);
-	}
-	
-}
@@ -1,55 +0,0 @@
-package com.backsun.lod.util;
-
-import com.backsun.lod.util.enums.FogDistance;
-
-import net.minecraftforge.common.config.Config;
-import net.minecraftforge.common.config.ConfigManager;
-import net.minecraftforge.fml.client.event.ConfigChangedEvent;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-
-/**
- * 
- * @author James Seibel
- * @version 02-14-2021
- */
-@Config(modid = Reference.MOD_ID)
-public class LodConfig
-{
-	// save the config file when it is changed
-	@Mod.EventBusSubscriber(modid = Reference.MOD_ID)
-	private static class EventHandler
-	{
-		@SubscribeEvent
-		public static void onConfigChanged(final ConfigChangedEvent.OnConfigChangedEvent event)
-		{
-			if (event.getModID().equals(Reference.MOD_ID))
-			{
-				ConfigManager.sync(Reference.MOD_ID, Config.Type.INSTANCE);
-			}
-		}
-	}
-	
-	
-	@Config.Comment(
-			{"Enable LODs", 
-			"If true LODs will be drawn, if false LODs will "
-			+ "not be rendered. However they will "
-			+ "still be generated and stored in your world's save folder."})
-	public static boolean drawLODs = true;
-	
-	@Config.Comment(
-			{"Fog Distance", 
-			"What distance should Fog be drawn on the LODs?"})
-	public static FogDistance fogDistance = FogDistance.NEAR_AND_FAR;
-	
-	@Config.Comment(
-			{"Draw Debugging Checkerboard", 
-			"If false the LODs will draw with their normal world colors."
-			+ "If true they will draw as a black and white checkerboard."
-			+ "This can be used for debugging or imagining you are playing a "
-			+ "giant game of chess ;)"})
-	public static boolean drawCheckerBoard = false;
-	
-	
-}
@@ -1,322 +0,0 @@
-package com.backsun.lod.util;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import com.backsun.lod.objects.LodChunk;
-import com.backsun.lod.objects.LodDimension;
-import com.backsun.lod.objects.LodRegion;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.world.storage.ISaveHandler;
-
-/**
- * This object handles creating LodRegions
- * from files and saving LodRegion objects
- * to file.
- * 
- * @author James Seibel
- * @version 01-30-2021
- */
-public class LodFileHandler
-{
-	private LodDimension loadedRegion = null;
-	public long regionLastWriteTime[][];
-	
-	// String s = Minecraft.getMinecraftDir().getCanonicalPath() + "/saves/" + world.getSaveHandler().getSaveDirectoryName() + "/data/AA/World" + world.provider.dimensionId + ".dat";
-	private String save_dir;
-	public ISaveHandler saveHandler;
-	
-	private final String FILE_NAME_PREFIX = "lod";
-	private final String FILE_EXTENSION = ".txt";
-	
-	private ExecutorService fileWritingThreadPool = Executors.newFixedThreadPool(1);
-	/** Is true if the readyToReadAndWrite is false */
-	private boolean waitingToSaveRegions = false;
-	
-	
-	public LodFileHandler(ISaveHandler newSaveHandler, LodDimension newLoadedRegion)
-	{
-		saveHandler = newSaveHandler;
-		
-		loadedRegion = newLoadedRegion;
-		// these two variable are used in sync with the LodDimension
-		regionLastWriteTime = new long[loadedRegion.getWidth()][loadedRegion.getWidth()];
-		for(int i = 0; i < loadedRegion.getWidth(); i++)
-			for(int j = 0; j < loadedRegion.getWidth(); j++)
-				regionLastWriteTime[i][j] = -1;
-		
-		if (saveHandler != null && saveHandler.getWorldDirectory() != null)
-			save_dir = getWorldSaveDirectory();
-	}
-	
-	
-	
-	
-	
-	//================//
-	// read from file //
-	//================//
-	
-	
-	
-	/**
-	 * Return the LodRegion at the given coordinates.
-	 * (null if the file doesn't exist)
-	 */
-	public LodRegion loadRegionFromFile(int regionX, int regionZ)
-	{
-		// we don't currently support reading or writing
-		// files when connected to a server
-		if (!Minecraft.getMinecraft().isIntegratedServerRunning())
-			return null;
-		
-		if (!readyToReadAndWrite())
-			return null;
-		
-		String fileName = getFileNameForRegion(regionX, regionZ);
-		
-		File f = new File(fileName);
-		
-		if (!f.exists())
-		{
-			// there wasn't a file, don't
-			// return anything
-			return null;
-		}
-		
-		LodRegion region = new LodRegion(regionX, regionZ);
-		
-		try
-		{
-			BufferedReader br = new BufferedReader(new FileReader(f));
-			String s = br.readLine();
-			
-			while(s != null && !s.isEmpty())
-			{
-				try
-				{
-					// convert each line into an LOD object and add it to the region
-					LodChunk lod = new LodChunk(s);
-					
-					region.addLod(lod);
-				}
-				catch(IllegalArgumentException e)
-				{
-					// we were unable to create this chunk
-					// for whatever reason.
-					// skip to the next chunk
-				}
-				
-				s = br.readLine();
-			}
-			
-			br.close();
-		}
-		catch (IOException e)
-		{
-			// File not found
-			
-			// or the buffered reader encountered a 
-			// problem reading the file
-			return null;
-		}
-		
-		return region;
-	}
-	
-	
-	
-	
-	
-	
-	
-	
-	//==============//
-	// Save to File //
-	//==============//
-	
-	
-	public synchronized void saveDirtyRegionsToFile()
-	{
-		// we don't currently support reading or writing
-		// files when connected to a server
-		if (!Minecraft.getMinecraft().isIntegratedServerRunning())
-			return;
-		
-		if (!readyToReadAndWrite())
-		{	
-			// we aren't ready to read and write yet
-			if(!waitingToSaveRegions)
-			{
-				waitingToSaveRegions = true;
-				
-				// retry until we are able to read and write
-				// then wake up the fileWritingThreadPool
-				Thread retryReady = new Thread(() -> 
-				{
-					try
-					{
-						// check once every so often so see
-						// if anything has changed so we can
-						// start reading and writing files
-						while(!readyToReadAndWrite())
-						{
-							this.wait(1000);
-							// get the save handler again, if for some
-							// reason the original handler was null
-							saveHandler = Minecraft.getMinecraft().getIntegratedServer().getWorld(0).getSaveHandler();
-							save_dir = getWorldSaveDirectory();
-						}
-						
-						// we can start writing files now
-						fileWritingThreadPool.execute(saveDirtyRegionsThread);
-						waitingToSaveRegions = false;
-					}
-					catch (InterruptedException e) 
-					{ /* should never be called */}
-				});
-				
-				retryReady.run();
-			}
-			
-			return;
-		}
-		
-		fileWritingThreadPool.execute(saveDirtyRegionsThread);
-	}
-	private Thread saveDirtyRegionsThread = new Thread(() -> 
-	{
-		for(int i = 0; i < loadedRegion.getWidth(); i++)
-		{
-			for(int j = 0; j < loadedRegion.getWidth(); j++)
-			{
-				if(loadedRegion.isRegionDirty[i][j])
-				{
-					saveRegionToDisk(loadedRegion.regions[i][j]);
-					loadedRegion.isRegionDirty[i][j] = false;
-				}
-			}
-		}
-		
-		waitingToSaveRegions = false;
-	});
- 	
-	
-	private void saveRegionToDisk(LodRegion region)
-	{
-		if (!readyToReadAndWrite() || region == null)
-			return;
-		
-		// convert chunk coordinates to region
-		// coordinates
-		int x = region.x;
-		int z = region.z;
-		
-		File f = new File(getFileNameForRegion(x, z));
-		
-		try
-		{
-			// make sure the file and folder exists
-			if (!f.exists())
-				if(!f.getParentFile().exists())
-					f.getParentFile().mkdirs();
-				f.createNewFile();
-			
-			FileWriter fw = new FileWriter(f);
-			
-			for(LodChunk[] chunkArray : region.getAllLods())
-				for(LodChunk chunk : chunkArray)
-					if(chunk != null)
-						fw.write(chunk.toData() + "\n");
-			
-			fw.close();
-		}
-		catch(Exception e)
-		{
-			System.err.println("LOD file write error: " + e.getMessage());
-		}
-	}
-	
-	
- 	
-	
-	
-	
-	
-	//================//
-	// helper methods //
-	//================//
-	
-	
-	/**
-	 * Return the name of the file that should contain the 
-	 * region at the given x and z. <br>
-	 * Returns null if this object isn't ready to read and write.
-	 * @param regionX
-	 * @param regionZ
-	 */
-	private String getFileNameForRegion(int regionX, int regionZ)
-	{
-		if (!readyToReadAndWrite())
-			return null;
-		
-		return save_dir + "\\lod_data\\DIM" + loadedRegion.dimension.getId() + "\\" +
-				FILE_NAME_PREFIX + "." + regionX + "." + regionZ + FILE_EXTENSION;
-	}
-	
-	
-	/**
-	 * Returns if this FileHandler is ready to read
-	 * and write files.
-	 */
-	public boolean readyToReadAndWrite()
-	{
-		return saveHandler != null && saveHandler.getWorldDirectory() != null && 
-				save_dir != null && !save_dir.isEmpty();
-	}
-	
-	
-	
-	
-	/**
-	 * If on single player this will return the name of the user's
-	 * world, if in multiplayer it will return the server name
-	 * and game version.
-	 */
-	public static String getWorldName()
-	{
-		Minecraft mc = Minecraft.getMinecraft();
-		
-		if(mc.isIntegratedServerRunning())
-		{
-			return mc.getIntegratedServer().getWorldName();
-		}
-		else
-		{
-			return mc.getCurrentServerData().serverName + "_version_" + mc.getCurrentServerData().gameVersion;
-		}
-	}
-	
-	
-	
-	/**
-	 * Returns null if there was an IO Exception
-	 */
-	private String getWorldSaveDirectory()
-	{
-		try
-		{
-			return saveHandler.getWorldDirectory().getCanonicalPath();
-		}
-		catch (IOException e) 
-		{
-			return null;
-		}
-	}
-}
@@ -1,25 +0,0 @@
-package com.backsun.lod.util;
-
-/**
- * 
- * @author James Seibel
- * @version 04-16-2020
- */
-public class Reference
-{
-	/** the mod's identifier  */
-	public static final String MOD_ID = "lod";
-	/** the mod's name */
-	public static final String NAME = "LOD Mod";
-	/** the mod's version */
-	public static final String VERSION = "1.0";
-	/** the version of minecraft this mod is built for */
-	public static final String ACCEPTED_VERSIONS = "[1.12.2]";
-	
-	/** where the client proxy class is */
-	public static final String CLIENT_PROXY_CLASS = "com.backsun.lod.proxy.ClientProxy";
-	/** where the  common proxy class is*/
-	public static final String COMMON_PROXY_CLASS = "com.backsun.lod.proxy.CommonProxy";
-	
-	
-}
@@ -1,187 +0,0 @@
-package com.backsun.lod.util;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Parameter;
-
-import com.backsun.lod.util.enums.FogQuality;
-
-import net.minecraft.client.Minecraft;
-
-/**
- * This object is used to get variables from methods
- * where they are private.
- * 
- * @author James Seibel
- * @version 09-21-2020
- */
-public class ReflectionHandler
-{
-	public Method fovMethod = null;
-	public Field ofFogField = null;
-	
-	
-	public ReflectionHandler()
-	{
-		setupFovMethod();
-		setupFogField();
-	}
-	
-	
-	
-	
-	/**
-	 * This sets the "getFOVModifier" method from the 
-	 * minecraft "EntityRenderer" class, so that we can get
-	 * the FOV of the player at any time.
-	 * 
-	 * This is required since Minecraft is obfuscated so
-	 * we can't just look for 'getFOVModifier'
-	 * we have to search for it based on its parameters and
-	 * return type; which luckily are unique in the EntityRenderer
-	 * class.
-	 */
-	private void setupFovMethod()
-	{
-		// get every method from the entity renderer
-		Method[] methods = Minecraft.getMinecraft().entityRenderer.getClass().getDeclaredMethods();
-		
-		Class<?> returnType;
-		Parameter[] params;
-		Method returnMethod = null;
-		
-		for(Method m : methods)
-		{
-			returnType = m.getReturnType();
-			params = m.getParameters();
-			
-			// see if this method has the same return type
-			// and parameters as the 'getFOVModifier' method. 
-			if (returnType.equals(float.class) && 
-					params.length == 2 && 
-					params[0].getType().equals(float.class) &&
-					params[1].getType().equals(boolean.class))
-			{
-				
-				// only accept the first method that we find
-				if (returnMethod == null)
-				{
-					returnMethod = m;
-				}
-				else
-				{
-					// we found a second method that matches the 
-					// outline we were looking for,
-					// to prevent unexpected behavior 
-					// dont't set fovMethod.
-					
-					// Since we aren't sure that 
-					// this method is the right 
-					// one, we may accidently mess 
-					// up the entityRender by invoking
-					// it and we probably wouldn't get 
-					// the FOV from it anyway.
-					
-					System.err.println("Error: a second method that matches the parameters and return typ of 'getFOVModifier' was found, LODs won't be rendered.");
-					
-					return;
-				}
-			}
-		}
-		
-		// only set the method once we have gone through
-		// the whole array of methods, just to
-		// make sure we have the right one.
-		fovMethod = returnMethod;
-		// set up the method so we can invoke it later
-		fovMethod.setAccessible(true);
-	}
-	
-	/**
-	 * Similar to setupFovMethod.
-	 */
-	private void setupFogField()
-	{
-		// get every variable from the entity renderer
-		Field[] vars = Minecraft.getMinecraft().gameSettings.getClass().getDeclaredFields();
-				
-		// try and find the ofFogType variable in gameSettings
-		for(Field f : vars)
-		{
-			if(f.getName().equals("ofFogType"))
-			{
-				ofFogField = f;
-				return;
-			}
-		}
-		
-		// we didn't find the field,
-		// either optifine isn't installed, or
-		// optifine changed the name of the variable
-		ofFogField = null;
-	}
-	
-	
-	
-	
-	
-	/**
-	 * Get what type of fog optifine is currently set to render.
-	 */
-	public FogQuality getFogQuality()
-	{
-		if (ofFogField == null)
-		{
-			// either optifine isn't installed,
-			// the variable name was changed, or
-			// the setup method wasn't called yet.
-			return FogQuality.OFF;
-		}
-		
-		int returnNum = 0;
-		
-		try
-		{
-			returnNum = (int)ofFogField.get(Minecraft.getMinecraft().gameSettings);
-		}
-		catch (IllegalArgumentException | IllegalAccessException e)
-		{
-			e.printStackTrace();
-		}
-		
-		switch (returnNum)
-		{
-			case 0:
-				return FogQuality.FAST;
-			case 1:
-				return FogQuality.FAST;
-			case 2:
-				return FogQuality.FANCY;
-			case 3:
-				return FogQuality.OFF;
-				
-			default:
-				return FogQuality.FAST;
-		}
-	}
-	
-	
-	/**
-	 * Gets the FOV used by the EntityRender.
-	 */
-	public float getFov(Minecraft mc, float partialTicks, boolean useFovSetting)
-	{
-		try
-		{
-			return (float)fovMethod.invoke(mc.entityRenderer, new Object[]{partialTicks, useFovSetting});
-		}
-		catch(InvocationTargetException | IllegalAccessException | IllegalArgumentException e)
-		{
-			e.printStackTrace();
-		}
-		
-		return 0.0f;
-	}
-	
-}
@@ -1,34 +0,0 @@
-package com.backsun.lod.util.enums;
-
-/**
- * @author James Seibel
- * @version 10-17-2020
- * 
- * TOP, N, S, E, W, BOTTOM
- */
-public enum ColorDirection
-{
-	// used for colors
-	/** +Y */
-	TOP(0),
-	
-	/** -Z */
-	N(1),
-	/** +Z */
-	S(2),
-	
-	/** +X */
-	E(3),
-	/** -X */
-	W(4),
-	
-	/** -Y */
-	BOTTOM(5);
-	
-	public final int value;
-	
-	private ColorDirection(int newValue)
-	{
-		value = newValue;
-	}
-}
@@ -1,32 +0,0 @@
-package com.backsun.lod.util.enums;
-
-/**
- * @author James Seibel
- * @version 1-23-2021
- */
-public enum DrawMode
-{
-	/** Draw the LOD objects in groups.
-	 * <br>
-	 * <br>
-	 * Fancy fog: render the center and outside LOD
-	 * objects in 2 different groups.
-	 * <br>
-	 * Fast fog: render all LOD objects at one time. 
-	 */
-	BATCH(0),
-	
-	/** Draw each LOD objects separately.
-	 * <br>
-	 * <br>
-	 * Not suggested normally since draw calls are GPU expensive.
-	 */
-	INDIVIDUAL(5);
-	
-	public final int value;
-	
-	private DrawMode(int newValue)
-	{
-		value = newValue;
-	}
-}
@@ -1,17 +0,0 @@
-package com.backsun.lod.util.enums;
-
-/**
- * Near, far, or NEAR_AND_FAR.
- * 
- * @author James Seibel
- * @version 02-14-2021
- */
-public enum FogDistance
-{
-	/** valid for both fast and fancy fog qualities. */
-	NEAR,
-	/** valid for both fast and fancy fog qualities. */
-	FAR,
-	/** only looks good if the fog quality is set to Fancy. */
-	NEAR_AND_FAR;
-}
@@ -1,14 +0,0 @@
-package com.backsun.lod.util.enums;
-
-/**
- * fast, fancy, or off
- * 
- * @author James Seibel
- * @version 02-14-2021
- */
-public enum FogQuality
-{
-	FAST,
-	FANCY,
-	OFF;
-}
@@ -1,29 +0,0 @@
-package com.backsun.lod.util.enums;
-
-/**
- * 
- * @author James Seibel
- * @version 1-20-2020
- * 
- * NE, SE, SW, NW
- */
-public enum LodLocation
-{
-	// used for position
-	
-	/** -Z, +X */
-	NE(0),
-	/** +Z, +X */
-	SE(1),
-	/** +Z, -X */
-	SW(2),
-	/** -Z, -X */
-	NW(3);
-	
-	public final int value;
-	
-	private LodLocation(int newValue)
-	{
-		value = newValue;
-	}
-}
@@ -0,0 +1,80 @@
+/*
+ *    This file is part of 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;
+
+import com.seibel.lod.config.LodConfig;
+import com.seibel.lod.proxy.ClientProxy;
+
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.ModLoadingContext;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.config.ModConfig;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
+import net.minecraftforge.fml.event.server.FMLServerStartingEvent;
+import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+
+/**
+ * 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 7-3-2021
+ */
+@Mod(ModInfo.MODID)
+public class LodMain
+{
+	public static LodMain instance;
+	
+	public static ClientProxy client_proxy;
+	
+	
+	private void init(final FMLCommonSetupEvent event)
+	{
+		ModLoadingContext.get().registerConfig(ModConfig.Type.CLIENT, LodConfig.CLIENT_SPEC);
+	}
+	
+	
+    public LodMain()
+    {
+        // 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)
+    {
+    	client_proxy = new ClientProxy();
+		MinecraftForge.EVENT_BUS.register(client_proxy);
+    }
+    
+    
+    
+    @SubscribeEvent
+    public void onServerStarting(FMLServerStartingEvent event)
+    {
+        // this is called when the server starts
+    }
+    
+}
@@ -0,0 +1,32 @@
+/*
+ *    This file is part of 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;
+
+/**
+ * This file is similar to mcmod.info
+ * 
+ * @author James Seibel
+ * @version 08-29-2021
+ */
+public final class ModInfo
+{	
+	public static final String MODID = "lod";
+	public static final String MODNAME = "LOD";
+	public static final String MODAPI = "LodAPI";
+	public static final String VERSION = "a1.4";
+}
@@ -0,0 +1,28 @@
+package com.seibel.lod.builders;
+
+import com.seibel.lod.enums.DistanceGenerationMode;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+import com.seibel.lod.util.LodUtil;
+import net.minecraft.util.math.ChunkPos;
+
+/**
+ * @author Leonardo Amato
+ * @version 22-08-2021
+ */
+public class GenerationRequest
+{
+	public final LevelPos levelPos;
+	public final DistanceGenerationMode generationMode;
+
+	public GenerationRequest(LevelPos levelPos, DistanceGenerationMode generationMode)
+	{
+		this.levelPos = levelPos;
+		this.generationMode = generationMode;
+	}
+
+	public ChunkPos getChunkPos()
+	{
+		LevelPos chunkLevelPos = levelPos.getConvertedLevelPos(LodUtil.CHUNK_DETAIL_LEVEL);
+		return new ChunkPos(chunkLevelPos.posX, chunkLevelPos.posZ);
+	}
+}
@@ -0,0 +1,603 @@
+/*
+ *    This file is part of 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.builders;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.apache.commons.lang3.mutable.MutableBoolean;
+import org.lwjgl.opengl.GL11;
+
+import com.seibel.lod.config.LodConfig;
+import com.seibel.lod.objects.LodDimension;
+import com.seibel.lod.objects.RegionPos;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+import com.seibel.lod.proxy.ClientProxy;
+import com.seibel.lod.render.LodRenderer;
+import com.seibel.lod.util.LodThreadFactory;
+import com.seibel.lod.util.LodUtil;
+
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.vertex.VertexBuffer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.ChunkPos;
+
+
+/**
+ * This object is used to create NearFarBuffer objects.
+ *
+ * @author James Seibel
+ * @version 8-24-2021
+ */
+public class LodBufferBuilder
+{
+	/**
+	 * This holds the thread used to generate new LODs off the main thread.
+	 */
+	private ExecutorService mainGenThread = Executors.newSingleThreadExecutor(new LodThreadFactory(this.getClass().getSimpleName() + " - main"));
+	/**
+	 * This holds the threads used to generate buffers.
+	 */
+	private ExecutorService bufferBuilderThreads = Executors.newFixedThreadPool(LodConfig.CLIENT.threading.numberOfBufferBuilderThreads.get(), new LodThreadFactory(this.getClass().getSimpleName() + " - builder"));
+
+	/**
+	 * The buffers that are used to create LODs using far fog
+	 */
+	public volatile BufferBuilder[][] buildableBuffers;
+
+	/**
+	 * Used when building new VBOs
+	 */
+	public volatile VertexBuffer[][] buildableVbos;
+
+	/**
+	 * VBOs that are sent over to the LodNodeRenderer
+	 */
+	public volatile VertexBuffer[][] drawableVbos;
+
+	/**
+	 * if this is true the LOD buffers are currently being
+	 * regenerated.
+	 */
+	public boolean generatingBuffers = false;
+
+	/**
+	 * if this is true new LOD buffers have been generated
+	 * and are waiting to be swapped with the drawable buffers
+	 */
+	private boolean switchVbos = false;
+
+
+	/**
+	 * Size of the buffer builders in bytes last time we created them
+	 */
+	public int previousBufferSize = 0;
+
+	/**
+	 * Width of the dimension in regions last time we created the buffers
+	 */
+	public int previousRegionWidth = 0;
+
+	/**
+	 * this is used to prevent multiple threads creating, destroying, or using the buffers at the same time
+	 */
+	private ReentrantLock bufferLock = new ReentrantLock();
+
+	private volatile Object[][] setsToRender;
+	private volatile RegionPos center;
+
+	public LodBufferBuilder()
+	{
+
+	}
+
+
+	/**
+	 * Create a thread to asynchronously generate LOD buffers
+	 * centered around the given camera X and Z.
+	 * <br>
+	 * This method will write to the drawable near and far buffers.
+	 * <br>
+	 * After the buildable buffers have been generated they must be
+	 * swapped with the drawable buffers in the LodRenderer to be drawn.
+	 */
+	public void generateLodBuffersAsync(LodRenderer renderer, LodDimension lodDim,
+	                                    BlockPos playerBlockPos, boolean fullRegen)
+	{
+		// only allow one generation process to happen at a time
+		if (generatingBuffers)
+			return;
+
+		if (buildableBuffers == null)
+			// setupBuffers hasn't been called yet
+			return;
+
+
+		generatingBuffers = true;
+
+
+		// round the player's block position down to the nearest chunk BlockPos
+		ChunkPos playerChunkPos = new ChunkPos(playerBlockPos);
+		BlockPos playerBlockPosRounded = playerChunkPos.getWorldPosition();
+
+
+		Thread thread = new Thread(() ->
+		{
+			bufferLock.lock();
+
+
+			try
+			{
+				long treeStart = System.currentTimeMillis();
+				long treeEnd = System.currentTimeMillis();
+
+				long startTime = System.currentTimeMillis();
+
+
+				ArrayList<Callable<Boolean>> nodeToRenderThreads = new ArrayList<>(lodDim.regions.length * lodDim.regions.length);
+
+				startBuffers(fullRegen, lodDim);
+
+				// =====================//
+				//    RENDERING PART    //
+				// =====================//
+
+				RegionPos playerRegionPos = new RegionPos(playerChunkPos);
+				if (center == null)
+					center = playerRegionPos;
+
+				if (setsToRender == null)
+					setsToRender = new Object[lodDim.regions.length][lodDim.regions.length];
+
+				if (setsToRender.length != lodDim.regions.length)
+					setsToRender = new Object[lodDim.regions.length][lodDim.regions.length];
+
+
+				RegionPos worldRegionOffset = new RegionPos(playerRegionPos.x - lodDim.getCenterX(), playerRegionPos.z - lodDim.getCenterZ());
+				if (worldRegionOffset.x != 0 || worldRegionOffset.z != 0)
+				{
+					move(worldRegionOffset, Math.floorDiv(lodDim.getWidth(), 2));
+				}
+
+				for (int xRegion = 0; xRegion < lodDim.regions.length; xRegion++)
+				{
+					for (int zRegion = 0; zRegion < lodDim.regions.length; zRegion++)
+					{
+						if (lodDim.regen[xRegion][zRegion] || fullRegen)
+						{
+							RegionPos regionPos = new RegionPos(
+									xRegion + lodDim.getCenterX() - Math.floorDiv(lodDim.getWidth(), 2),
+									zRegion + lodDim.getCenterZ() - Math.floorDiv(lodDim.getWidth(), 2));
+
+							// local position in the vbo and bufferBuilder arrays
+							BufferBuilder currentBuffer = buildableBuffers[xRegion][zRegion];
+
+							// make sure the buffers weren't
+							// changed while we were running this method
+							if (currentBuffer == null || (currentBuffer != null && !currentBuffer.building()))
+								return;
+
+							//previous setToRender chache
+							if (setsToRender[xRegion][zRegion] == null)
+							{
+								setsToRender[xRegion][zRegion] = new ConcurrentHashMap<LevelPos, MutableBoolean>();
+							}
+							ConcurrentMap<LevelPos, MutableBoolean> nodeToRender = (ConcurrentMap<LevelPos, MutableBoolean>) setsToRender[xRegion][zRegion];
+							Callable<Boolean> dataToRenderThread = () ->
+							{
+								lodDim.getDataToRender(
+										nodeToRender,
+										regionPos,
+										playerBlockPosRounded.getX(),
+										playerBlockPosRounded.getZ());
+
+								int posX;
+								int posZ;
+								byte detailLevel;
+								int chunkXdist;
+								int chunkZdist;
+								short gameChunkRenderDistance = (short) (renderer.vanillaRenderedChunks.length/2 - 1);
+								for (LevelPos posToRender : nodeToRender.keySet())
+								{
+									if (!nodeToRender.get(posToRender).booleanValue())
+									{
+										nodeToRender.remove(posToRender);
+										continue;
+									}
+									nodeToRender.get(posToRender).setFalse();
+									// skip any chunks that Minecraft is going to render
+									chunkXdist = posToRender.getChunkPosX() - playerChunkPos.x;
+									chunkZdist = posToRender.getChunkPosZ() - playerChunkPos.z;
+									if(gameChunkRenderDistance >= Math.abs(chunkXdist) && gameChunkRenderDistance >=  Math.abs(chunkZdist) && posToRender.detailLevel <= LodUtil.CHUNK_DETAIL_LEVEL)
+									{
+										if (renderer.vanillaRenderedChunks[chunkXdist + gameChunkRenderDistance  + 1][chunkZdist + gameChunkRenderDistance + 1])
+										{
+											continue;
+										}
+									}
+									posX = posToRender.posX;
+									posZ = posToRender.posZ;
+									detailLevel = posToRender.detailLevel;
+									// skip any chunks that Minecraft is going to render
+
+
+									try
+									{
+										boolean disableFix = false;
+										if (lodDim.doesDataExist(posToRender.clone()))
+										{
+											short[] lodData = lodDim.getData(posToRender);
+											short[][][] adjData = new short[2][2][];
+											/**TODO The following two for are too complex*/
+											for (int x : new int[]{0, 1})
+											{
+												posToRender.changeParameters(detailLevel, posX + x * 2 - 1, posZ);
+												chunkXdist = posToRender.getChunkPosX() - playerChunkPos.x;
+												chunkZdist = posToRender.getChunkPosZ() - playerChunkPos.z;
+												if(gameChunkRenderDistance >= Math.abs(chunkXdist) && gameChunkRenderDistance >=  Math.abs(chunkZdist))
+												{
+													if (!renderer.vanillaRenderedChunks[chunkXdist + gameChunkRenderDistance + 1][chunkZdist + gameChunkRenderDistance + 1]
+													&& (nodeToRender.containsKey(posToRender) || disableFix))
+													{
+														adjData[0][x] = lodDim.getData(posToRender);
+													}
+												}else{
+													if (nodeToRender.containsKey(posToRender) || disableFix)
+													{
+														adjData[0][x] = lodDim.getData(posToRender);
+
+													}
+												}
+											}
+
+											for (int z : new int[]{0, 1})
+											{
+												posToRender.changeParameters(detailLevel, posX, posZ + z * 2 - 1);
+												chunkXdist = posToRender.getChunkPosX() - playerChunkPos.x;
+												chunkZdist = posToRender.getChunkPosZ() - playerChunkPos.z;
+												if(gameChunkRenderDistance >= Math.abs(chunkXdist) && gameChunkRenderDistance >=  Math.abs(chunkZdist))
+												{
+													if (!renderer.vanillaRenderedChunks[chunkXdist + gameChunkRenderDistance + 1][chunkZdist + gameChunkRenderDistance+ 1]
+															    && (nodeToRender.containsKey(posToRender) || disableFix))
+													{
+														adjData[1][z] = lodDim.getData(posToRender);
+													}
+												}else{
+													if (nodeToRender.containsKey(posToRender) || disableFix)
+													{
+														adjData[1][z] = lodDim.getData(posToRender);
+
+													}
+												}
+											}
+											posToRender.changeParameters(detailLevel, posX, posZ);
+
+											LodConfig.CLIENT.graphics.lodTemplate.get().template.addLodToBuffer(currentBuffer, playerBlockPos, lodData, adjData,
+													posToRender, renderer.previousDebugMode);
+										}
+									} catch (ArrayIndexOutOfBoundsException e)
+									{
+										return false;
+									}
+
+								}// for pos to in list to render
+
+								// the thread executed successfully
+								return true;
+							};
+							nodeToRenderThreads.add(dataToRenderThread);
+						}
+					}// region z
+				}// region z
+				long renderStart = System.currentTimeMillis();
+				// wait for all threads to finish
+				List<Future<Boolean>> futuresBuffer = bufferBuilderThreads.invokeAll(nodeToRenderThreads);
+				for (Future<Boolean> future : futuresBuffer)
+				{
+					// the future will be false if its thread failed
+					if (!future.get())
+					{
+						ClientProxy.LOGGER.warn("LodBufferBuilder ran into trouble and had to start over.");
+						closeBuffers(fullRegen, lodDim);
+						return;
+					}
+				}
+				long renderEnd = System.currentTimeMillis();
+
+
+				long endTime = System.currentTimeMillis();
+				@SuppressWarnings("unused")
+				long buildTime = endTime - startTime;
+				@SuppressWarnings("unused")
+				long treeTime = treeEnd - treeStart;
+				@SuppressWarnings("unused")
+				long renderingTime = renderEnd - renderStart;
+
+//				ClientProxy.LOGGER.info("Buffer Build time: " + buildTime + " ms" + '\n' +
+//						                        "Tree cutting time: " + treeTime + " ms" + '\n' +
+//						                        "Rendering time: " + renderingTime + " ms");
+
+				// mark that the buildable buffers as ready to swap
+				switchVbos = true;
+			} catch (Exception e)
+			{
+				ClientProxy.LOGGER.warn("\"LodNodeBufferBuilder.generateLodBuffersAsync\" ran into trouble: ");
+				e.printStackTrace();
+			} finally
+			{
+				// regardless of if we successfully created the buffers
+				// we are done generating.
+				generatingBuffers = false;
+
+				// clean up any potentially open resources
+				if (buildableBuffers != null)
+					closeBuffers(fullRegen, lodDim);
+
+				// upload the new buffers
+				uploadBuffers(fullRegen, lodDim);
+				bufferLock.unlock();
+			}
+
+		});
+
+		mainGenThread.execute(thread);
+
+		return;
+	}
+
+
+	/**
+	 * Move the center of this LodDimension and move all owned
+	 * regions over by the given x and z offset. <br><br>
+	 * <p>
+	 * Synchronized to prevent multiple moves happening on top of each other.
+	 */
+	public void move(RegionPos regionOffset, int width)
+	{
+		int xOffset = regionOffset.x;
+		int zOffset = regionOffset.z;
+
+		// if the x or z offset is equal to or greater than
+		// the total size, just delete the current data
+		// and update the centerX and/or centerZ
+		if (Math.abs(xOffset) >= width || Math.abs(zOffset) >= width)
+		{
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					setsToRender[x][z] = null;
+				}
+			}
+
+			// update the new center
+			center.x += xOffset;
+			center.z += zOffset;
+
+			return;
+		}
+
+
+		// X
+		if (xOffset > 0)
+		{
+			// move everything over to the left (as the center moves to the right)
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					if (x + xOffset < width)
+						setsToRender[x][z] = setsToRender[x + xOffset][z];
+					else
+						setsToRender[x][z] = null;
+				}
+			}
+		} else
+		{
+			// move everything over to the right (as the center moves to the left)
+			for (int x = width - 1; x >= 0; x--)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					if (x + xOffset >= 0)
+						setsToRender[x][z] = setsToRender[x + xOffset][z];
+					else
+						setsToRender[x][z] = null;
+				}
+			}
+		}
+
+
+		// Z
+		if (zOffset > 0)
+		{
+			// move everything up (as the center moves down)
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					if (z + zOffset < width)
+						setsToRender[x][z] = setsToRender[x][z + zOffset];
+					else
+						setsToRender[x][z] = null;
+				}
+			}
+		} else
+		{
+			// move everything down (as the center moves up)
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = width - 1; z >= 0; z--)
+				{
+					if (z + zOffset >= 0)
+						setsToRender[x][z] = setsToRender[x][z + zOffset];
+					else
+						setsToRender[x][z] = null;
+				}
+			}
+		}
+
+
+		// update the new center
+		center.x += xOffset;
+		center.z += zOffset;
+	}
+
+	//===============================//
+	// BufferBuilder related methods //
+	//===============================//
+
+
+	/**
+	 * Called from the LodRenderer to create the
+	 * BufferBuilders. <br><br>
+	 * <p>
+	 * May have to wait for the bufferLock to open.
+	 */
+	public void setupBuffers(int numbRegionsWide, int bufferMaxCapacity)
+	{
+		bufferLock.lock();
+
+		previousRegionWidth = numbRegionsWide;
+		previousBufferSize = bufferMaxCapacity;
+
+
+		buildableBuffers = new BufferBuilder[numbRegionsWide][numbRegionsWide];
+
+		buildableVbos = new VertexBuffer[numbRegionsWide][numbRegionsWide];
+		drawableVbos = new VertexBuffer[numbRegionsWide][numbRegionsWide];
+
+		for (int x = 0; x < numbRegionsWide; x++)
+		{
+			for (int z = 0; z < numbRegionsWide; z++)
+			{
+				buildableBuffers[x][z] = new BufferBuilder(bufferMaxCapacity);
+				buildableVbos[x][z] = new VertexBuffer(LodRenderer.LOD_VERTEX_FORMAT);
+				drawableVbos[x][z] = new VertexBuffer(LodRenderer.LOD_VERTEX_FORMAT);
+			}
+		}
+
+		bufferLock.unlock();
+	}
+
+	/**
+	 * sets the buffers and Vbos to null, forcing them to be recreated. <br><br>
+	 * <p>
+	 * May have to wait for the bufferLock to open.
+	 */
+	public void destroyBuffers()
+	{
+		bufferLock.lock();
+
+		buildableBuffers = null;
+		buildableVbos = null;
+		drawableVbos = null;
+
+		bufferLock.unlock();
+	}
+
+
+	/**
+	 * Calls begin on each of the buildable BufferBuilders.
+	 */
+	private void startBuffers(boolean fullRegen, LodDimension lodDim)
+	{
+		for (int x = 0; x < buildableBuffers.length; x++)
+			for (int z = 0; z < buildableBuffers.length; z++)
+			{
+				if (fullRegen || lodDim.regen[x][z])
+				{
+					buildableBuffers[x][z].begin(GL11.GL_QUADS, LodRenderer.LOD_VERTEX_FORMAT);
+				}
+			}
+	}
+
+	/**
+	 * Calls end on each of the buildable BufferBuilders.
+	 */
+	private void closeBuffers(boolean fullRegen, LodDimension lodDim)
+	{
+		for (int x = 0; x < buildableBuffers.length; x++)
+			for (int z = 0; z < buildableBuffers.length; z++)
+
+				if (buildableBuffers[x][z] != null && buildableBuffers[x][z].building() && (fullRegen || lodDim.regen[x][z]))
+				{
+					buildableBuffers[x][z].end();
+				}
+	}
+
+	/**
+	 * Called from the LodRenderer to create the
+	 * BufferBuilders at the right size.
+	 */
+	private void uploadBuffers(boolean fullRegen, LodDimension lodDim)
+	{
+		for (int x = 0; x < buildableVbos.length; x++)
+		{
+			for (int z = 0; z < buildableVbos.length; z++)
+			{
+				if (fullRegen || lodDim.regen[x][z])
+				{
+					buildableVbos[x][z].upload(buildableBuffers[x][z]);
+					lodDim.regen[x][z] = false;
+				}
+			}
+		}
+	}
+
+
+	/**
+	 * Get the newly created VBOs
+	 */
+	public VertexBuffer[][] getVertexBuffers()
+	{
+		// don't wait for the lock to open
+		// since this is called on the main render thread
+		if (bufferLock.tryLock())
+		{
+			VertexBuffer[][] tmp = drawableVbos;
+			drawableVbos = buildableVbos;
+			buildableVbos = tmp;
+
+			// the vbos have been swapped
+			switchVbos = false;
+			bufferLock.unlock();
+		}
+
+		return drawableVbos;
+	}
+
+	/**
+	 * If this is true the buildable near and far
+	 * buffers have been generated and are ready to be
+	 * sent to the LodRenderer.
+	 */
+	public boolean newBuffersAvaliable()
+	{
+		return switchVbos;
+	}
+
+
+}
@@ -0,0 +1,570 @@
+/*
+ *    This file is part of 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.builders;
+
+import java.awt.Color;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import com.seibel.lod.config.LodConfig;
+import com.seibel.lod.enums.DistanceGenerationMode;
+import com.seibel.lod.enums.LodDetail;
+import com.seibel.lod.objects.DataPoint;
+import com.seibel.lod.objects.LodDimension;
+import com.seibel.lod.objects.LodWorld;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+import com.seibel.lod.util.ColorUtil;
+import com.seibel.lod.util.DetailDistanceUtil;
+import com.seibel.lod.util.LodThreadFactory;
+import com.seibel.lod.util.LodUtil;
+
+import net.minecraft.block.AbstractPlantBlock;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.BushBlock;
+import net.minecraft.block.GrassBlock;
+import net.minecraft.block.IGrowable;
+import net.minecraft.block.LeavesBlock;
+import net.minecraft.block.material.MaterialColor;
+import net.minecraft.client.Minecraft;
+import net.minecraft.world.DimensionType;
+import net.minecraft.world.IWorld;
+import net.minecraft.world.biome.Biome;
+import net.minecraft.world.chunk.ChunkSection;
+import net.minecraft.world.chunk.IChunk;
+import net.minecraft.world.gen.Heightmap;
+
+/**
+ * This object is in charge of creating Lod related objects. (specifically: Lod
+ * World, Dimension, and Region objects)
+ *
+ * @author Leonardo Amato
+ * @author James Seibel
+ * @version 8-29-2021
+ */
+public class LodBuilder
+{
+	private ExecutorService lodGenThreadPool = Executors.newSingleThreadExecutor(new LodThreadFactory(this.getClass().getSimpleName()));
+
+	public static final int CHUNK_DATA_WIDTH = LodUtil.CHUNK_WIDTH;
+	public static final int CHUNK_SECTION_HEIGHT = CHUNK_DATA_WIDTH;
+	public static final Heightmap.Type DEFAULT_HEIGHTMAP = Heightmap.Type.WORLD_SURFACE_WG;
+
+	/**
+	 * If no blocks are found in the area in determineBottomPointForArea return this
+	 */
+	public static final short DEFAULT_DEPTH = -1;
+	/**
+	 * If no blocks are found in the area in determineHeightPointForArea return this
+	 */
+	public static final short DEFAULT_HEIGHT = -1;
+
+	/**
+	 * How wide LodDimensions should be in regions
+	 */
+	public int defaultDimensionWidthInRegions = 5;
+
+	public LodBuilder()
+	{
+
+	}
+
+	public void generateLodNodeAsync(IChunk chunk, LodWorld lodWorld, IWorld world)
+	{
+		generateLodNodeAsync(chunk, lodWorld, world, DistanceGenerationMode.SERVER);
+	}
+
+
+	public void generateLodNodeAsync(IChunk chunk, LodWorld lodWorld, IWorld world, DistanceGenerationMode generationMode)
+	{
+		if (lodWorld == null || !lodWorld.getIsWorldLoaded())
+			return;
+
+		// don't try to create an LOD object
+		// if for some reason we aren't
+		// given a valid chunk object
+		if (chunk == null)
+			return;
+
+		Thread thread = new Thread(() ->
+		{
+			try
+			{
+				DimensionType dim = world.dimensionType();
+
+				LodDimension lodDim;
+
+				int playerPosX;
+				int playerPosZ;
+				if (Minecraft.getInstance().player == null)
+				{
+					playerPosX = chunk.getPos().getMinBlockX();
+					playerPosZ = chunk.getPos().getMinBlockZ();
+				} else
+				{
+					playerPosX = (int) world.players().get(0).getX();
+					playerPosZ = (int) world.players().get(0).getZ();
+				}
+				if (lodWorld.getLodDimension(dim) == null)
+				{
+					lodDim = new LodDimension(dim, lodWorld, defaultDimensionWidthInRegions);
+					lodWorld.addLodDimension(lodDim);
+					lodDim.treeGenerator(playerPosX, playerPosZ);
+				} else
+				{
+					lodDim = lodWorld.getLodDimension(dim);
+				}
+				generateLodNodeFromChunk(lodDim, chunk, new LodBuilderConfig(generationMode));
+			} catch (IllegalArgumentException | NullPointerException e)
+			{
+				System.out.println("Chunk pos " + chunk.getPos());
+				e.printStackTrace();
+				// if the world changes while LODs are being generated
+				// they will throw errors as they try to access things that no longer
+				// exist.
+			}
+		});
+		lodGenThreadPool.execute(thread);
+
+		return;
+	}
+
+	/**
+	 * Creates a LodChunk for a chunk in the given world.
+	 *
+	 * @throws IllegalArgumentException thrown if either the chunk or world is null.
+	 */
+	public void generateLodNodeFromChunk(LodDimension lodDim, IChunk chunk) throws IllegalArgumentException
+	{
+		generateLodNodeFromChunk(lodDim, chunk, new LodBuilderConfig());
+	}
+
+	/**
+	 * Creates a LodChunk for a chunk in the given world.
+	 *
+	 * @throws IllegalArgumentException thrown if either the chunk or world is null.
+	 */
+	public void generateLodNodeFromChunk(LodDimension lodDim, IChunk chunk, LodBuilderConfig config)
+			throws IllegalArgumentException
+	{
+
+		if (chunk == null)
+			throw new IllegalArgumentException("generateLodFromChunk given a null chunk");
+
+		int startX;
+		int startZ;
+		int endX;
+		int endZ;
+		short[] color;
+		short height;
+		short depth;
+		short[] data;
+		LevelPos levelPos = new LevelPos((byte) 0, 0, 0);
+		levelPos.changeParameters(LodUtil.CHUNK_DETAIL_LEVEL, chunk.getPos().x, chunk.getPos().z);
+		levelPos.convert(LodUtil.REGION_DETAIL_LEVEL);
+		try
+		{
+			byte minDetailLevel = lodDim.getRegion(levelPos).getMinDetailLevel();
+			LodDetail detail = DetailDistanceUtil.getLodGenDetail(minDetailLevel);
+			for (int i = 0; i < detail.dataPointLengthCount * detail.dataPointLengthCount; i++)
+			{
+				startX = detail.startX[i];
+				startZ = detail.startZ[i];
+				endX = detail.endX[i];
+				endZ = detail.endZ[i];
+
+				color = generateLodColorForArea(chunk, config, startX, startZ, endX, endZ);
+
+				if (!config.useHeightmap)
+				{
+					height = determineHeightPointForArea(chunk.getSections(), startX, startZ, endX, endZ);
+					depth = determineBottomPointForArea(chunk.getSections(), startX, startZ, endX, endZ);
+				} else
+				{
+					height = determineHeightPoint(chunk.getOrCreateHeightmapUnprimed(LodUtil.DEFAULT_HEIGHTMAP), startX,
+							startZ, endX, endZ);
+					depth = 0;
+				}
+				levelPos.changeParameters((byte) 0,
+						chunk.getPos().x * 16 + startX,
+						chunk.getPos().z * 16 + startZ);
+				levelPos.convert(detail.detailLevel);
+				boolean isServer = config.distanceGenerationMode == DistanceGenerationMode.SERVER;
+				data = DataPoint.createDataPoint(height, depth, color[0], color[1], color[2]);
+				lodDim.addData(levelPos,
+						data,
+						false,
+						isServer);
+			}
+			levelPos.changeParameters(LodUtil.CHUNK_DETAIL_LEVEL, chunk.getPos().x, chunk.getPos().z);
+			lodDim.updateData(levelPos);
+		} catch (Exception e)
+		{
+			//e.printStackTrace();
+		}
+	}
+
+
+	// =====================//
+	// constructor helpers //
+	// =====================//
+
+	/**
+	 * Find the lowest valid point from the bottom.
+	 */
+	private short determineBottomPointForArea(ChunkSection[] chunkSections, int startX, int startZ, int endX, int endZ)
+	{
+		int numberOfBlocksRequired = ((endX - startX) * (endZ - startZ) / 2);
+
+		// search from the bottom up
+		for (int section = 0; section < CHUNK_DATA_WIDTH; section++)
+		{
+			for (int y = 0; y < CHUNK_SECTION_HEIGHT; y++)
+			{
+				int numberOfBlocksFound = 0;
+
+				for (int x = startX; x < endX; x++)
+				{
+					for (int z = startZ; z < endZ; z++)
+					{
+						if (isLayerValidLodPoint(chunkSections, section, y, x, z))
+						{
+							numberOfBlocksFound++;
+
+							if (numberOfBlocksFound >= numberOfBlocksRequired)
+							{
+								// we found
+								// enough blocks in this
+								// layer to count as an
+								// LOD point
+								return (short) (y + (section * CHUNK_SECTION_HEIGHT));
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// we never found a valid LOD point
+		return DEFAULT_DEPTH;
+	}
+
+
+	/**
+	 * Find the lowest valid point from the bottom.
+	 */
+	@SuppressWarnings("unused")
+	private short determineBottomPoint(Heightmap heightmap)
+	{
+		// the heightmap only shows how high the blocks go, it
+		// doesn't have any info about how low they go
+		return 0;
+	}
+
+	/**
+	 * Find the highest valid point from the Top
+	 */
+	private short determineHeightPointForArea(ChunkSection[] chunkSections, int startX, int startZ, int endX, int endZ)
+	{
+		int numberOfBlocksRequired = ((endX - startX) * (endZ - startZ) / 2);
+		// search from the top down
+		for (int section = chunkSections.length - 1; section >= 0; section--)
+		{
+			for (int y = CHUNK_DATA_WIDTH - 1; y >= 0; y--)
+			{
+				int numberOfBlocksFound = 0;
+
+				for (int x = startX; x < endX; x++)
+				{
+					for (int z = startZ; z < endZ; z++)
+					{
+						if (isLayerValidLodPoint(chunkSections, section, y, x, z))
+						{
+							numberOfBlocksFound++;
+
+							if (numberOfBlocksFound >= numberOfBlocksRequired)
+							{
+								// we found
+								// enough blocks in this
+								// layer to count as an
+								// LOD point
+								return (short) (y + 1 + (section * CHUNK_SECTION_HEIGHT));
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// we never found a valid LOD point
+		return DEFAULT_HEIGHT;
+	}
+
+
+	/**
+	 * Find the highest point from the Top
+	 */
+	private short determineHeightPoint(Heightmap heightmap, int startX, int startZ, int endX, int endZ)
+	{
+		short highest = 0;
+		for (int x = startX; x < endX; x++)
+		{
+			for (int z = startZ; z < endZ; z++)
+			{
+				short newHeight = (short) heightmap.getFirstAvailable(x, z);
+				if (newHeight > highest)
+					highest = newHeight;
+			}
+		}
+
+		return highest;
+	}
+
+	/**
+	 * Generate the color for the given chunk using biome water color, foliage
+	 * color, and grass color.
+	 *
+	 * @param config_useSolidBlocksInColorGen <br>
+	 *                                        If true we look down from the top of
+	 *                                        the <br>
+	 *                                        chunk until we find a non-invisible
+	 *                                        block, and then use <br>
+	 *                                        its color. If false we generate the
+	 *                                        color immediately for <br>
+	 *                                        each x and z.
+	 * @param config_useBiomeColors           <br>
+	 *                                        If true use biome foliage, water, and
+	 *                                        grass colors, <br>
+	 *                                        otherwise only use the block's
+	 *                                        material color
+	 */
+	private short[] generateLodColorForArea(IChunk chunk, LodBuilderConfig config, int startX, int startZ, int endX,
+	                                        int endZ)
+	{
+		ChunkSection[] chunkSections = chunk.getSections();
+
+		int numbOfBlocks = 0;
+		int red = 0;
+		int green = 0;
+		int blue = 0;
+
+		for (int x = startX; x < endX; x++)
+		{
+			for (int z = startZ; z < endZ; z++)
+			{
+				boolean foundBlock = false;
+
+				// go top down
+				for (int i = chunkSections.length - 1; !foundBlock && i >= 0; i--)
+				{
+					if (!foundBlock && (chunkSections[i] != null || !config.useSolidBlocksInColorGen))
+					{
+						for (int y = CHUNK_SECTION_HEIGHT - 1; !foundBlock && y >= 0; y--)
+						{
+							int colorInt = 0;
+							BlockState blockState = null;
+
+							if (chunkSections[i] != null)
+							{
+								blockState = chunkSections[i].getBlockState(x, y, z);
+								colorInt = blockState.materialColor.col;
+							}
+
+							if (colorInt == 0 && config.useSolidBlocksInColorGen)
+							{
+								// skip air or invisible blocks
+								continue;
+							}
+
+							if (config.useBiomeColors)
+							{
+								// I have no idea why I need to bit shift to the right, but
+								// if I don't the biomes don't show up correctly.
+								Biome biome = chunk.getBiomes().getNoiseBiome(x >> 2, y + 1 * chunkSections.length >> 2,
+										z >> 2);
+								colorInt = getColorForBiome(x, z, biome);
+							} else
+							{
+
+								// the bit shift is equivalent to dividing by 4
+								Biome biome = chunk.getBiomes().getNoiseBiome(x >> 2, y + i * chunkSections.length >> 2,
+										z >> 2);
+								colorInt = getColorForBlock(x, z, blockState, biome);
+							}
+
+							red += ColorUtil.getRed(colorInt);
+							green += ColorUtil.getGreen(colorInt);
+							blue += ColorUtil.getBlue(colorInt);
+
+							numbOfBlocks++;
+
+							// we found a valid block, skip to the
+							// next x and z
+							foundBlock = true;
+						}
+					}
+				}
+			}
+		}
+
+		if (numbOfBlocks == 0)
+			numbOfBlocks = 1;
+
+		red /= numbOfBlocks;
+		green /= numbOfBlocks;
+		blue /= numbOfBlocks;
+
+		return new short[]{(short) red, (short) green, (short) blue};
+	}
+
+	/**
+	 * Returns a color int for the given block.
+	 */
+	private int getColorForBlock(int x, int z, BlockState blockState, Biome biome)
+	{
+		int colorInt = 0;
+
+		// block special cases
+		if (blockState == Blocks.AIR.defaultBlockState() || blockState == Blocks.CAVE_AIR.defaultBlockState())
+		{
+			Color tmp = LodUtil.intToColor(biome.getGrassColor(x, z));
+			tmp = tmp.darker();
+			colorInt = LodUtil.colorToInt(tmp);
+		} else if (blockState == Blocks.STONE.defaultBlockState())
+		{
+			colorInt = LodUtil.STONE_COLOR_INT;
+		} else if (blockState == Blocks.MYCELIUM.defaultBlockState())
+		{
+			colorInt = LodUtil.MYCELIUM_COLOR_INT;
+		}
+
+		// plant life
+		else if (blockState.getBlock() instanceof LeavesBlock || blockState.getBlock() == Blocks.VINE)
+		{
+			Color leafColor = LodUtil.intToColor(biome.getFoliageColor()).darker();
+			leafColor = leafColor.darker();
+			colorInt = LodUtil.colorToInt(leafColor);
+		} else if ((blockState.getBlock() instanceof GrassBlock || blockState.getBlock() instanceof AbstractPlantBlock
+				            || blockState.getBlock() instanceof BushBlock || blockState.getBlock() instanceof IGrowable)
+				           && !(blockState.getBlock() == Blocks.BROWN_MUSHROOM || blockState.getBlock() == Blocks.RED_MUSHROOM))
+		{
+			Color plantColor = LodUtil.intToColor(biome.getGrassColor(x, z));
+			plantColor = plantColor.darker();
+			colorInt = LodUtil.colorToInt(plantColor);
+		}
+
+		// water
+		else if (blockState.getBlock() == Blocks.WATER)
+		{
+			colorInt = biome.getWaterColor();
+		}
+
+		// everything else
+		else
+		{
+			colorInt = blockState.materialColor.col;
+		}
+
+		return colorInt;
+	}
+
+	/**
+	 * Returns a color int for the given biome.
+	 */
+	private int getColorForBiome(int x, int z, Biome biome)
+	{
+		int colorInt = 0;
+
+		switch (biome.getBiomeCategory())
+		{
+
+			case NETHER:
+				colorInt = Blocks.BEDROCK.defaultBlockState().materialColor.col;
+				break;
+
+			case THEEND:
+				colorInt = Blocks.END_STONE.defaultBlockState().materialColor.col;
+				break;
+
+			case BEACH:
+			case DESERT:
+				colorInt = Blocks.SAND.defaultBlockState().materialColor.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;
+	}
+
+	/**
+	 * Is the layer between the given X, Z, and dataIndex values a valid LOD point?
+	 */
+	private boolean isLayerValidLodPoint(ChunkSection[] chunkSections, int sectionIndex, int y, int x, int z)
+	{
+		if (chunkSections[sectionIndex] == null)
+		{
+			// this section doesn't have any blocks,
+			// it is not a valid section
+			return false;
+		} else
+		{
+			if (chunkSections[sectionIndex].getBlockState(x, y, z) != null
+					    && chunkSections[sectionIndex].getBlockState(x, y, z).getBlock() != Blocks.AIR
+					    && chunkSections[sectionIndex].getBlockState(x, y, z).getBlock() != Blocks.CAVE_AIR)
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+}
@@ -0,0 +1,112 @@
+/*
+ *    This file is part of 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.builders;
+
+import com.seibel.lod.enums.DistanceGenerationMode;
+
+/**
+ * This is used to easily configure how LodChunks are generated.
+ * Generally this will only be used if we want to generate a
+ * LodChunk using a incomplete Chunk, otherwise the defaults
+ * work best for a fully generated chunk (IE has correct surface blocks).
+ *
+ * @author James Seibel
+ * @version 8-14-2021
+ */
+public class LodBuilderConfig
+{
+	/**
+	 * default false
+	 */
+	public boolean useHeightmap;
+	/**
+	 * default false
+	 */
+	public boolean useBiomeColors;
+	/**
+	 * default true
+	 */
+	public boolean useSolidBlocksInColorGen;
+	/**
+	 * default server
+	 */
+	public DistanceGenerationMode distanceGenerationMode;
+
+	/**
+	 * default settings for a normal chunk <br>
+	 * useHeightmap = false <br>
+	 * useBiomeColors = false <br>
+	 * useSolidBlocksInColorGen = true <br>
+	 * generationMode = Server <br>
+	 */
+	public LodBuilderConfig()
+	{
+		useHeightmap = false;
+		useBiomeColors = false;
+		useSolidBlocksInColorGen = true;
+		distanceGenerationMode = DistanceGenerationMode.SERVER;
+	}
+
+	/**
+	 * @param newUseHeightmap               default = false
+	 * @param newUseBiomeColors             default = false
+	 * @param newUseSolidBlocksInBiomeColor default = true
+	 * @param newDistanceGenerationMode     default = Server
+	 */
+	public LodBuilderConfig(boolean newUseHeightmap, boolean newUseBiomeColors,
+	                        boolean newUseSolidBlocksInBiomeColor, DistanceGenerationMode newDistanceGenerationMode)
+	{
+		useHeightmap = newUseHeightmap;
+		useBiomeColors = newUseBiomeColors;
+		useSolidBlocksInColorGen = newUseSolidBlocksInBiomeColor;
+		distanceGenerationMode = newDistanceGenerationMode;
+	}
+
+	/**
+	 * @param newUseHeightmap               default = false
+	 * @param newUseBiomeColors             default = false
+	 * @param newUseSolidBlocksInBiomeColor default = true
+	 * @param newDistanceGenerationMode     default = Server
+	 */
+	public LodBuilderConfig(boolean newUseHeightmap, boolean newUseBiomeColors, boolean newUseSolidBlocksInBiomeColor)
+	{
+		this();
+		useHeightmap = newUseHeightmap;
+		useBiomeColors = newUseBiomeColors;
+		useSolidBlocksInColorGen = newUseSolidBlocksInBiomeColor;
+		if (newUseHeightmap)
+		{
+			distanceGenerationMode = DistanceGenerationMode.BIOME_ONLY_SIMULATE_HEIGHT;
+		} else
+		{
+			distanceGenerationMode = DistanceGenerationMode.BIOME_ONLY;
+		}
+	}
+
+	/**
+	 * @param newUseHeightmap               default = false
+	 * @param newUseBiomeColors             default = false
+	 * @param newUseSolidBlocksInBiomeColor default = true
+	 * @param newDistanceGenerationMode     default = Server
+	 */
+	public LodBuilderConfig(DistanceGenerationMode newDistanceGenerationMode)
+	{
+		this();
+		distanceGenerationMode = newDistanceGenerationMode;
+	}
+}
@@ -0,0 +1,53 @@
+/*
+ *    This file is part of 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.builders.lodTemplates;
+
+import com.seibel.lod.enums.DebugMode;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.util.math.BlockPos;
+
+/**
+ * This is the abstract class used to create different
+ * BufferBuilders.
+ *
+ * @author James Seibel
+ * @version 8-8-2021
+ */
+public abstract class AbstractLodTemplate
+{
+	public abstract void addLodToBuffer(BufferBuilder buffer, BlockPos playerBlockPos, short[] data, short[][][] adjData,
+	                                    LevelPos levelPos, DebugMode debugging);
+
+	/**
+	 * add the given position and color to the buffer
+	 */
+	protected void addPosAndColor(BufferBuilder buffer,
+	                              double x, double y, double z,
+	                              int red, int green, int blue, int alpha)
+	{
+		buffer.vertex(x, y, z).color(red, green, blue, alpha).endVertex();
+	}
+
+	/**
+	 * Returns in bytes how much buffer memory is required
+	 * for one LOD object
+	 */
+	public abstract int getBufferMemoryForSingleNode();
+}
@@ -0,0 +1,328 @@
+/*
+ *    This file is part of 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.builders.lodTemplates;
+
+import com.seibel.lod.config.LodConfig;
+import com.seibel.lod.enums.DebugMode;
+import com.seibel.lod.enums.ShadingMode;
+import com.seibel.lod.objects.DataPoint;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+import com.seibel.lod.util.ColorUtil;
+import com.seibel.lod.util.LodUtil;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+
+/**
+ * Builds LODs as rectangular prisms.
+ *
+ * @author James Seibel
+ * @version 8-10-2021
+ */
+public class CubicLodTemplate extends AbstractLodTemplate
+{
+	private final int CULL_OFFSET = 16;
+	
+	public CubicLodTemplate()
+	{
+		
+	}
+	
+	@Override
+	public void addLodToBuffer(BufferBuilder buffer, BlockPos playerBlockPos, short[] data, short[][][] adjData,
+			LevelPos levelPos, DebugMode debugging)
+	{
+		AxisAlignedBB bbox;
+		
+		int width = 1 << levelPos.detailLevel;
+		
+		// add each LOD for the detail level
+		bbox = generateBoundingBox(
+				DataPoint.getHeight(data),
+				DataPoint.getDepth(data),
+				width,
+				levelPos.posX * width,
+				0,
+				levelPos.posZ * width);
+		
+		int color = DataPoint.getColor(data);
+		if (debugging != DebugMode.OFF)
+		{
+			color = LodUtil.DEBUG_DETAIL_LEVEL_COLORS[levelPos.detailLevel].getRGB();
+		}
+		
+		if (bbox != null)
+		{
+			addBoundingBoxToBuffer(buffer, bbox, color, playerBlockPos, adjData);
+		}
+		
+	}
+	
+	private AxisAlignedBB generateBoundingBox(int height, int depth, int width, double xOffset, double yOffset, double zOffset)
+	{
+		// don't add an LOD if it is empty
+		if (height == -1 && depth == -1)
+			return null;
+		
+		if (depth == height)
+		{
+			// if the top and bottom points are at the same height
+			// render this LOD as 1 block thick
+			height++;
+		}
+		
+		return new AxisAlignedBB(0, depth, 0, width, height, width).move(xOffset, yOffset, zOffset);
+	}
+	
+	private void addBoundingBoxToBuffer(BufferBuilder buffer, AxisAlignedBB bb, int c, BlockPos playerBlockPos, short[][][] adjData)
+	{
+		int topColor = c;
+		int bottomColor = c;
+		int northColor = c;
+		int southColor = c;
+		int westColor = c;
+		int eastColor = c;
+		
+		// darken the bottom and side colors if requested
+		if (LodConfig.CLIENT.graphics.shadingMode.get() == ShadingMode.DARKEN_SIDES)
+		{
+			// the side colors are different because
+			// when using fast lighting in Minecraft the north/south
+			// and east/west sides are different in a similar way
+			/**TODO OPTIMIZE THIS STEP*/
+			Minecraft mc = Minecraft.getInstance();
+			topColor = ColorUtil.applyShade(c, mc.level.getShade(Direction.UP, true));
+			bottomColor = ColorUtil.applyShade(c, mc.level.getShade(Direction.DOWN, true));
+			northColor = ColorUtil.applyShade(c, mc.level.getShade(Direction.NORTH, true));
+			southColor = ColorUtil.applyShade(c, mc.level.getShade(Direction.SOUTH, true));
+			westColor = ColorUtil.applyShade(c, mc.level.getShade(Direction.WEST, true));
+			eastColor = ColorUtil.applyShade(c, mc.level.getShade(Direction.EAST, true));
+		}
+		
+		// apply the user specified saturation and brightness
+		float saturationMultiplier = LodConfig.CLIENT.graphics.saturationMultiplier.get().floatValue();
+		float brightnessMultiplier = LodConfig.CLIENT.graphics.brightnessMultiplier.get().floatValue();
+		
+		if (saturationMultiplier != 1 || brightnessMultiplier != 1)
+		{
+			topColor = ColorUtil.applySaturationAndBrightnessMultipliers(topColor, saturationMultiplier, brightnessMultiplier);
+			bottomColor = ColorUtil.applySaturationAndBrightnessMultipliers(bottomColor, saturationMultiplier, brightnessMultiplier);
+			northColor = ColorUtil.applySaturationAndBrightnessMultipliers(northColor, saturationMultiplier, brightnessMultiplier);
+			southColor = ColorUtil.applySaturationAndBrightnessMultipliers(southColor, saturationMultiplier, brightnessMultiplier);
+			westColor = ColorUtil.applySaturationAndBrightnessMultipliers(westColor, saturationMultiplier, brightnessMultiplier);
+			eastColor = ColorUtil.applySaturationAndBrightnessMultipliers(eastColor, saturationMultiplier, brightnessMultiplier);
+		}
+		int minY;
+		int maxY;
+		short[] data;
+		
+		int red;
+		int green;
+		int blue;
+		int alpha;
+		boolean disableCulling = true;
+		/**TODO make all of this more automatic if possible*/
+		if (playerBlockPos.getY() > bb.maxY - CULL_OFFSET || disableCulling)
+		{
+			red = ColorUtil.getRed(topColor);
+			green = ColorUtil.getGreen(topColor);
+			blue = ColorUtil.getBlue(topColor);
+			alpha = ColorUtil.getAlpha(topColor);
+			// top (facing up)
+			addPosAndColor(buffer, bb.minX, bb.maxY, bb.minZ, red, green, blue, alpha);
+			addPosAndColor(buffer, bb.minX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+			addPosAndColor(buffer, bb.maxX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+			addPosAndColor(buffer, bb.maxX, bb.maxY, bb.minZ, red, green, blue, alpha);
+		}
+		if (playerBlockPos.getY() < bb.minY + CULL_OFFSET || disableCulling)
+		{
+			red = ColorUtil.getRed(bottomColor);
+			green = ColorUtil.getGreen(bottomColor);
+			blue = ColorUtil.getBlue(bottomColor);
+			alpha = ColorUtil.getAlpha(bottomColor);
+			// bottom (facing down)
+			addPosAndColor(buffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
+			addPosAndColor(buffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
+			addPosAndColor(buffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
+			addPosAndColor(buffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
+		}
+		
+		if (playerBlockPos.getZ() > bb.minZ - CULL_OFFSET || disableCulling)
+		{
+			red = ColorUtil.getRed(northColor);
+			green = ColorUtil.getGreen(northColor);
+			blue = ColorUtil.getBlue(northColor);
+			alpha = ColorUtil.getAlpha(northColor);
+			// south (facing -Z)
+			data = adjData[1][1];
+			if (data == null)
+			{
+				addPosAndColor(buffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.maxX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.minX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
+			}
+			else
+			{
+				maxY = DataPoint.getHeight(data);
+				if (maxY < bb.maxY)
+				{
+					minY = (int) Math.max(maxY, bb.minY);
+					addPosAndColor(buffer, bb.maxX, minY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, minY, bb.maxZ, red, green, blue, alpha);
+				}
+				minY = DataPoint.getDepth(data);
+				if (minY > bb.minY)
+				{
+					maxY = (int) Math.min(minY, bb.maxY);
+					addPosAndColor(buffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, maxY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, maxY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
+				}
+			}
+		}
+		
+		if (playerBlockPos.getZ() < bb.maxZ + CULL_OFFSET || disableCulling)
+		{
+			red = ColorUtil.getRed(southColor);
+			green = ColorUtil.getGreen(southColor);
+			blue = ColorUtil.getBlue(southColor);
+			alpha = ColorUtil.getAlpha(southColor);
+			data = adjData[1][0];
+			// north (facing +Z)
+			if (data == null)
+			{
+				addPosAndColor(buffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.minX, bb.maxY, bb.minZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.maxX, bb.maxY, bb.minZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
+			}
+			else
+			{
+				maxY = DataPoint.getHeight(data);
+				if (maxY < bb.maxY)
+				{
+					minY = (int) Math.max(maxY, bb.minY);
+					addPosAndColor(buffer, bb.minX, minY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, bb.maxY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, bb.maxY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, minY, bb.minZ, red, green, blue, alpha);
+				}
+				minY = DataPoint.getDepth(data);
+				if (minY > bb.minY)
+				{
+					maxY = (int) Math.min(minY, bb.maxY);
+					addPosAndColor(buffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, maxY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, maxY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
+				}
+			}
+		}
+		
+		if (playerBlockPos.getX() < bb.maxX + CULL_OFFSET || disableCulling)
+		{
+			red = ColorUtil.getRed(westColor);
+			green = ColorUtil.getGreen(westColor);
+			blue = ColorUtil.getBlue(westColor);
+			alpha = ColorUtil.getAlpha(westColor);
+			// west (facing -X)
+			data = adjData[0][0];
+			if (data == null)
+			{
+				addPosAndColor(buffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.minX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.minX, bb.maxY, bb.minZ, red, green, blue, alpha);
+			}
+			else
+			{
+				maxY = DataPoint.getHeight(data);
+				if (maxY < bb.maxY)
+				{
+					minY = (int) Math.max(maxY, bb.minY);
+					addPosAndColor(buffer, bb.minX, minY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, minY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, bb.maxY, bb.minZ, red, green, blue, alpha);
+				}
+				minY = DataPoint.getDepth(data);
+				if (minY > bb.minY)
+				{
+					maxY = (int) Math.min(minY, bb.maxY);
+					addPosAndColor(buffer, bb.minX, bb.minY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, bb.minY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, maxY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.minX, maxY, bb.minZ, red, green, blue, alpha);
+				}
+			}
+		}
+		
+		if (playerBlockPos.getX() > bb.minX - CULL_OFFSET || disableCulling)
+		{
+			red = ColorUtil.getRed(eastColor);
+			green = ColorUtil.getGreen(eastColor);
+			blue = ColorUtil.getBlue(eastColor);
+			alpha = ColorUtil.getAlpha(eastColor);
+			// east (facing +X)
+			data = adjData[0][1];
+			if (data == null)
+			{
+				addPosAndColor(buffer, bb.maxX, bb.maxY, bb.minZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.maxX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
+				addPosAndColor(buffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
+			}
+			else
+			{
+				maxY = DataPoint.getHeight(data);
+				if (maxY < bb.maxY)
+				{
+					minY = (int) Math.max(maxY, bb.minY);
+					addPosAndColor(buffer, bb.maxX, bb.maxY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, bb.maxY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, minY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, minY, bb.minZ, red, green, blue, alpha);
+				}
+				minY = DataPoint.getDepth(data);
+				if (minY > bb.minY)
+				{
+					maxY = (int) Math.min(minY, bb.maxY);
+					addPosAndColor(buffer, bb.maxX, maxY, bb.minZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, maxY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, bb.minY, bb.maxZ, red, green, blue, alpha);
+					addPosAndColor(buffer, bb.maxX, bb.minY, bb.minZ, red, green, blue, alpha);
+				}
+			}
+		}
+	}
+	
+	@Override
+	public int getBufferMemoryForSingleNode()
+	{
+		// (sidesOnACube * pointsInASquare * (positionPoints + colorPoints)))
+		return (6 * 4 * (3 + 4));
+	}
+	
+}
@@ -0,0 +1,49 @@
+/*
+ *    This file is part of 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.builders.lodTemplates;
+
+import com.seibel.lod.enums.DebugMode;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.util.math.BlockPos;
+
+/**
+ * TODO DynamicLodTemplate
+ * Chunks smoothly transition between
+ * each other, unless a neighboring chunk
+ * is at a significantly different height.
+ *
+ * @author James Seibel
+ * @version 06-16-2021
+ */
+public class DynamicLodTemplate extends AbstractLodTemplate
+{
+	@Override
+	public void addLodToBuffer(BufferBuilder buffer, BlockPos playerBlockPos, short[] data, short[][][] adjData,
+	                           LevelPos levelPos, DebugMode debugging)
+	{
+		System.err.println("DynamicLodTemplate not implemented!");
+	}
+
+	@Override
+	public int getBufferMemoryForSingleNode()
+	{
+		return 0;
+	}
+}
@@ -0,0 +1,47 @@
+/*
+ *    This file is part of 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.builders.lodTemplates;
+
+import com.seibel.lod.enums.DebugMode;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.util.math.BlockPos;
+
+/**
+ * TODO #21 TriangularLodTemplate
+ * Builds each LOD chunk as a singular rectangular prism.
+ *
+ * @author James Seibel
+ * @version 06-16-2021
+ */
+public class TriangularLodTemplate extends AbstractLodTemplate
+{
+	@Override
+	public void addLodToBuffer(BufferBuilder buffer, BlockPos playerBlockPos, short[] data, short[][][] adjData,
+	                           LevelPos levelPos, DebugMode debugging)
+	{
+		System.err.println("DynamicLodTemplate not implemented!");
+	}
+
+	@Override
+	public int getBufferMemoryForSingleNode()
+	{
+		return 0;
+	}
+}
@@ -0,0 +1,669 @@
+/*
+ *    This file is part of 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.builders.worldGeneration;
+
+import java.util.ConcurrentModificationException;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Supplier;
+
+import com.seibel.lod.builders.LodBuilder;
+import com.seibel.lod.builders.LodBuilderConfig;
+import com.seibel.lod.config.LodConfig;
+import com.seibel.lod.enums.DistanceGenerationMode;
+import com.seibel.lod.objects.LodDimension;
+import com.seibel.lod.proxy.ClientProxy;
+import com.seibel.lod.render.LodRenderer;
+import com.seibel.lod.util.LodThreadFactory;
+import com.seibel.lod.util.LodUtil;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.WeightedList.Entry;
+import net.minecraft.util.math.ChunkPos;
+import net.minecraft.util.palette.UpgradeData;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.world.biome.Biome;
+import net.minecraft.world.chunk.ChunkPrimer;
+import net.minecraft.world.chunk.ChunkStatus;
+import net.minecraft.world.chunk.IChunk;
+import net.minecraft.world.gen.ChunkGenerator;
+import net.minecraft.world.gen.Heightmap;
+import net.minecraft.world.gen.blockstateprovider.WeightedBlockStateProvider;
+import net.minecraft.world.gen.feature.BlockClusterFeatureConfig;
+import net.minecraft.world.gen.feature.ConfiguredFeature;
+import net.minecraft.world.gen.feature.DecoratedFeatureConfig;
+import net.minecraft.world.gen.feature.FeatureSpread;
+import net.minecraft.world.gen.feature.FeatureSpreadConfig;
+import net.minecraft.world.gen.feature.IceAndSnowFeature;
+import net.minecraft.world.gen.feature.NoFeatureConfig;
+import net.minecraft.world.gen.placement.ConfiguredPlacement;
+import net.minecraft.world.gen.placement.DecoratedPlacementConfig;
+import net.minecraft.world.gen.placement.IPlacementConfig;
+import net.minecraft.world.gen.placement.NoiseDependant;
+import net.minecraft.world.server.ServerChunkProvider;
+import net.minecraft.world.server.ServerWorld;
+import net.minecraft.world.server.ServerWorldLightManager;
+import net.minecraftforge.common.WorldWorkerManager.IWorker;
+
+/**
+ * This is used to generate a LodChunk at a given ChunkPos.
+ *
+ * @author James Seibel
+ * @version 8-26-2021
+ */
+public class LodNodeGenWorker implements IWorker
+{
+	public static ExecutorService genThreads = Executors.newFixedThreadPool(LodConfig.CLIENT.threading.numberOfWorldGenerationThreads.get(), new LodThreadFactory(LodNodeGenWorker.class.getSimpleName()));
+
+	private boolean threadStarted = false;
+	private LodChunkGenThread thread;
+	
+	
+	/** If a configured feature fails for whatever reason,
+	 * add it to this list, this is to hopefully remove any
+	 * features that could cause issues down the line. */
+	private static ConcurrentHashMap<Integer, ConfiguredFeature<?, ?>> configuredFeaturesToAvoid = new ConcurrentHashMap<>();
+
+
+
+	public LodNodeGenWorker(ChunkPos newPos, DistanceGenerationMode newGenerationMode, LodRenderer newLodRenderer,
+							LodBuilder newLodBuilder,
+							LodDimension newLodDimension, ServerWorld newServerWorld)
+	{
+		// just a few sanity checks
+		if (newPos == null)
+			throw new IllegalArgumentException("LodChunkGenWorker must have a non-null ChunkPos");
+
+		if (newLodRenderer == null)
+			throw new IllegalArgumentException("LodChunkGenWorker must have a non-null LodRenderer");
+
+		if (newLodBuilder == null)
+			throw new IllegalArgumentException("LodChunkGenThread requires a non-null LodChunkBuilder");
+
+		if (newLodDimension == null)
+			throw new IllegalArgumentException("LodChunkGenThread requires a non-null LodDimension");
+
+		if (newServerWorld == null)
+			throw new IllegalArgumentException("LodChunkGenThread requires a non-null ServerWorld");
+
+
+
+		thread = new LodChunkGenThread(newPos, newGenerationMode, newLodRenderer,
+				newLodBuilder,
+				newLodDimension, newServerWorld);
+	}
+
+	@Override
+	public boolean doWork()
+	{
+		if (!threadStarted)
+		{
+			if (LodConfig.CLIENT.worldGenerator.distanceGenerationMode.get() == DistanceGenerationMode.SERVER)
+			{
+				// if we are using SERVER generation that has to be done
+				// synchronously to prevent crashing and harmful
+				// interactions with the normal world generator
+				thread.run();
+			}
+			else
+			{
+				// Every other method can
+				// be done asynchronously
+				Thread newThread = new Thread(thread);
+				newThread.setPriority(3);
+				genThreads.execute(newThread);
+			}
+
+			threadStarted = true;
+
+			// useful for debugging
+//        	ClientProxy.LOGGER.info(thread.lodDim.getNumberOfLods());
+//        	ClientProxy.LOGGER.info(genThreads.toString());
+		}
+
+		return false;
+	}
+
+	@Override
+	public boolean hasWork()
+	{
+		return !threadStarted;
+	}
+
+
+
+
+	private class LodChunkGenThread implements Runnable
+	{
+		public final ServerWorld serverWorld;
+		public final LodDimension lodDim;
+		public final DistanceGenerationMode generationMode;
+		public final LodBuilder lodBuilder;
+		public final LodRenderer lodRenderer;
+
+		private ChunkPos pos;
+
+		public LodChunkGenThread(ChunkPos newPos, DistanceGenerationMode newGenerationMode, LodRenderer newLodRenderer,
+								 LodBuilder newLodBuilder,
+								 LodDimension newLodDimension, ServerWorld newServerWorld)
+		{
+			pos = newPos;
+			generationMode = newGenerationMode;
+			lodRenderer = newLodRenderer;
+			lodBuilder = newLodBuilder;
+			lodDim = newLodDimension;
+			serverWorld = newServerWorld;
+		}
+
+		@Override
+		public void run()
+		{
+			try
+			{
+				// only generate LodChunks if they can
+				// be added to the current LodDimension
+
+				/**TODO i must disable this if, i will find a way to replace it*/
+				if (lodDim.regionIsInRange(pos.x / LodUtil.REGION_WIDTH_IN_CHUNKS, pos.z / LodUtil.REGION_WIDTH_IN_CHUNKS))
+				{
+//					long startTime = System.currentTimeMillis();
+
+					switch(generationMode)
+					{
+						case NONE:
+							// don't generate
+							break;
+						case BIOME_ONLY:
+						case BIOME_ONLY_SIMULATE_HEIGHT:
+							// fastest
+							generateUsingBiomesOnly();
+							break;
+						case SURFACE:
+							// faster
+							generateUsingSurface();
+							break;
+						case FEATURES:
+							// fast
+							generateUsingFeatures();
+							break;
+						case SERVER:
+							// very slow
+							generateWithServer();
+							break;
+					}
+
+					//lodRenderer.regenerateLODsNextFrame();
+
+/*
+					boolean dataExistence = lodDim.doesDataExist(new LevelPos((byte) 3, pos.x, pos.z));
+					if (dataExistence)
+						ClientProxy.LOGGER.info(pos.x + " " + pos.z + " Success!");
+					else
+						ClientProxy.LOGGER.info(pos.x + " " + pos.z);
+*/
+					// shows the pool size, active threads, queued tasks and completed tasks
+//					ClientProxy.LOGGER.info(genThreads.toString());
+
+//					long endTime = System.currentTimeMillis();
+//					System.out.println(endTime - startTime);
+
+				}// if in range
+				else{
+
+				}
+			}
+			catch (Exception e)
+			{
+				//e.printStackTrace();
+			}
+			finally
+			{
+				// decrement how many threads are running
+				LodWorldGenerator.INSTANCE.numberOfChunksWaitingToGenerate.addAndGet(-1);
+				
+				// this position is no longer being generated
+				LodWorldGenerator.INSTANCE.positionWaitingToBeGenerated.remove(pos);
+			}
+
+		}// run
+
+
+
+		/**
+		 * takes about 2-5 ms
+		 */
+		private void generateUsingBiomesOnly()
+		{
+			List<IChunk> chunkList = new LinkedList<>();
+			ChunkPrimer chunk = new ChunkPrimer(pos, UpgradeData.EMPTY);
+			chunkList.add(chunk);
+
+			ServerChunkProvider chunkSource = serverWorld.getChunkSource();
+			ChunkGenerator chunkGen = chunkSource.generator;
+
+			// generate the terrain (this is thread safe)
+			ChunkStatus.EMPTY.generate(serverWorld, chunkGen, serverWorld.getStructureManager(), (ServerWorldLightManager) serverWorld.getLightEngine(), null, chunkList);
+			// override the chunk status so we can run the next generator stage
+			chunk.setStatus(ChunkStatus.STRUCTURE_REFERENCES);
+			chunkGen.createBiomes(serverWorld.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), chunk);
+			chunk.setStatus(ChunkStatus.STRUCTURE_REFERENCES);
+
+
+
+
+			// generate fake height data for this LOD
+			int seaLevel = serverWorld.getSeaLevel();
+
+			boolean simulateHeight = generationMode == DistanceGenerationMode.BIOME_ONLY_SIMULATE_HEIGHT;
+			boolean inTheEnd = false;
+
+			// add fake heightmap data so our LODs aren't at height 0
+			Heightmap heightmap = new Heightmap(chunk, LodUtil.DEFAULT_HEIGHTMAP);
+			for(int x = 0; x < LodUtil.CHUNK_WIDTH && !inTheEnd; x++)
+			{
+				for(int z = 0; z < LodUtil.CHUNK_WIDTH && !inTheEnd; z++)
+				{
+					if (simulateHeight)
+					{
+						// these heights are of course aren't super accurate,
+						// they are just to simulate height data where there isn't any
+						switch(chunk.getBiomes().getNoiseBiome(x >> 2, seaLevel >> 2, z >> 2).getBiomeCategory())
+						{
+							case NETHER:
+								heightmap.setHeight(x, z, serverWorld.getHeight() / 2);
+								break;
+
+							case EXTREME_HILLS:
+								heightmap.setHeight(x, z, seaLevel + 30);
+								break;
+							case MESA:
+								heightmap.setHeight(x, z, seaLevel + 20);
+								break;
+							case JUNGLE:
+								heightmap.setHeight(x, z, seaLevel + 20);
+								break;
+							case BEACH:
+								heightmap.setHeight(x, z, seaLevel + 5);
+								break;
+							case NONE:
+								heightmap.setHeight(x, z, 0);
+								break;
+
+							case OCEAN:
+							case RIVER:
+								heightmap.setHeight(x, z, seaLevel);
+								break;
+
+							case THEEND:
+								inTheEnd = true;
+								break;
+
+							// DESERT
+							// FOREST
+							// ICY
+							// MUSHROOM
+							// SAVANNA
+							// SWAMP
+							// TAIGA
+							// PLAINS
+							default:
+								heightmap.setHeight(x, z, seaLevel + 10);
+								break;
+						}// heightmap switch
+					}
+					else
+					{
+						// we aren't simulating height
+						// always use sea level
+						heightmap.setHeight(x, z, seaLevel);
+					}
+				}// z
+			}// x
+
+			chunk.setHeightmap(LodUtil.DEFAULT_HEIGHTMAP, heightmap.getRawData());
+
+
+			if (!inTheEnd)
+			{
+				lodBuilder.generateLodNodeFromChunk(lodDim, chunk, new LodBuilderConfig(true, true, false));
+			}
+			else
+			{
+				// if we are in the end, don't generate any chunks.
+				// Since we don't know where the islands are, everything
+				// generates the same and it looks really bad.
+				lodBuilder.generateLodNodeFromChunk(lodDim, chunk, new LodBuilderConfig(true, true, false));
+			}
+
+
+//			long startTime = System.currentTimeMillis();
+//			long endTime = System.currentTimeMillis();
+//			System.out.println(endTime - startTime);
+		}
+
+
+		/**
+		 * takes about 10 - 20 ms
+		 */
+		private void generateUsingSurface()
+		{
+			List<IChunk> chunkList = new LinkedList<>();
+			ChunkPrimer chunk = new ChunkPrimer(pos, UpgradeData.EMPTY);
+			chunkList.add(chunk);
+			LodServerWorld lodServerWorld = new LodServerWorld(serverWorld, chunk);
+
+			ServerChunkProvider chunkSource = serverWorld.getChunkSource();
+			ChunkGenerator chunkGen = chunkSource.generator;
+
+
+			// generate the terrain (this is thread safe)
+			ChunkStatus.EMPTY.generate(serverWorld, chunkGen, serverWorld.getStructureManager(), (ServerWorldLightManager) serverWorld.getLightEngine(), null, chunkList);
+			// override the chunk status so we can run the next generator stage
+			chunk.setStatus(ChunkStatus.STRUCTURE_REFERENCES);
+			chunkGen.createBiomes(serverWorld.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), chunk);
+			ChunkStatus.NOISE.generate(serverWorld, chunkGen, serverWorld.getStructureManager(), (ServerWorldLightManager) serverWorld.getLightEngine(), null, chunkList);
+			ChunkStatus.SURFACE.generate(serverWorld, chunkGen, serverWorld.getStructureManager(), (ServerWorldLightManager) serverWorld.getLightEngine(), null, chunkList);
+
+			// this feature has been proven to be thread safe
+			// so we will add it
+			IceAndSnowFeature snowFeature = new IceAndSnowFeature(NoFeatureConfig.CODEC);
+			snowFeature.place(lodServerWorld, chunkGen, serverWorld.random, chunk.getPos().getWorldPosition(), null);
+
+			lodBuilder.generateLodNodeFromChunk(lodDim, chunk, new LodBuilderConfig(DistanceGenerationMode.SURFACE));
+
+			/**TODO if we want to use Biome utils and terrain utils for overworld
+			 * lodBuilder.generateLodNodeFromChunk(lodDim, pos ,detailLevel, serverWorld.getSeed());*/
+		}
+
+
+		/**
+		 * takes about 15 - 20 ms
+		 *
+		 * Causes concurrentModification Exceptions,
+		 * which could cause instability or world generation bugs
+		 */
+		private void generateUsingFeatures()
+		{
+			List<IChunk> chunkList = new LinkedList<>();
+			ChunkPrimer chunk = new ChunkPrimer(pos, UpgradeData.EMPTY);
+			chunkList.add(chunk);
+			LodServerWorld lodServerWorld = new LodServerWorld(serverWorld, chunk);
+
+			ServerChunkProvider chunkSource = serverWorld.getChunkSource();
+			ChunkGenerator chunkGen = chunkSource.generator;
+
+
+			// generate the terrain (this is thread safe)
+			ChunkStatus.EMPTY.generate(serverWorld, chunkGen, serverWorld.getStructureManager(), (ServerWorldLightManager) serverWorld.getLightEngine(), null, chunkList);
+			// override the chunk status so we can run the next generator stage
+			chunk.setStatus(ChunkStatus.STRUCTURE_REFERENCES);
+			chunkGen.createBiomes(serverWorld.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), chunk);
+			ChunkStatus.NOISE.generate(serverWorld, chunkGen, serverWorld.getStructureManager(), (ServerWorldLightManager) serverWorld.getLightEngine(), null, chunkList);
+			ChunkStatus.SURFACE.generate(serverWorld, chunkGen, serverWorld.getStructureManager(), (ServerWorldLightManager) serverWorld.getLightEngine(), null, chunkList);
+
+
+			// get all the biomes in the chunk
+			HashSet<Biome> biomes = new HashSet<>();
+			for (int x = 0; x < LodUtil.CHUNK_WIDTH; x++)
+			{
+				for (int z = 0; z < LodUtil.CHUNK_WIDTH; z++)
+				{
+					Biome biome = chunk.getBiomes().getNoiseBiome(x >> 2, serverWorld.getSeaLevel() >> 2, z >> 2);
+
+					// Issue #35
+					// For some reason Jungle biomes cause incredible lag
+					// the features here must be interacting with each other
+					// in unpredictable ways (specifically tree feature generation).
+					// When generating Features my CPU usage generally hovers around 30 - 40%
+					// when generating Jungles it spikes to 100%.
+					if (biome.getBiomeCategory() != Biome.Category.JUNGLE)
+					{
+						// should probably use the heightmap here instead of seaLevel,
+						// but this seems to get the job done well enough
+						biomes.add(biome);
+					}
+				}
+			}
+
+			boolean allowUnstableFeatures = LodConfig.CLIENT.worldGenerator.allowUnstableFeatureGeneration.get();
+
+			// generate all the features related to this chunk.
+			// this may or may not be thread safe
+			for (Biome biome : biomes)
+			{
+				List<List<Supplier<ConfiguredFeature<?, ?>>>> featuresForState = biome.generationSettings.features();
+
+				for(int featureStateToGenerate = 0; featureStateToGenerate < featuresForState.size(); featureStateToGenerate++)
+				{
+					for(Supplier<ConfiguredFeature<?, ?>> featureSupplier : featuresForState.get(featureStateToGenerate))
+					{
+						ConfiguredFeature<?, ?> configuredFeature = featureSupplier.get();
+
+						if (!allowUnstableFeatures &&
+								configuredFeaturesToAvoid.containsKey(configuredFeature.hashCode()))
+							continue;
+
+
+						try
+						{
+							configuredFeature.place(lodServerWorld, chunkGen, serverWorld.random, chunk.getPos().getWorldPosition());
+						}
+						catch(ConcurrentModificationException e)
+						{
+							// This will happen. I'm not sure what to do about it
+							// except pray that it doesn't effect the normal world generation
+							// in any harmful way.
+							// Update: this can cause crashes and high CPU usage.
+
+							// Issue #35
+							// I tried cloning the config for each feature, but that
+							// path was blocked since I can't clone lambda methods.
+							// I tried using a deep cloning library and discovered
+							// the problem there.
+							// ( https://github.com/kostaskougios/cloning
+							//   and
+							//   https://github.com/EsotericSoftware/kryo )
+
+							if (!allowUnstableFeatures)
+								configuredFeaturesToAvoid.put(configuredFeature.hashCode(), configuredFeature);
+//							ClientProxy.LOGGER.info(configuredFeaturesToAvoid.mappingCount());
+						}
+						catch(UnsupportedOperationException e)
+						{
+							// This will happen when the LodServerWorld
+							// isn't able to return something that a feature
+							// generator needs
+
+							if (!allowUnstableFeatures)
+								configuredFeaturesToAvoid.put(configuredFeature.hashCode(), configuredFeature);
+//							ClientProxy.LOGGER.info(configuredFeaturesToAvoid.mappingCount());
+						}
+						catch(Exception e)
+						{
+							// I'm not sure what happened, print to the log
+
+							System.out.println();
+							System.out.println();
+							e.printStackTrace();
+							System.out.println();
+							System.out.println();
+
+							if (!allowUnstableFeatures)
+								configuredFeaturesToAvoid.put(configuredFeature.hashCode(), configuredFeature);
+//							ClientProxy.LOGGER.info(configuredFeaturesToAvoid.mappingCount());
+						}
+					}
+				}
+			}
+
+			// generate a Lod like normal
+
+			lodBuilder.generateLodNodeFromChunk(lodDim, chunk, new LodBuilderConfig(DistanceGenerationMode.FEATURES));
+		}
+
+
+		/**
+		 * on pre generated chunks 0 - 1 ms
+		 * on un generated chunks 0 - 50 ms
+		 * 	with the median seeming to hover around 15 - 30 ms
+		 * 	and outliers in the 100 - 200 ms range
+		 *
+		 * Note this should not be multithreaded and does cause server/simulation lag
+		 * (Higher lag for generating than loading)
+		 */
+		private void generateWithServer()
+		{
+			lodBuilder.generateLodNodeAsync(serverWorld.getChunk(pos.x, pos.z, ChunkStatus.FEATURES), ClientProxy.getLodWorld(), serverWorld);
+		}
+
+
+
+
+
+
+		//================//
+		// Unused methods //
+		//================//
+
+		// Sadly I wasn't able to get these to work,
+		// they are here for documentation purposes
+
+		@SuppressWarnings({ "rawtypes", "unchecked", "unused" })
+		private DecoratedFeatureConfig cloneDecoratedFeatureConfig(DecoratedFeatureConfig config)
+		{
+			IPlacementConfig placementConfig = null;
+
+			Class oldConfigClass = config.decorator.config().getClass();
+
+			if (oldConfigClass == FeatureSpreadConfig.class)
+			{
+				FeatureSpreadConfig oldPlacementConfig = (FeatureSpreadConfig) config.decorator.config();
+				FeatureSpread oldSpread = oldPlacementConfig.count();
+
+				placementConfig = new FeatureSpreadConfig(oldSpread);
+			}
+			else if(oldConfigClass == DecoratedPlacementConfig.class)
+			{
+				DecoratedPlacementConfig oldPlacementConfig = (DecoratedPlacementConfig) config.decorator.config();
+				placementConfig = new DecoratedPlacementConfig(oldPlacementConfig.inner(), oldPlacementConfig.outer());
+			}
+			else if(oldConfigClass == NoiseDependant.class)
+			{
+				NoiseDependant oldPlacementConfig = (NoiseDependant) config.decorator.config();
+				placementConfig = new NoiseDependant(oldPlacementConfig.noiseLevel, oldPlacementConfig.belowNoise, oldPlacementConfig.aboveNoise);
+			}
+			else
+			{
+//				ClientProxy.LOGGER.debug("unkown decorated placement config: \"" + config.decorator.config().getClass() + "\"");
+				return config;
+			}
+
+
+			ConfiguredPlacement<?> newPlacement = new ConfiguredPlacement(config.decorator.decorator, placementConfig);
+			return new DecoratedFeatureConfig(config.feature, newPlacement);
+		}
+
+
+		@SuppressWarnings("unused")
+		private BlockClusterFeatureConfig cloneBlockClusterFeatureConfig(BlockClusterFeatureConfig config)
+		{
+			WeightedBlockStateProvider provider = new WeightedBlockStateProvider();
+			for(Entry<BlockState> state : ((WeightedBlockStateProvider) config.stateProvider).weightedList.entries)
+				provider.weightedList.entries.add(state);
+
+			HashSet<Block> whitelist = new HashSet<>();
+			for(Block block : config.whitelist)
+				whitelist.add(block);
+
+			HashSet<BlockState> blacklist = new HashSet<>();
+			for(BlockState state : config.blacklist)
+				blacklist.add(state);
+
+
+			BlockClusterFeatureConfig.Builder builder = new BlockClusterFeatureConfig.Builder(provider, config.blockPlacer);
+			builder.whitelist(whitelist);
+			builder.blacklist(blacklist);
+			builder.xspread(config.xspread);
+			builder.yspread(config.yspread);
+			builder.zspread(config.zspread);
+			if(config.canReplace) { builder.canReplace(); }
+			if(config.needWater) { builder.needWater(); }
+			if(config.project) { builder.noProjection(); }
+			builder.tries(config.tries);
+
+
+			return builder.build();
+		}
+
+	}
+
+
+	/**
+	 * Stops the current genThreads if they are running
+	 * and then recreates the Executer service. <br><br>
+	 *
+	 * This is done to clear any outstanding tasks
+	 * that may exist after the player leaves their current world.
+	 * If this isn't done unfinished tasks may be left in the queue
+	 * preventing new LodChunks form being generated.
+	 */
+	public static void restartExecuterService()
+	{
+		if (genThreads != null && !genThreads.isShutdown())
+		{
+			genThreads.shutdownNow();
+		}
+		genThreads = Executors.newFixedThreadPool(LodConfig.CLIENT.threading.numberOfWorldGenerationThreads.get(), new LodThreadFactory(LodNodeGenWorker.class.getSimpleName()));
+	}
+
+
+
+
+
+    /*
+     * 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 is needed to make biomes distinct)
+
+     Otherwise if snow/trees aren't necessary SURFACE is the next fastest (although not by much)
+     */
+}
@@ -0,0 +1,330 @@
+/*
+ *    This file is part of 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.builders.worldGeneration;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import com.seibel.lod.util.LodUtil;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.fluid.Fluid;
+import net.minecraft.fluid.FluidState;
+import net.minecraft.particles.IParticleData;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.Direction;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.SoundEvent;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.SectionPos;
+import net.minecraft.util.registry.DynamicRegistries;
+import net.minecraft.world.DifficultyInstance;
+import net.minecraft.world.DimensionType;
+import net.minecraft.world.EmptyTickList;
+import net.minecraft.world.ISeedReader;
+import net.minecraft.world.ITickList;
+import net.minecraft.world.biome.Biome;
+import net.minecraft.world.biome.BiomeManager;
+import net.minecraft.world.border.WorldBorder;
+import net.minecraft.world.chunk.AbstractChunkProvider;
+import net.minecraft.world.chunk.ChunkStatus;
+import net.minecraft.world.chunk.IChunk;
+import net.minecraft.world.gen.Heightmap;
+import net.minecraft.world.gen.Heightmap.Type;
+import net.minecraft.world.gen.feature.structure.Structure;
+import net.minecraft.world.gen.feature.structure.StructureStart;
+import net.minecraft.world.lighting.WorldLightManager;
+import net.minecraft.world.server.ServerWorld;
+import net.minecraft.world.storage.IWorldInfo;
+
+
+/**
+ * This is a fake ServerWorld used when generating features.
+ * This allows us to keep each LodChunk generation independent
+ * of the actual ServerWorld, allowing us
+ * to multithread generation.
+ *
+ * @author James Seibel
+ * @version 7-26-2021
+ */
+public class LodServerWorld implements ISeedReader
+{
+
+	public HashMap<Heightmap.Type, Heightmap> heightmaps = new HashMap<>();
+
+	public IChunk chunk;
+
+	public ServerWorld serverWorld;
+
+	public LodServerWorld(ServerWorld newServerWorld, IChunk newChunk)
+	{
+		chunk = newChunk;
+		serverWorld = newServerWorld;
+	}
+
+
+	@Override
+	public int getHeight(Type heightmapType, int x, int z)
+	{
+		// make sure the block position is set relative to the chunk
+		x = x % LodUtil.CHUNK_WIDTH;
+		x = (x < 0) ? x + 16 : x;
+
+		z = z % LodUtil.CHUNK_WIDTH;
+		z = (z < 0) ? z + 16 : z;
+
+		return chunk.getOrCreateHeightmapUnprimed(LodUtil.DEFAULT_HEIGHTMAP).getFirstAvailable(x, z);
+	}
+
+	@Override
+	public Biome getBiome(BlockPos pos)
+	{
+		return chunk.getBiomes().getNoiseBiome(pos.getX() >> 2, pos.getY() >> 2, pos.getZ() >> 2);
+	}
+
+	@Override
+	public boolean setBlock(BlockPos pos, BlockState state, int flags, int recursionLeft)
+	{
+		return chunk.setBlockState(pos, state, false) == state;
+	}
+
+	@Override
+	public BlockState getBlockState(BlockPos pos)
+	{
+		return chunk.getBlockState(pos);
+	}
+
+	@Override
+	public FluidState getFluidState(BlockPos pos)
+	{
+		return chunk.getFluidState(pos);
+	}
+
+
+	@Override
+	public boolean isStateAtPosition(BlockPos pos, Predicate<BlockState> state)
+	{
+		return state.test(chunk.getBlockState(pos));
+	}
+
+	@Override
+	public ITickList<Block> getBlockTicks()
+	{
+		return EmptyTickList.empty();
+	}
+
+	@Override
+	public IChunk getChunk(int x, int z, ChunkStatus requiredStatus, boolean nonnull)
+	{
+		return chunk;
+	}
+
+	@Override
+	public Stream<? extends StructureStart<?>> startsForFeature(SectionPos p_241827_1_, Structure<?> p_241827_2_)
+	{
+		return serverWorld.startsForFeature(p_241827_1_, p_241827_2_);
+	}
+
+	@Override
+	public ITickList<Fluid> getLiquidTicks()
+	{
+		return EmptyTickList.empty();
+	}
+
+	@Override
+	public WorldLightManager getLightEngine()
+	{
+		return new WorldLightManager(null, false, false);
+	}
+
+	@Override
+	public long getSeed()
+	{
+		return serverWorld.getSeed();
+	}
+
+	@Override
+	public DynamicRegistries registryAccess()
+	{
+		return serverWorld.registryAccess();
+	}
+
+
+	/**
+	 * All methods below shouldn't be needed
+	 * and thus have been left unimplemented.
+	 */
+
+
+	@Override
+	public Random getRandom()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+	@Override
+	public void playSound(PlayerEntity player, BlockPos pos, SoundEvent soundIn, SoundCategory category, float volume,
+	                      float pitch)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+	@Override
+	public void addParticle(IParticleData particleData, double x, double y, double z, double xSpeed, double ySpeed,
+	                        double zSpeed)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+	@Override
+	public BiomeManager getBiomeManager()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+	@Override
+	public int getSeaLevel()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+	@Override
+	public float getShade(Direction p_230487_1_, boolean p_230487_2_)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+	@Override
+	public WorldBorder getWorldBorder()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+	@Override
+	public boolean removeBlock(BlockPos pos, boolean isMoving)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+	@Override
+	public boolean destroyBlock(BlockPos pos, boolean dropBlock, Entity entity, int recursionLeft)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public ServerWorld getLevel()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public AbstractChunkProvider getChunkSource()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public DifficultyInstance getCurrentDifficultyAt(BlockPos arg0)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public IWorldInfo getLevelData()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public void levelEvent(PlayerEntity arg0, int arg1, BlockPos arg2, int arg3)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+
+	}
+
+
+	@Override
+	public List<Entity> getEntities(Entity arg0, AxisAlignedBB arg1, Predicate<? super Entity> arg2)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public <T extends Entity> List<T> getEntitiesOfClass(Class<? extends T> arg0, AxisAlignedBB arg1,
+	                                                     Predicate<? super T> arg2)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public List<? extends PlayerEntity> players()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public int getSkyDarken()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public Biome getUncachedNoiseBiome(int p_225604_1_, int p_225604_2_, int p_225604_3_)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public boolean isClientSide()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public DimensionType dimensionType()
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+
+	@Override
+	public TileEntity getBlockEntity(BlockPos p_175625_1_)
+	{
+		throw new UnsupportedOperationException("Not Implemented");
+	}
+
+}
@@ -0,0 +1,262 @@
+package com.seibel.lod.builders.worldGeneration;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.commons.lang3.mutable.MutableBoolean;
+
+import com.seibel.lod.builders.GenerationRequest;
+import com.seibel.lod.builders.LodBuilder;
+import com.seibel.lod.config.LodConfig;
+import com.seibel.lod.enums.DistanceGenerationMode;
+import com.seibel.lod.objects.LodDimension;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+import com.seibel.lod.render.LodRenderer;
+import com.seibel.lod.util.DetailDistanceUtil;
+import com.seibel.lod.util.LodThreadFactory;
+import com.seibel.lod.util.LodUtil;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.ChunkPos;
+import net.minecraft.world.server.ServerWorld;
+import net.minecraftforge.common.WorldWorkerManager;
+
+/**
+ * A singleton that handles all long distance LOD world generation.
+ *
+ * @author James Seibel
+ * @version 8-24-2021
+ */
+public class LodWorldGenerator
+{
+	public Minecraft mc = Minecraft.getInstance();
+
+	/**
+	 * This holds the thread used to generate new LODs off the main thread.
+	 */
+	private ExecutorService mainGenThread = Executors.newSingleThreadExecutor(new LodThreadFactory(this.getClass().getSimpleName() + " world generator"));
+
+	/**
+	 * we only want to queue up one generator thread at a time
+	 */
+	private boolean generatorThreadRunning = false;
+
+	/**
+	 * how many chunks to generate outside of the player's view distance at one
+	 * time. (or more specifically how many requests to make at one time). I
+	 * multiply by 8 to make sure there is always a buffer of chunk requests, to
+	 * make sure the CPU is always busy and we can generate LODs as quickly as
+	 * possible.
+	 */
+	public int maxChunkGenRequests;
+
+	/**
+	 * This keeps track of how many chunk generation requests are on going. This is
+	 * to limit how many chunks are queued at once. To prevent chunks from being
+	 * generated for a long time in an area the player is no longer in.
+	 */
+	public AtomicInteger numberOfChunksWaitingToGenerate = new AtomicInteger(0);
+
+	public Set<ChunkPos> positionWaitingToBeGenerated = new HashSet<>();
+
+	/**
+	 * Singleton copy of this object
+	 */
+	public static final LodWorldGenerator INSTANCE = new LodWorldGenerator();
+
+	public volatile ConcurrentMap<LevelPos, MutableBoolean> nodeToGenerate;
+
+	SortedSet<LevelPos> nodeToGenerateListNear;
+	SortedSet<LevelPos> nodeToGenerateListFar;
+
+	private LodWorldGenerator()
+	{
+
+	}
+
+	/**
+	 * Queues up LodNodeGenWorkers for the given lodDimension.
+	 *
+	 * @param renderer needed so the LodNodeGenWorkers can flag that the
+	 *                 buffers need to be rebuilt.
+	 */
+	public void queueGenerationRequests(LodDimension lodDim, LodRenderer renderer, LodBuilder lodBuilder)
+	{
+		if (LodConfig.CLIENT.worldGenerator.distanceGenerationMode.get() != DistanceGenerationMode.NONE
+				    && !generatorThreadRunning
+				    && mc.hasSingleplayerServer())
+		{
+			// the thread is now running, don't queue up another thread
+			generatorThreadRunning = true;
+
+			// just in case the config changed
+			maxChunkGenRequests = LodConfig.CLIENT.threading.numberOfWorldGenerationThreads.get() * 8;
+
+			Thread generatorThread = new Thread(() ->
+			{
+				try
+				{
+					// round the player's block position down to the nearest chunk BlockPos
+					ChunkPos playerChunkPos = new ChunkPos(mc.player.blockPosition());
+					BlockPos playerBlockPosRounded = playerChunkPos.getWorldPosition();
+
+					// used when determining which chunks are closer when queuing distance
+					// generation
+					int minChunkDist = Integer.MAX_VALUE;
+
+					ArrayList<GenerationRequest> chunksToGen = new ArrayList<>(maxChunkGenRequests);
+					// if we don't have a full number of chunks to generate in chunksToGen
+					// we can top it off from this reserve
+
+
+					//=======================================//
+					// create the generation Request objects //
+					//=======================================//
+					List<GenerationRequest> generationRequestList = new ArrayList<>(maxChunkGenRequests);
+
+					if (nodeToGenerate == null)
+						nodeToGenerate = new ConcurrentHashMap<>();
+
+
+					Comparator<LevelPos> posNearComparator = LevelPos.getPosComparator(
+							playerBlockPosRounded.getX(),
+							playerBlockPosRounded.getZ());
+					Comparator<LevelPos> posFarComparator = LevelPos.getPosAndDetailComparator(
+							playerBlockPosRounded.getX(),
+							playerBlockPosRounded.getZ());
+					nodeToGenerateListNear = new TreeSet(posNearComparator);
+					nodeToGenerateListFar = new TreeSet(posFarComparator);
+
+					lodDim.getDataToGenerate(
+							nodeToGenerate,
+							playerBlockPosRounded.getX(),
+							playerBlockPosRounded.getZ());
+
+
+					//here we prepare two sorted set
+					//the first contains the near pos to render
+					//the second contain the far pos to render
+					byte farDetail = (byte) 7;
+					for (LevelPos pos : nodeToGenerate.keySet())
+					{
+						if (!nodeToGenerate.get(pos).booleanValue())
+						{
+							nodeToGenerate.remove(pos);
+						} else
+						{
+							if (pos.detailLevel > farDetail){
+								nodeToGenerateListFar.add(pos);
+							}
+							nodeToGenerateListNear.add(pos);
+							nodeToGenerate.get(pos).setFalse();
+						}
+					}
+
+					int maxDistance;
+					byte circle;
+					LevelPos levelPos;
+					int requesting = maxChunkGenRequests;
+					int requestingFar = maxChunkGenRequests / 4;
+					while (requesting > 0 && !nodeToGenerateListNear.isEmpty())
+					{
+						levelPos = nodeToGenerateListNear.first();
+						//.out.println(levelPos);
+						nodeToGenerate.remove(levelPos);
+						nodeToGenerateListNear.remove(levelPos);
+						nodeToGenerateListFar.remove(levelPos);
+
+						//maxDistance = levelPos.maxDistance(
+						//		playerBlockPosRounded.getX(),
+						//		playerBlockPosRounded.getZ());
+						//circle = DetailDistanceUtil.getDistanceGenerationInverse(maxDistance);
+						generationRequestList.add(new GenerationRequest(levelPos, DetailDistanceUtil.getDistanceGenerationMode(levelPos.detailLevel)));
+						requesting--;
+						if (requestingFar > 0 && !nodeToGenerateListFar.isEmpty())
+						{
+							levelPos = nodeToGenerateListFar.first();
+							nodeToGenerate.remove(levelPos);
+							nodeToGenerateListNear.remove(levelPos);
+							nodeToGenerateListFar.remove(levelPos);
+							if (levelPos.detailLevel >= farDetail)
+							{
+								//maxDistance = levelPos.maxDistance(	playerBlockPosRounded.getX(), playerBlockPosRounded.getZ());
+								//circle = DetailDistanceUtil.getDistanceGenerationInverse(maxDistance);
+								generationRequestList.add(new GenerationRequest(levelPos, DetailDistanceUtil.getDistanceGenerationMode(levelPos.detailLevel)));
+								requestingFar--;
+								requesting--;
+							}
+						}
+					}
+
+
+					//====================================//
+					// get the closet generation requests //
+					//====================================//
+
+					// determine which points in the posListToGenerate
+					// should actually be queued to generate
+					for (GenerationRequest generationRequest : generationRequestList)
+					{
+						ChunkPos chunkPos = generationRequest.getChunkPos();
+						if (numberOfChunksWaitingToGenerate.get() < maxChunkGenRequests)
+						{
+							// prevent generating the same chunk multiple times
+							if (positionWaitingToBeGenerated.contains(chunkPos))
+							{
+								continue;
+							}
+							chunksToGen.add(generationRequest);
+
+						} // lod null and can generate more chunks
+					} // positions to generate
+
+
+					//=============================//
+					// start the LodNodeGenWorkers //
+					//=============================//
+
+					// issue #19
+					// TODO add a way for a server side mod to generate chunks requested here
+					ServerWorld serverWorld = LodUtil.getServerWorldFromDimension(lodDim.dimension);
+
+					// start chunk generation
+					for (GenerationRequest generationRequest : generationRequestList)
+					{
+						// don't add null chunkPos (which shouldn't happen anyway)
+						// or add more to the generation queue
+						ChunkPos chunkPos = generationRequest.getChunkPos();
+						if (chunkPos == null || numberOfChunksWaitingToGenerate.get() >= maxChunkGenRequests)
+							continue;
+
+						positionWaitingToBeGenerated.add(chunkPos);
+						numberOfChunksWaitingToGenerate.addAndGet(1);
+						LodNodeGenWorker genWorker = new LodNodeGenWorker(chunkPos, generationRequest.generationMode, renderer, lodBuilder, lodDim, serverWorld);
+						WorldWorkerManager.addWorker(genWorker);
+					}
+
+				} catch (Exception e)
+				{
+					// this shouldn't ever happen, but just in case
+					e.printStackTrace();
+				} finally
+				{
+					generatorThreadRunning = false;
+				}
+			});
+
+			mainGenThread.execute(generatorThread);
+		} // if distanceGenerationMode != DistanceGenerationMode.NONE && !generatorThreadRunning
+	}
+
+}
@@ -0,0 +1,440 @@
+/*
+ *    This file is part of 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.config;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.logging.log4j.LogManager;
+
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import com.electronwill.nightconfig.core.io.WritingMode;
+import com.seibel.lod.ModInfo;
+import com.seibel.lod.enums.DebugMode;
+import com.seibel.lod.enums.DistanceCalculatorType;
+import com.seibel.lod.enums.DistanceGenerationMode;
+import com.seibel.lod.enums.FogDistance;
+import com.seibel.lod.enums.FogDrawOverride;
+import com.seibel.lod.enums.LodDetail;
+import com.seibel.lod.enums.LodTemplate;
+import com.seibel.lod.enums.ShadingMode;
+
+import net.minecraftforge.common.ForgeConfigSpec;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.config.ModConfig;
+
+/**
+ * This handles any configuration the user has access to.
+ *
+ * @author James Seibel
+ * @version 9-1-2021
+ */
+@Mod.EventBusSubscriber
+public class LodConfig
+{
+	public static class Client
+    {
+        public final Graphics graphics;
+        public final WorldGenerator worldGenerator;
+        public final Threading threading;
+        public final Debugging debugging;
+        public final Buffers buffers;
+
+        public Client(ForgeConfigSpec.Builder builder)
+        {
+            builder.push("client");
+            {
+                graphics = new Graphics(builder);
+                worldGenerator = new WorldGenerator(builder);
+                threading = new Threading(builder);
+                debugging = new Debugging(builder);
+                buffers = new Buffers(builder);
+            }
+            builder.pop();
+        }
+    }
+	
+	
+	
+	//================//
+	// Client Configs //
+	//================//
+	
+	public static class Graphics
+	{
+		public ForgeConfigSpec.BooleanValue drawLODs;
+		
+		public ForgeConfigSpec.EnumValue<FogDistance> fogDistance;
+		public ForgeConfigSpec.EnumValue<FogDrawOverride> fogDrawOverride;
+		
+		public ForgeConfigSpec.EnumValue<LodTemplate> lodTemplate;
+		
+		public ForgeConfigSpec.EnumValue<LodDetail> maxDrawDetail;
+		
+		public ForgeConfigSpec.EnumValue<ShadingMode> shadingMode;
+		
+		public ForgeConfigSpec.IntValue lodQuality;
+		
+		public ForgeConfigSpec.IntValue lodChunkRenderDistance;
+		
+		public ForgeConfigSpec.DoubleValue brightnessMultiplier;
+		public ForgeConfigSpec.DoubleValue saturationMultiplier;
+		
+		
+		Graphics(ForgeConfigSpec.Builder builder)
+		{
+			builder.comment("These settings control how the LODs look.").push(this.getClass().getSimpleName());
+			
+			drawLODs = builder
+					.comment("\n\n"
+							+ " If false LODs will not be drawn, \n"
+							+ " however they will still be generated \n"
+							+ " and saved to file for later use. \n")
+					.define("drawLODs", true);
+			
+			fogDistance = builder
+					.comment("\n\n"
+							+ " At what distance should Fog be drawn on the LODs? \n"
+							+ " If the fog cuts off ubruptly or you are using Optifine's \"fast\" fog option \n"
+							+ " set this to " + FogDistance.NEAR.toString() + " or " + FogDistance.FAR.toString() + ". \n")
+					.defineEnum("fogDistance", FogDistance.NEAR_AND_FAR);
+			
+			fogDrawOverride = builder
+					.comment("\n\n"
+							+ " When should fog be drawn? \n"
+							+ " " + FogDrawOverride.USE_OPTIFINE_FOG_SETTING.toString() + ": Use whatever Fog setting Optifine is using. If Optifine isn't installed this defaults to " + FogDrawOverride.ALWAYS_DRAW_FOG_FANCY.toString() + ". \n"
+							+ " " + FogDrawOverride.NEVER_DRAW_FOG.toString() + ": Never draw fog on the LODs \n"
+							+ " " + FogDrawOverride.ALWAYS_DRAW_FOG_FAST.toString() + ": Always draw fast fog on the LODs \n"
+							+ " " + FogDrawOverride.ALWAYS_DRAW_FOG_FANCY.toString() + ": Always draw fancy fog on the LODs (if your graphics card supports it) \n")
+					.defineEnum("fogDrawOverride", FogDrawOverride.USE_OPTIFINE_FOG_SETTING);
+			
+			lodTemplate = builder
+					.comment("\n\n"
+							+ " How should the LODs be drawn? \n"
+							+ " NOTE: Currently only " + LodTemplate.CUBIC.toString() + " is implemented! \n"
+							+ " \n"
+							+ " " + LodTemplate.CUBIC.toString() + ": LOD Chunks are drawn as rectangular prisms (boxes). \n"
+							+ " " + LodTemplate.TRIANGULAR.toString() + ": LOD Chunks smoothly transition between other. \n"
+							+ " " + LodTemplate.DYNAMIC.toString() + ": LOD Chunks smoothly transition between other, \n"
+							+ " " + "         unless a neighboring chunk is at a significantly different height. \n")
+					.defineEnum("lodTemplate", LodTemplate.CUBIC);
+			
+			maxDrawDetail = builder
+					.comment("\n\n"
+							+ " What is the maximum detail level that LODs should be drawn at? \n"
+							+ " " + LodDetail.SINGLE.toString() + ": render 1 LOD for each Chunk. \n"
+							+ " " + LodDetail.DOUBLE.toString() + ": render 4 LODs for each Chunk. \n"
+							+ " " + LodDetail.QUAD.toString() + ": render 16 LODs for each Chunk. \n"
+							+ " " + LodDetail.HALF.toString() + ": render 64 LODs for each Chunk. \n"
+							+ " " + LodDetail.FULL.toString() + ": render 256 LODs for each Chunk. \n")
+					.defineEnum("lodDrawQuality", LodDetail.FULL);
+			
+			lodQuality = builder
+					.comment("\n\n"
+							+ " this value is multiplied by 128 and determine \n"
+							+ " how much the quality decrease over distance \n")
+					.defineInRange("lodQuality", 1, 1, 4);
+			
+			lodChunkRenderDistance = builder
+					.comment("\n\n"
+							+ " This is the render distance of the mod \n")
+					.defineInRange("lodChunkRenderDistane", 64, 32, 512);
+			
+			shadingMode = builder
+					.comment("\n\n"
+							+ " What kind of shading should the LODs have? \n"
+							+ " \n"
+							+ " " + ShadingMode.NONE.toString() + " \n"
+							+ " " + "LODs will have the same lighting on every side. \n"
+							+ " " + "Can make large similarly colored areas hard to differentiate. \n"
+							+ "\n"
+							+ " " + ShadingMode.DARKEN_SIDES.toString() + " \n"
+							+ " " + "LODs will have darker sides and bottoms to simulate Minecraft's flat lighting.")
+					.defineEnum("lightingMode", ShadingMode.DARKEN_SIDES);
+			
+			brightnessMultiplier = builder
+					.comment("\n\n"
+							+ " Change how bright LOD colors are. \n"
+							+ " 0 = black \n"
+							+ " 1 = normal color value \n"
+							+ " 2 = washed out colors \n")
+					.defineInRange("brightnessMultiplier", 1.0, 0, 2);
+			
+			saturationMultiplier = builder
+					.comment("\n\n"
+							+ " Change how saturated LOD colors are. \n"
+							+ " 0 = black and white \n"
+							+ " 1 = normal saturation \n"
+							+ " 2 = very saturated \n")
+					.defineInRange("saturationMultiplier", 1.0, 0, 2);
+			
+			
+			builder.pop();
+		}
+	}
+	
+	public static class WorldGenerator
+	{
+		public ForgeConfigSpec.EnumValue<LodDetail> maxGenerationDetail;
+		public ForgeConfigSpec.EnumValue<DistanceGenerationMode> distanceGenerationMode;
+		public ForgeConfigSpec.BooleanValue allowUnstableFeatureGeneration;
+		public ForgeConfigSpec.EnumValue<DistanceCalculatorType> lodDistanceCalculatorType;
+		
+		
+		WorldGenerator(ForgeConfigSpec.Builder builder)
+		{
+			builder.comment("These settings control how LODs outside your normal view range are generated.").push(this.getClass().getSimpleName());
+			
+			maxGenerationDetail = builder
+					.comment("\n\n"
+							+ " What is the maximum detail level that LODs should be generated at? \n"
+							+ " " + LodDetail.SINGLE.toString() + ": render 1 LOD for each Chunk. \n"
+							+ " " + LodDetail.DOUBLE.toString() + ": render 4 LODs for each Chunk. \n"
+							+ " " + LodDetail.QUAD.toString() + ": render 16 LODs for each Chunk. \n"
+							+ " " + LodDetail.HALF.toString() + ": render 64 LODs for each Chunk. \n"
+							+ " " + LodDetail.FULL.toString() + ": render 256 LODs for each Chunk. \n")
+					.defineEnum("lodGenerationQuality", LodDetail.HALF);
+			
+			lodDistanceCalculatorType = builder
+					.comment("\n\n"
+							+ " " + DistanceCalculatorType.LINEAR + " \n"
+							+ " with LINEAR calculator the quality of block decrease \n"
+							+ " linearly to the distance of the player \n"
+							
+							+ "\n"
+							+ " " + DistanceCalculatorType.QUADRATIC + " \n"
+							+ " with LINEAR calculator the quality of block decrease \n"
+							+ " quadratically to the distance of the player \n"
+							
+							+ "\n"
+							+ " " + DistanceCalculatorType.RENDER_DEPENDANT + " \n"
+							+ " with LINEAR calculator the quality of block decrease \n"
+							+ " quadratically to the distance of the player \n")
+					.defineEnum("lodDistanceComputation", DistanceCalculatorType.LINEAR);
+			
+			distanceGenerationMode = builder
+					.comment("\n\n"
+							+ " Note: The times listed here are the amount of time it took \n"
+							+ "       the developer's PC to generate 1 chunk, \n"
+							+ "       and are included so you can compare the \n"
+							+ "       different generation options. Your mileage may vary. \n"
+							+ "\n"
+
+							+ " " + DistanceGenerationMode.NONE.toString() + " \n"
+							+ " Don't run the distance generator. \n"
+							
+							+ " " + DistanceGenerationMode.BIOME_ONLY.toString() + " \n"
+							+ " Only generate the biomes and use biome \n"
+							+ " grass/foliage color, water color, or snow color \n"
+							+ " to generate the color. \n"
+							+ " Doesn't generate height, everything is shown at sea level. \n"
+							+ " Multithreaded - Fastest (2-5 ms) \n"
+							
+							+ "\n"
+							+ " " + DistanceGenerationMode.BIOME_ONLY_SIMULATE_HEIGHT.toString() + " \n"
+							+ " Same as BIOME_ONLY, except instead \n"
+							+ " of always using sea level as the LOD height \n"
+							+ " different biome types (mountain, ocean, forest, etc.) \n"
+							+ " use predetermined heights to simulate having height data. \n"
+							+ " Multithreaded - Fastest (2-5 ms) \n"
+							
+							+ "\n"
+							+ " " + DistanceGenerationMode.SURFACE.toString() + " \n"
+							+ " Generate the world surface, \n"
+							+ " this does NOT include caves, trees, \n"
+							+ " or structures. \n"
+							+ " Multithreaded - Faster (10-20 ms) \n"
+							
+							+ "\n"
+							+ " " + DistanceGenerationMode.FEATURES.toString() + " \n"
+							+ " Generate everything except structures. \n"
+							+ " WARNING: This may cause world generation bugs or instability! \n"
+							+ " Multithreaded - Fast (15-20 ms) \n"
+							
+							+ "\n"
+							+ " " + DistanceGenerationMode.SERVER.toString() + " \n"
+							+ " Ask the server to generate/load each chunk. \n"
+							+ " This is the most compatible, but causes server/simulation lag. \n"
+							+ " This will also show player made structures if you \n"
+							+ " are adding the mod to a pre-existing world. \n"
+							+ " Singlethreaded - Slow (15-50 ms, with spikes up to 200 ms) \n")
+					.defineEnum("distanceGenerationMode", DistanceGenerationMode.SURFACE);
+			
+			allowUnstableFeatureGeneration = builder
+					.comment("\n\n"
+							+ " When using the " + DistanceGenerationMode.FEATURES.toString() + " generation mode \n"
+							+ " some features may not be thread safe, which could \n"
+							+ " cause instability and crashes. \n"
+							+ " By default (false) those features are skipped, \n"
+							+ " improving stability, but decreasing how many features are \n"
+							+ " actually generated. \n"
+							+ " (for example: some tree generation is unstable, \n"
+							+ "               so some trees may not be generated.) \n"
+							+ " By setting this to true, all features will be generated, \n"
+							+ " but your game will be more unstable and crashes may occur. \n"
+							+ " \n"
+							+ " I would love to remove this option and always generate everything, \n"
+							+ " but I'm not sure how to do that. \n"
+							+ " If you are a Java wizard, check out the git issue here: \n"
+							+ " https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues/35 \n")
+					.define("allowUnstableFeatureGeneration", false);
+			
+			
+			builder.pop();
+		}
+	}
+	
+	public static class Threading
+	{
+		public ForgeConfigSpec.IntValue numberOfWorldGenerationThreads;
+		public ForgeConfigSpec.IntValue numberOfBufferBuilderThreads;
+		
+		Threading(ForgeConfigSpec.Builder builder)
+		{
+			builder.comment("These settings control how many CPU threads the mod uses for different tasks.").push(this.getClass().getSimpleName());
+			
+			numberOfWorldGenerationThreads = builder
+					.comment("\n\n"
+							+ " This is how many threads are used when generating LODs outside \n"
+							+ " the normal render distance. \n"
+							+ " If you experience stuttering when generating distant LODs, decrease \n"
+							+ " this number. If you want to increase LOD generation speed, \n"
+							+ " increase this number. \n"
+							+ " \n"
+							+ " The maximum value is the number of processors on your CPU. \n"
+							+ " Requires a restart to take effect. \n")
+					.defineInRange("numberOfWorldGenerationThreads", Runtime.getRuntime().availableProcessors() / 2, 1, Runtime.getRuntime().availableProcessors());
+			
+			numberOfBufferBuilderThreads = builder
+					.comment("\n\n"
+							+ " This is how many threads are used when building vertex buffers \n"
+							+ " (The things sent to your GPU to draw the LODs). \n"
+							+ " If you experience high CPU useage when NOT generating distant \n"
+							+ " LODs, lower this number. \n"
+							+ " \n"
+							+ " The maximum value is the number of processors on your CPU. \n"
+							+ " Requires a restart to take effect. \n")
+					.defineInRange("numberOfBufferBuilderThreads", Runtime.getRuntime().availableProcessors(), 1, Runtime.getRuntime().availableProcessors());
+			
+			builder.pop();
+		}
+	}
+	
+	public static class Debugging
+	{
+		public ForgeConfigSpec.EnumValue<DebugMode> debugMode;
+		public ForgeConfigSpec.BooleanValue enableDebugKeybinding;
+		
+		Debugging(ForgeConfigSpec.Builder builder)
+		{
+			builder.comment("These settings can be used by to look for bugs, or see how certain parts of the mod are working.").push(this.getClass().getSimpleName());
+			
+			debugMode = builder
+					.comment("\n\n"
+							+ " " + DebugMode.OFF.toString() + ": LODs will draw with their normal colors. \n"
+							+ " " + DebugMode.SHOW_DETAIL.toString() + ": LOD colors will be based on their detail. \n"
+							+ " " + DebugMode.SHOW_DETAIL_WIREFRAME.toString() + ": LOD colors will be based on their detail, drawn with wireframe. \n")
+					.defineEnum("debugMode", DebugMode.OFF);
+			
+			enableDebugKeybinding = builder
+					.comment("\n\n"
+							+ " If true the F4 key can be used to cycle through the different debug modes. \n")
+					.define("enableDebugKeybinding", false);
+			
+			builder.pop();
+		}
+	}
+	
+	public static class Buffers
+	{
+		public ForgeConfigSpec.IntValue bufferRebuildPlayerMoveTimeout;
+		public ForgeConfigSpec.IntValue bufferRebuildChunkChangeTimeout;
+		public ForgeConfigSpec.IntValue bufferRebuildLodChangeTimeout;
+		
+		Buffers(ForgeConfigSpec.Builder builder)
+		{
+			builder.comment("These settings affect when Vertex Buffers are built.").push(this.getClass().getSimpleName());
+			
+			bufferRebuildPlayerMoveTimeout = builder
+					.comment("\n\n"
+							+ " How long in milliseconds should we wait to \n"
+							+ " rebuild the vertex buffers when the player moves \n"
+							+ " a chunk or more? \n")
+					.defineInRange("bufferRebuildPlayerMoveTimeout", 2000, 1, 60000);
+			
+			bufferRebuildChunkChangeTimeout = builder
+					.comment("\n\n"
+							+ " How long in milliseconds should we wait to \n"
+							+ " rebuild the vertex buffers when the vanilla rendered \n"
+							+ " chunks change? \n")
+					.defineInRange("bufferRebuildChunkChangeTimeout", 1000, 1, 60000);
+			
+			bufferRebuildLodChangeTimeout = builder
+					.comment("\n\n"
+							+ " How long in milliseconds should we wait to \n"
+							+ " rebuild the vertex buffers when the LOD regions change? \n")
+					.defineInRange("bufferRebuildLodChangeTimeout", 5000, 1, 60000);
+			
+			
+			builder.pop();
+		}
+	}
+	
+	
+	
+	
+	
+	
+	
+	
+	/**
+	 * {@link Path} to the configuration file of this mod
+	 */
+	private static final Path CONFIG_PATH = Paths.get("config", ModInfo.MODID + ".toml");
+	
+	public static final ForgeConfigSpec CLIENT_SPEC;
+	public static final Client CLIENT;
+	
+	static
+	{
+		final Pair<Client, ForgeConfigSpec> specPair = new ForgeConfigSpec.Builder().configure(Client::new);
+		CLIENT_SPEC = specPair.getRight();
+		CLIENT = specPair.getLeft();
+		CommentedFileConfig clientConfig = CommentedFileConfig.builder(CONFIG_PATH)
+				.writingMode(WritingMode.REPLACE)
+				.build();
+		clientConfig.load();
+		clientConfig.save();
+		CLIENT_SPEC.setConfig(clientConfig);
+	}
+	
+	@SubscribeEvent
+	public static void onLoad(final ModConfig.Loading configEvent)
+	{
+		LogManager.getLogger().debug(ModInfo.MODNAME, "Loaded forge config file {}", configEvent.getConfig().getFileName());
+	}
+	
+	@SubscribeEvent
+	public static void onFileChange(final ModConfig.Reloading configEvent)
+	{
+		LogManager.getLogger().debug(ModInfo.MODNAME, "Forge config just got changed on the file system!");
+	}
+	
+}
@@ -0,0 +1,51 @@
+/*
+ *    This file is part of 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.enums;
+
+/**
+ * TOP, NORTH, SOUTH, EAST, WEST, BOTTOM
+ * 
+ * @author James Seibel
+ * @version 10-17-2020
+ */
+public enum ColorDirection
+{
+	// used for colors
+	/** +Y */
+	TOP(0),
+	
+	/** -Z */
+	NORTH(1),
+	/** +Z */
+	SOUTH(2),
+	
+	/** +X */
+	EAST(3),
+	/** -X */
+	WEST(4),
+	
+	/** -Y */
+	BOTTOM(5);
+	
+	public final int value;
+	
+	private ColorDirection(int newValue)
+	{
+		value = newValue;
+	}
+}
@@ -0,0 +1,50 @@
+/*
+ *    This file is part of 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.enums;
+
+/**
+ * off, detail, detail wireframe
+ * 
+ * @author James Seibel
+ * @version 8-28-2021
+ */
+public enum DebugMode
+{
+	OFF,
+	
+	/** LOD colors are based on their detail */
+	SHOW_DETAIL,
+	
+	/** LOD colors are based on their detail, and draws in wireframe. */
+	SHOW_DETAIL_WIREFRAME;
+	
+	/** used when cycling through the different modes */
+	private DebugMode next;
+	static 
+	{
+		OFF.next = SHOW_DETAIL;
+		SHOW_DETAIL.next = SHOW_DETAIL_WIREFRAME;
+		SHOW_DETAIL_WIREFRAME.next = OFF;
+	}
+	
+	/** returns the next debug mode */
+	public DebugMode getNext()
+	{
+		return this.next;
+	}
+}
@@ -0,0 +1,23 @@
+package com.seibel.lod.enums;
+
+/**
+ * @author Leonardo Amato
+ * @version 22-08-2021
+ */
+public enum DistanceCalculatorType
+{
+	/**
+	 * different Lod detail render and generate linearly to the distance
+	 */
+	LINEAR,
+
+	/**
+	 * different Lod detail render and generate quadratically to the distance
+	 */
+	QUADRATIC,
+
+	/**
+	 * we calculate the distance based on game render distance and mod render distance
+	 */
+	RENDER_DEPENDANT;
+}
@@ -0,0 +1,93 @@
+/*
+ *    This file is part of 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.enums;
+
+/**
+ * NONE <br>
+ * BIOME_ONLY <br>
+ * BIOME_ONLY_SIMULATE_HEIGHT <br>
+ * SURFACE <br>
+ * FEATURES <br>
+ * SERVER <br><br>
+ * <p>
+ * In order of fastest to slowest.
+ *
+ * @author James Seibel
+ * @author Leonardo Amato
+ * @version 8-7-2021
+ */
+public enum DistanceGenerationMode
+{
+	/**
+	 * Don't generate anything
+	 */
+	NONE((byte) 0),
+
+	/**
+	 * Only generate the biomes and use biome
+	 * grass/foliage color, water color, or ice color
+	 * to generate the color.
+	 * Doesn't generate height, everything is shown at sea level.
+	 * Multithreaded - Fastest (2-5 ms)
+	 */
+	BIOME_ONLY((byte) 1),
+
+	/**
+	 * Same as BIOME_ONLY, except instead
+	 * of always using sea level as the LOD height
+	 * different biome types (mountain, ocean, forest, etc.)
+	 * use predetermined heights to simulate having height data.
+	 */
+	BIOME_ONLY_SIMULATE_HEIGHT((byte) 2),
+
+	/**
+	 * Generate the world surface,
+	 * this does NOT include caves, trees,
+	 * or structures.
+	 * Multithreaded - Faster (10-20 ms)
+	 */
+	SURFACE((byte) 3),
+
+	/**
+	 * Generate everything except structures.
+	 * NOTE: This may cause world generation bugs or instability,
+	 * since some features cause concurrentModification exceptions.
+	 * Multithreaded - Fast (15-20 ms)
+	 */
+	FEATURES((byte) 4),
+
+	/**
+	 * Ask the server to generate/load each chunk.
+	 * This is the most compatible, but causes server/simulation lag.
+	 * This will also show player made structures if you
+	 * are adding the mod to a pre-existing world.
+	 * Singlethreaded - Slow (15-50 ms, with spikes up to 200 ms)
+	 */
+	SERVER((byte) 5);
+
+
+	/**
+	 * The higher the number the more complete the generation is.
+	 */
+	public final byte complexity;
+
+	DistanceGenerationMode(byte complexity)
+	{
+		this.complexity = complexity;
+	}
+}
@@ -0,0 +1,36 @@
+/*
+ *    This file is part of 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.enums;
+
+/**
+ * NEAR, FAR, or NEAR_AND_FAR.
+ * 
+ * @author James Seibel
+ * @version 02-14-2021
+ */
+public enum FogDistance
+{
+	/** good for fast or fancy fog qualities. */
+	NEAR,
+	
+	/** good for fast or fancy fog qualities. */
+	FAR,
+	
+	/** only looks good if the fog quality is set to Fancy. */
+	NEAR_AND_FAR;
+}
@@ -0,0 +1,43 @@
+/*
+ *    This file is part of 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.enums;
+
+/**
+ * USE_OPTIFINE_FOG_SETTING, <br>
+ * NEVER_DRAW_FOG, <br>
+ * ALWAYS_DRAW_FOG_FAST, <br>
+ * ALWAYS_DRAW_FOG_FANCY <br>
+ * 
+ * @author James Seibel
+ * @version 7-03-2021
+ */
+public enum FogDrawOverride
+{
+	/** Use whatever Fog setting optifine is using.
+	 * If optifine isn't installed this defaults to ALWAYS_DRAW_FOG. */
+	USE_OPTIFINE_FOG_SETTING,
+	
+	/** Never draw fog on the LODs */
+	NEVER_DRAW_FOG,
+	
+	/** Always draw fog on the LODs */
+	ALWAYS_DRAW_FOG_FAST,
+	
+	/** Always draw fog on the LODs */
+	ALWAYS_DRAW_FOG_FANCY;
+}
@@ -0,0 +1,31 @@
+/*
+ *    This file is part of 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.enums;
+
+/**
+ * fast, fancy, or off
+ * 
+ * @author James Seibel
+ * @version 02-14-2021
+ */
+public enum FogQuality
+{
+	FAST,
+	FANCY,
+	OFF;
+}
@@ -0,0 +1,43 @@
+/*
+ *    This file is part of 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.enums;
+
+/**
+ * NE, SE, SW, NW
+ * 
+ * @author James Seibel
+ * @version 1-20-2020
+ */
+public enum LodCorner
+{
+	/** -Z, +X */
+	NE(0),
+	/** +Z, +X */
+	SE(1),
+	/** +Z, -X */
+	SW(2),
+	/** -Z, -X */
+	NW(3);
+	
+	public final int value;
+	
+	private LodCorner(int newValue)
+	{
+		value = newValue;
+	}
+}
@@ -0,0 +1,159 @@
+/*
+ *    This file is part of 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.enums;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+import com.seibel.lod.util.LodUtil;
+
+/**
+ * single, double, quad, half, full
+ * 
+ * @author James Seibel
+ * @version 8-11-2021
+ */
+public enum LodDetail
+{
+	/** render 1 LOD for each chunk */
+	SINGLE(1, 4),
+	
+	/** render 4 LODs for each chunk */
+	DOUBLE(2, 3),
+	
+	/** render 16 LODs for each chunk */
+	QUAD(4, 2),
+	
+	/** render 64 LODs for each chunk */
+	HALF(8, 1),
+	
+	/** render 256 LODs for each chunk */
+	FULL(16, 0);
+	
+	
+	/** How many DataPoints should 
+	 * be drawn per side per LodChunk */
+	public final int dataPointLengthCount;
+	/** How wide each LOD DataPoint is */
+	public final int dataPointWidth;
+	/** This is the same as detailLevel in LodQuadTreeNode, 
+	 * lowest is 0 highest is 9 */
+	public final byte detailLevel;
+	
+	/* Start/End X/Z give the block positions
+	 * for each individual dataPoint in a LodChunk */
+	public final int[] startX;
+	public final int[] startZ;
+	
+	public final int[] endX;
+	public final int[] endZ;
+
+	
+	/** 
+	 * 1st dimension: LodDetail.detailLevel <br>
+	 * 2nd dimension: An array of all LodDetails that are less than or <br>
+	 *                equal to that detailLevel
+	 */
+	private static LodDetail[][] lowerDetailArrays;
+	
+	
+	
+	
+	private LodDetail(int newLengthCount, int newDetailLevel)
+	{
+		detailLevel = (byte) newDetailLevel;
+		dataPointLengthCount = newLengthCount;
+		dataPointWidth = 16 / dataPointLengthCount;
+		
+		startX = new int[dataPointLengthCount * dataPointLengthCount];
+		endX = new int[dataPointLengthCount * dataPointLengthCount];
+		
+		startZ = new int[dataPointLengthCount * dataPointLengthCount];
+		endZ = new int[dataPointLengthCount * dataPointLengthCount];
+		
+		
+		int index = 0;
+		for(int x = 0; x < newLengthCount; x++)
+		{
+			for(int z = 0; z < newLengthCount; z++)
+			{
+				startX[index] = x * dataPointWidth;
+				startZ[index] = z * dataPointWidth;
+				
+				endX[index] = (x*dataPointWidth) + dataPointWidth;
+				endZ[index] = (z*dataPointWidth) + dataPointWidth;
+				
+				index++;
+			}
+		}
+		
+	}// constructor
+	
+	
+	
+	
+	
+	
+	/** 
+	 * Returns an array of all LodDetails that have a detail level
+	 * that is less than or equal to the given LodDetail
+	 */
+	public static LodDetail[] getSelfAndLowerDetails(LodDetail detail)
+	{
+		if (lowerDetailArrays == null)
+		{
+			// run first time setup
+			lowerDetailArrays = new LodDetail[LodDetail.values().length][];
+			
+			// go through each LodDetail
+			for(LodDetail currentDetail : LodDetail.values())
+			{
+				ArrayList<LodDetail> lowerDetails = new ArrayList<>();
+				
+				// find the details lower than currentDetail
+				for(LodDetail compareDetail : LodDetail.values())
+				{
+					if (currentDetail.detailLevel <= compareDetail.detailLevel)
+					{
+						lowerDetails.add(compareDetail);
+					}
+				}
+				
+				// have the highest detail item first in the list
+				Collections.sort(lowerDetails);
+				Collections.reverse(lowerDetails);
+				
+				lowerDetailArrays[currentDetail.detailLevel] = lowerDetails.toArray(new LodDetail[lowerDetails.size()]); 
+			}
+		}
+		
+		return lowerDetailArrays[detail.detailLevel];
+	}
+	
+	/** Returns what detail level should be used at a given distance and maxDistance. */
+	public static LodDetail getDetailForDistance(LodDetail maxDetailLevel, int distance, int maxDistance)
+	{
+		LodDetail[] lowerDetails = getSelfAndLowerDetails(maxDetailLevel);
+		int distaneBetweenDetails = maxDistance / lowerDetails.length;
+		int index = LodUtil.clamp(0, distance / distaneBetweenDetails, lowerDetails.length - 1);
+		
+		return lowerDetails[index];
+		
+	}
+	
+}
@@ -0,0 +1,50 @@
+/*
+ *    This file is part of 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.enums;
+
+/**
+ * NONE <br>
+ * BIOME_ONLY <br>
+ * BIOME_ONLY_SIMULATE_HEIGHT <br>
+ * SURFACE <br>
+ * FEATURES <br>
+ * SERVER <br><br>
+ * 
+ * In order of fastest to slowest.
+ * 
+ * @author James Seibel
+ * @author Leonardo Amato
+ * @version 8-7-2021
+ */
+public enum LodRenderDistance
+{
+	SHORT(32),
+
+	MEDIUM(64),
+
+	FAR(128);
+
+
+	/** The higher the number the more complete the generation is. */
+	public final int renderDistance;
+
+	LodRenderDistance(int complexity)
+	{
+		this.renderDistance = complexity;
+	}
+}
@@ -0,0 +1,61 @@
+/*
+ *    This file is part of 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.enums;
+
+import com.seibel.lod.builders.lodTemplates.AbstractLodTemplate;
+import com.seibel.lod.builders.lodTemplates.CubicLodTemplate;
+import com.seibel.lod.builders.lodTemplates.DynamicLodTemplate;
+import com.seibel.lod.builders.lodTemplates.TriangularLodTemplate;
+
+/**
+ * Cubic, Triangular, Dynamic
+ * 
+ * @author James Seibel
+ * @version 8-4-2021
+ */
+public enum LodTemplate
+{
+	// used for position
+
+	/** Chunks are rendered as
+	 * rectangular prisms. */
+	CUBIC(new CubicLodTemplate()),
+	
+	/** Chunks smoothly transition between
+	 * each other. */
+	TRIANGULAR(new TriangularLodTemplate()),
+	
+	/** Chunks smoothly transition between
+	 * each other, unless a neighboring chunk
+	 * is at a significantly different height. */
+	DYNAMIC(new DynamicLodTemplate());
+	
+	
+	public final AbstractLodTemplate template;
+	
+	private LodTemplate(AbstractLodTemplate newTemplate)
+	{
+		template = newTemplate;
+	}
+	
+	
+	public int getBufferMemoryForSingleLod()
+	{
+		return template.getBufferMemoryForSingleNode();
+	}
+}
@@ -0,0 +1,86 @@
+/*
+ *    This file is part of 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.enums;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumSet;
+
+/** 
+ * NE, SE, SW, NW <br>
+ * NORTH, SOUTH, EAST, WEST, <br>
+ * CENTER
+ * 
+ * @author James Seibel
+ * @version 05-30-2021
+ */
+public enum RelativeChunkPos
+{
+	/** +X, -Z */
+	NE(0, 1,-1),
+	/** +X, +Z */
+	SE(1, 1,1),
+	/** -X, +Z */
+	SW(2, -1,1),
+	/** -X, -Z */
+	NW(3, -1,-1),
+	
+	/** -Z */
+	NORTH(4, 0,-1),
+	/** +Z */
+	SOUTH(5, 0,1),
+	
+	/** +X */
+	EAST(6, 1,0),
+	/** -X */
+	WEST(7, -1,0),
+	
+	CENTER(8, 0,0);
+	
+	/** index used when referencing objects in an array */
+	public final int index;
+	
+	/** position relative to X CENTER */
+	public final int x;
+	/** position relative to Z CENTER */
+	public final int z;
+	
+	/** NORTH, SOUTH, EAST, WEST */
+	public static EnumSet<RelativeChunkPos> ADJACENT = EnumSet.of(NORTH, SOUTH, EAST, WEST);
+	/** NE, NW, SE, SW */
+	public static EnumSet<RelativeChunkPos> DIAGONAL = EnumSet.of(NE, NW, SE, SW);
+	
+	
+	public static EnumSet<RelativeChunkPos> NW_CORNER = EnumSet.of(WEST, NW, NORTH);
+	public static EnumSet<RelativeChunkPos> NE_CORNER = EnumSet.of(EAST, NE, NORTH);
+	public static EnumSet<RelativeChunkPos> SW_CORNER = EnumSet.of(WEST, SW, SOUTH);
+	public static EnumSet<RelativeChunkPos> SE_CORNER = EnumSet.of(EAST, SE, SOUTH);
+	
+	/** NW_CORNER, NE_CORNER, SW_CORNER, SE_CORNER <br>
+	 * Contains the 3 points surrounding a corner. */
+	public static ArrayList<EnumSet<RelativeChunkPos>> CORNERS = new ArrayList<EnumSet<RelativeChunkPos>>( Arrays.asList(NW_CORNER, NE_CORNER, SW_CORNER, SE_CORNER) );
+	
+	private RelativeChunkPos(int newIndex, int newX, int newZ)
+	{
+		index = newIndex;
+		x = newX;
+		z = newZ;
+	}
+}
+
+
@@ -0,0 +1,18 @@
+package com.seibel.lod.enums;
+
+/**
+ * NONE, DARKEN_SIDES
+ * 
+ * @author James Seibel
+ * @version 7-25-2020
+ */
+public enum ShadingMode
+{
+	/** LODs will have the same lighting on every side.
+	Fastest, but can make large similarly colored areas hard to differentiate */
+	NONE,
+	
+	/** LODs will have darker sides and bottoms to simulate top down lighting.
+	Fastest */
+	DARKEN_SIDES;
+}
@@ -0,0 +1,386 @@
+/*
+ *    This file is part of 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.handlers;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import com.seibel.lod.enums.DistanceGenerationMode;
+import com.seibel.lod.objects.LevelContainer;
+import com.seibel.lod.objects.LodDimension;
+import com.seibel.lod.objects.LodRegion;
+import com.seibel.lod.objects.RegionPos;
+import com.seibel.lod.proxy.ClientProxy;
+import com.seibel.lod.util.LodThreadFactory;
+import com.seibel.lod.util.LodUtil;
+
+/**
+ * This object handles creating LodRegions
+ * from files and saving LodRegion objects
+ * to file.
+ *
+ * @author James Seibel
+ * @version 8-24-2021
+ */
+public class LodDimensionFileHandler
+{
+	/**
+	 * This is what separates each piece of data
+	 */
+	public static final char DATA_DELIMITER = ',';
+
+
+	private LodDimension loadedDimension = null;
+	public long regionLastWriteTime[][];
+
+	private File dimensionDataSaveFolder;
+
+	/**
+	 * lod
+	 */
+	private static final String FILE_NAME_PREFIX = "lod";
+	/**
+	 * .txt
+	 */
+	private static final String FILE_EXTENSION = ".txt";
+	/**
+	 * lod/
+	 */
+	private static final String LOD_FOLDER_NAME = "lod";
+	/**
+	 * detail-#
+	 */
+	private static final String DETAIL_FOLDER_NAME_PREFIX = "detail-";
+
+	/**
+	 * .tmp <br>
+	 * Added to the end of the file path when saving to prevent
+	 * nulling a currently existing file. <br>
+	 * After the file finishes saving it will end with
+	 * FILE_EXTENSION.
+	 */
+	private static final String TMP_FILE_EXTENSION = ".tmp";
+
+	/**
+	 * This is the file version currently accepted by this
+	 * file handler, older versions (smaller numbers) will be deleted and overwritten,
+	 * newer versions (larger numbers) will be ignored and won't be read.
+	 */
+	public static final int LOD_SAVE_FILE_VERSION = 4;
+
+	/**
+	 * This is the string written before the file version
+	 */
+	private static final String LOD_FILE_VERSION_PREFIX = "lod_save_file_version";
+
+	/**
+	 * Allow saving asynchronously, but never try to save multiple regions
+	 * at a time
+	 */
+	private ExecutorService fileWritingThreadPool = Executors.newSingleThreadExecutor(new LodThreadFactory(this.getClass().getSimpleName()));
+
+
+	public LodDimensionFileHandler(File newSaveFolder, LodDimension newLoadedDimension)
+	{
+		if (newSaveFolder == null)
+			throw new IllegalArgumentException("LodDimensionFileHandler requires a valid File location to read and write to.");
+
+		dimensionDataSaveFolder = newSaveFolder;
+
+		loadedDimension = newLoadedDimension;
+		// these two variable are used in sync with the LodDimension
+		regionLastWriteTime = new long[loadedDimension.getWidth()][loadedDimension.getWidth()];
+		for (int i = 0; i < loadedDimension.getWidth(); i++)
+			for (int j = 0; j < loadedDimension.getWidth(); j++)
+				regionLastWriteTime[i][j] = -1;
+	}
+
+
+	//================//
+	// read from file //
+	//================//
+
+	/**
+	 * Return the LodRegion region at the given coordinates.
+	 * (null if the file doesn't exist)
+	 */
+	public LodRegion loadRegionFromFile(byte detailLevel, RegionPos regionPos, DistanceGenerationMode generationMode)
+	{
+		int regionX = regionPos.x;
+		int regionZ = regionPos.z;
+		LodRegion region = new LodRegion(LodUtil.REGION_DETAIL_LEVEL,regionPos, generationMode);
+		for (byte tempDetailLevel = LodUtil.REGION_DETAIL_LEVEL; tempDetailLevel >= detailLevel; tempDetailLevel--)
+		{
+			try
+			{
+				String fileName = getFileNameAndPathForRegion(regionX, regionZ, generationMode, tempDetailLevel);
+
+				// if the fileName was null that means the folder is inaccessible
+				// for some reason
+				if (fileName == null)
+					throw new IllegalArgumentException("Game folder is not accessible");
+
+
+				File f = new File(fileName);
+
+				if (!f.exists())
+				{
+					// there wasn't a file, don't
+					// return anything
+					continue;
+				}
+				String data = "";
+				BufferedReader bufferedReader = new BufferedReader(new FileReader(f));
+				data = bufferedReader.readLine();
+				int fileVersion = -1;
+
+				if (data != null && !data.isEmpty())
+				{
+					// try to get the file version
+					try
+					{
+						fileVersion = Integer.parseInt(data.substring(data.indexOf(' ')).trim());
+					} catch (NumberFormatException | StringIndexOutOfBoundsException e)
+					{
+						// this file doesn't have a version
+						// keep the version as -1
+						fileVersion = -1;
+					}
+
+					// check if this file can be read by this file handler
+					if (fileVersion < LOD_SAVE_FILE_VERSION)
+					{
+						// the file we are reading is an older version,
+						// close the reader and delete the file.
+						bufferedReader.close();
+						f.delete();
+						ClientProxy.LOGGER.info("Outdated LOD region file for region: (" + regionX + "," + regionZ + ") version: " + fileVersion +
+								                        ", version requested: " + LOD_SAVE_FILE_VERSION +
+								                        " File was been deleted.");
+
+						break;
+					} else if (fileVersion > LOD_SAVE_FILE_VERSION)
+					{
+						// the file we are reading is a newer version,
+						// close the reader and ignore the file, we don't
+						// want to accidently delete anything the user may want.
+						bufferedReader.close();
+						ClientProxy.LOGGER.info("Newer LOD region file for region: (" + regionX + "," + regionZ + ") version: " + fileVersion +
+								                        ", version requested: " + LOD_SAVE_FILE_VERSION +
+								                        " this region will not be written to in order to protect the newer file.");
+
+						break;
+					}
+				} else
+				{
+					// there is no data in this file
+					bufferedReader.close();
+					break;
+				}
+
+				// this file is a readable version, begin reading the file
+				data = bufferedReader.readLine();
+
+				bufferedReader.close();
+				region.addLevel(new LevelContainer(data));
+			} catch (Exception e)
+			{
+				// the buffered reader encountered a
+				// problem reading the file
+
+				e.printStackTrace();
+			}
+		}
+		if (region.getMinDetailLevel() >= detailLevel)
+			region.expand(detailLevel);
+		return region;
+	}
+
+
+	//==============//
+	// Save to File //
+	//==============//
+
+	/**
+	 * Save all dirty regions in this LodDimension to file.
+	 */
+	public void saveDirtyRegionsToFileAsync()
+	{
+		fileWritingThreadPool.execute(saveDirtyRegionsThread);
+	}
+
+	private Thread saveDirtyRegionsThread = new Thread(() ->
+	{
+		try
+		{
+			for (int i = 0; i < loadedDimension.getWidth(); i++)
+			{
+				for (int j = 0; j < loadedDimension.getWidth(); j++)
+				{
+					if (loadedDimension.isRegionDirty[i][j] && loadedDimension.regions[i][j] != null)
+					{
+						saveRegionToFile(loadedDimension.regions[i][j]);
+						loadedDimension.isRegionDirty[i][j] = false;
+					}
+				}
+			}
+		} catch (Exception e)
+		{
+			e.printStackTrace();
+		}
+	});
+
+	/**
+	 * Save a specific region to disk.<br>
+	 * Note: <br>
+	 * 1. If a file already exists for a newer version
+	 * the file won't be written.<br>
+	 * 2. This will save to the LodDimension that this
+	 * handler is associated with.
+	 */
+	private void saveRegionToFile(LodRegion region)
+	{
+		// convert to region coordinates
+		int x = region.regionPosX;
+		int z = region.regionPosZ;
+		for (byte detailLevel = region.getMinDetailLevel(); detailLevel <= LodUtil.REGION_DETAIL_LEVEL; detailLevel++)
+		{
+			String fileName = getFileNameAndPathForRegion(x, z, region.getGenerationMode(), detailLevel);
+			File oldFile = new File(fileName);
+
+			// if the fileName was null that means the folder is inaccessible
+			// for some reason
+			if (fileName == null)
+			{
+				ClientProxy.LOGGER.warn("Unable to save region [" + x + ", " + z + "] to file.");
+				return;
+			}
+
+
+			try
+			{
+				// make sure the file and folder exists
+				if (!oldFile.exists())
+				{
+					// the file doesn't exist,
+					// create it and the folder if need be
+					if (!oldFile.getParentFile().exists())
+						oldFile.getParentFile().mkdirs();
+					oldFile.createNewFile();
+				} else
+				{
+					// the file exists, make sure it
+					// is the correct version.
+					// (to make sure we don't overwrite a newer
+					// version file if it exists)
+
+					BufferedReader br = new BufferedReader(new FileReader(oldFile));
+					String s = br.readLine();
+					int fileVersion = LOD_SAVE_FILE_VERSION;
+
+					if (s != null && !s.isEmpty())
+					{
+						// try to get the file version
+						try
+						{
+							fileVersion = Integer.parseInt(s.substring(s.indexOf(' ')).trim());
+						} catch (NumberFormatException | StringIndexOutOfBoundsException e)
+						{
+							// this file doesn't have a correctly formated version
+							// just overwrite the file
+						}
+					}
+					br.close();
+
+					// check if this file can be written to by the file handler
+					if (fileVersion <= LOD_SAVE_FILE_VERSION)
+					{
+						// we are good to continue and overwrite the old file
+					} else // if(fileVersion > LOD_SAVE_FILE_VERSION)
+					{
+						// the file we are reading is a newer version,
+						// don't write anything, we don't want to accidently
+						// delete anything the user may want.
+						return;
+					}
+				}
+
+				// the old file is good, now create a new save file
+				File newFile = new File(fileName + TMP_FILE_EXTENSION);
+				FileWriter fw = new FileWriter(newFile);
+
+				// add the version of this file
+				fw.write(LOD_FILE_VERSION_PREFIX + " " + LOD_SAVE_FILE_VERSION + "\n");
+
+				// add each LodChunk to the file
+				fw.write(region.getLevel(detailLevel).toString());
+				fw.close();
+
+				// overwrite the old file with the new one
+				Files.move(newFile.toPath(), oldFile.toPath(), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+			} catch (Exception e)
+			{
+				ClientProxy.LOGGER.error("LOD file write error: ");
+				e.printStackTrace();
+			}
+		}
+	}
+
+
+	//================//
+	// helper methods //
+	//================//
+
+
+	/**
+	 * Return the name of the file that should contain the
+	 * region at the given x and z. <br>
+	 * Returns null if this object isn't ready to read and write. <br><br>
+	 * <p>
+	 * example: "lod.0.0.txt" <br><br>
+	 * <p>
+	 * Returns null if there is an IO Exception.
+	 */
+	private String getFileNameAndPathForRegion(int regionX, int regionZ, DistanceGenerationMode generationMode, byte detailLevel)
+	{
+		try
+		{
+			// saveFolder is something like
+			// ".\Super Flat\DIM-1\data"
+			// or
+			// ".\Super Flat\data"
+			return dimensionDataSaveFolder.getCanonicalPath() + File.separatorChar +
+					       generationMode.toString() + File.separatorChar +
+					       DETAIL_FOLDER_NAME_PREFIX + detailLevel + File.separatorChar +
+					       FILE_NAME_PREFIX + "." + regionX + "." + regionZ + FILE_EXTENSION;
+		} catch (IOException | SecurityException e)
+		{
+			ClientProxy.LOGGER.warn("Unable to get the filename for the region [" + regionX + ", " + regionZ + "], error: [" + e.getMessage() + "], stacktrace: ");
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+}
@@ -0,0 +1,113 @@
+/*
+ *    This file is part of 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.handlers;
+
+import java.lang.reflect.Field;
+
+import com.seibel.lod.enums.FogQuality;
+
+import net.minecraft.client.Minecraft;
+
+/**
+ * This object is used to get variables from methods
+ * where they are private. Specifically the fog setting
+ * in Optifine.
+ *
+ * @author James Seibel
+ * @version 7-03-2021
+ */
+public class ReflectionHandler
+{
+	private Minecraft mc = Minecraft.getInstance();
+	public Field ofFogField = null;
+
+	public ReflectionHandler()
+	{
+		setupFogField();
+	}
+
+
+	/**
+	 * Similar to setupFovMethod.
+	 */
+	private void setupFogField()
+	{
+		// get every variable from the entity renderer
+		Field[] optionFields = mc.options.getClass().getDeclaredFields();
+
+		// try and find the ofFogType variable in gameSettings
+		for (Field field : optionFields)
+		{
+			if (field.getName().equals("ofFogType"))
+			{
+				ofFogField = field;
+				return;
+			}
+		}
+
+		// we didn't find the field,
+		// either optifine isn't installed, or
+		// optifine changed the name of the variable
+		ofFogField = null;
+	}
+
+
+	/**
+	 * Get what type of fog optifine is currently set to render.
+	 */
+	public FogQuality getFogQuality()
+	{
+		if (ofFogField == null)
+		{
+			// either optifine isn't installed,
+			// the variable name was changed, or
+			// the setup method wasn't called yet.
+			return FogQuality.FANCY;
+		}
+
+		int returnNum = 0;
+
+		try
+		{
+			returnNum = (int) ofFogField.get(mc.options);
+		} catch (IllegalArgumentException | IllegalAccessException e)
+		{
+			e.printStackTrace();
+		}
+
+		switch (returnNum)
+		{
+			// optifine's "default" option,
+			// it should never be called in this case
+			case 0:
+				return FogQuality.FAST;
+
+			// normal options
+			case 1:
+				return FogQuality.FAST;
+			case 2:
+				return FogQuality.FANCY;
+			case 3:
+				return FogQuality.OFF;
+
+			default:
+				return FogQuality.FAST;
+		}
+	}
+
+}
@@ -0,0 +1,62 @@
+/*
+ *    This file is part of 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.mixin;
+
+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.matrix.MatrixStack;
+import com.seibel.lod.LodMain;
+import com.seibel.lod.config.LodConfig;
+
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.WorldRenderer;
+
+/**
+ * This class is used to mix in my rendering code
+ * before Minecraft starts rendering blocks.
+ * If this wasn't done the LODs would render on top
+ * of the normal terrain.
+ * 
+ * @author James Seibel
+ * @version 05-29-2021
+ */
+@Mixin(WorldRenderer.class)
+public class MixinWorldRenderer
+{
+	private static float previousPartialTicks = 0;
+	
+	@Inject(at = @At("RETURN"), method = "renderSky(Lcom/mojang/blaze3d/matrix/MatrixStack;F)V", cancellable = false)
+	private void renderSky(MatrixStack matrixStackIn, float partialTicks, CallbackInfo callback)
+	{
+		// get the partial ticks since renderBlockLayer doesn't
+		// have access to them
+		previousPartialTicks = partialTicks;
+	}
+	
+	@Inject(at = @At("HEAD"), method = "renderChunkLayer(Lnet/minecraft/client/renderer/RenderType;Lcom/mojang/blaze3d/matrix/MatrixStack;DDD)V", cancellable = false)
+	private void renderChunkLayer(RenderType renderType, MatrixStack matrixStackIn, double xIn, double yIn, double zIn, CallbackInfo callback)
+	{
+		// only render if LODs are enabled and
+		// only render before solid blocks
+		if (LodConfig.CLIENT.graphics.drawLODs.get() && renderType.equals(RenderType.solid()))
+			LodMain.client_proxy.renderLods(previousPartialTicks);
+	}
+}
@@ -0,0 +1,48 @@
+package com.seibel.lod.objects;
+
+public class DataPoint
+{
+
+	public static short[] createDataPoint(int height, int depth, int red, int green, int blue)
+	{
+		return new short[]{(short) height, (short) depth, (short) red, (short) green, (short) blue};
+	}
+
+	public static short getHeight(short[] dataPoint)
+	{
+		return dataPoint[0];
+	}
+
+	public static short getDepth(short[] dataPoint)
+	{
+		return dataPoint[1];
+	}
+
+	public static short getRed(short[] dataPoint)
+	{
+		return dataPoint[2];
+	}
+
+	public static short getGreen(short[] dataPoint)
+	{
+		return dataPoint[3];
+	}
+
+	public static short getBlue(short[] dataPoint)
+	{
+		return dataPoint[4];
+	}
+
+	public static short[] getHeightDepth(short[] dataPoint)
+	{
+		return new short[]{dataPoint[0], dataPoint[1]};
+	}
+
+	public static int getColor(short[] dataPoint)
+	{
+		int R = (dataPoint[2] << 16) & 0x00FF0000;
+		int G = (dataPoint[3] << 8) & 0x0000FF00;
+		int B = dataPoint[4] & 0x000000FF;
+		return 0xFF000000 | R | G | B;
+	}
+}
@@ -0,0 +1,100 @@
+package com.seibel.lod.objects;
+
+import java.io.Serializable;
+
+import com.seibel.lod.util.LodUtil;
+
+public class LevelContainer implements Serializable
+{
+
+	public static final char DATA_DELIMITER = ',';
+
+	public final byte detailLevel;
+
+	public final byte[][][] colors;
+
+	public final short[][] height;
+
+	public final short[][] depth;
+
+	public final boolean[][] dataExistence;
+
+	public LevelContainer(byte detailLevel, byte[][][] colors, short[][] height, short[][] depth, boolean[][] dataExistence)
+	{
+		this.detailLevel = detailLevel;
+		this.colors = colors;
+		this.height = height;
+		this.depth = depth;
+		this.dataExistence = dataExistence;
+	}
+
+	public LevelContainer(String data)
+	{
+
+		int index = 0;
+		int lastIndex = 0;
+
+
+		index = data.indexOf(DATA_DELIMITER, 0);
+		this.detailLevel = (byte) Integer.parseInt(data.substring(0, index));
+		int size = (int) Math.pow(2, LodUtil.REGION_DETAIL_LEVEL - detailLevel);
+
+		this.colors = new byte[size][size][3];
+		this.height = new short[size][size];
+		this.depth = new short[size][size];
+		this.dataExistence = new boolean[size][size];
+		int intCol;
+		for (int x = 0; x < size; x++)
+		{
+			for (int z = 0; z < size; z++)
+			{
+				lastIndex = index;
+				index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
+				intCol = Integer.parseInt(data.substring(lastIndex + 1, index), 16);
+				colors[x][z][0] = (byte) ((intCol >> 16) - 128);
+				colors[x][z][1] = (byte) ((intCol >> 8) - 128);
+				colors[x][z][2] = (byte) (intCol - 128);
+
+				lastIndex = index;
+				index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
+				height[x][z] = Short.parseShort(data.substring(lastIndex + 1, index), 16);
+
+				lastIndex = index;
+				index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
+				depth[x][z] = Short.parseShort(data.substring(lastIndex + 1, index), 16);
+
+				lastIndex = index;
+				index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
+				dataExistence[x][z] = Boolean.parseBoolean(data.substring(lastIndex + 1, index));
+			}
+		}
+
+	}
+
+	@Override
+	public String toString()
+	{
+		StringBuilder stringBuilder = new StringBuilder();
+		int combinedCol;
+		int size = (int) Math.pow(2, LodUtil.REGION_DETAIL_LEVEL - detailLevel);
+		stringBuilder.append(detailLevel);
+		stringBuilder.append(DATA_DELIMITER);
+		for (int x = 0; x < size; x++)
+		{
+			for (int z = 0; z < size; z++)
+			{
+				//Converting the colors to intColor and then to HEX
+				combinedCol = ((colors[x][z][0] + 128) << 16) | ((colors[x][z][1] + 128) << 8) | ((colors[x][z][2] + 128));
+				stringBuilder.append(Integer.toHexString(combinedCol));
+				stringBuilder.append(DATA_DELIMITER);
+				stringBuilder.append(Integer.toHexString(height[x][z] & 0xffff));
+				stringBuilder.append(DATA_DELIMITER);
+				stringBuilder.append(Integer.toHexString(depth[x][z] & 0xffff));
+				stringBuilder.append(DATA_DELIMITER);
+				stringBuilder.append(dataExistence[x][z]);
+				stringBuilder.append(DATA_DELIMITER);
+			}
+		}
+		return stringBuilder.toString();
+	}
+}
@@ -0,0 +1,7 @@
+package com.seibel.lod.objects.LevelPos;
+
+public interface ImmutableLevelPos
+{
+    public LevelPos getConvertedLevelPos(byte newDetailLevel);
+    public LevelPos getRegionModuleLevelPos();
+}
@@ -0,0 +1,415 @@
+package com.seibel.lod.objects.LevelPos;
+
+import com.seibel.lod.objects.RegionPos;
+import com.seibel.lod.util.LodUtil;
+import net.minecraft.util.math.ChunkPos;
+
+import java.util.Comparator;
+
+public class LevelPos implements Cloneable, ImmutableLevelPos, MutableLevelPos, Comparable<LevelPos>
+{
+    public byte detailLevel;
+    public int posX;
+    public int posZ;
+    public boolean flag;
+
+    public LevelPos()
+    {
+    }
+
+    public LevelPos(byte detailLevel, int posX, int posZ)
+    {
+        this.posX = posX;
+        this.posZ = posZ;
+        this.detailLevel = detailLevel;
+    }
+
+    /**
+     * this operation does not change the state
+     */
+    public LevelPos getConvertedLevelPos(byte newDetailLevel)
+    {
+        if (newDetailLevel >= detailLevel)
+        {
+            int width = 1 << (newDetailLevel - detailLevel);
+            return new LevelPos(
+                    newDetailLevel,
+                    Math.floorDiv(posX, width),
+                    Math.floorDiv(posZ, width));
+        } else
+        {
+            int width = 1 << (detailLevel - newDetailLevel);
+            return new LevelPos(
+                    newDetailLevel,
+                    posX * width,
+                    posZ * width);
+        }
+    }
+
+    /**
+     * this operation does not change the state
+     */
+    public LevelPos getRegionModuleLevelPos()
+    {
+        int width = 1 << (LodUtil.REGION_DETAIL_LEVEL - detailLevel);
+        return new LevelPos(
+                detailLevel,
+                Math.floorMod(posX, width),
+                Math.floorMod(posZ, width));
+    }
+
+    /**
+     * this operation changes the state
+     */
+    public void convert(byte newDetailLevel)
+    {
+        if (newDetailLevel >= detailLevel)
+        {
+            int width = 1 << (newDetailLevel - detailLevel);
+            detailLevel = newDetailLevel;
+            posX = Math.floorDiv(posX, width);
+            posZ = Math.floorDiv(posZ, width);
+        } else
+        {
+            int width = 1 << (detailLevel - newDetailLevel);
+            detailLevel = newDetailLevel;
+            posX = posX * width;
+            posZ = posZ * width;
+        }
+    }
+
+    /**
+     * this operation changes the state
+     */
+    public void performRegionModule()
+    {
+        int width = 1 << (LodUtil.REGION_DETAIL_LEVEL - detailLevel);
+        posX = Math.floorMod(posX, width);
+        posZ = Math.floorMod(posZ, width);
+    }
+
+    /**
+     * this operation changes the state
+     */
+    public void applyOffset(int xOffset, int zOffset)
+    {
+        posX = posX + xOffset;
+        posX = posZ + zOffset;
+    }
+
+    /**
+     * this operation changes the state
+     */
+    public void changeParameters(byte newDetailLevel, int newPosX, int newPosZ)
+    {
+        detailLevel = newDetailLevel;
+        posX = newPosX;
+        posZ = newPosZ;
+    }
+
+    public RegionPos getRegionPos()
+    {
+        int width = 1 << (LodUtil.REGION_DETAIL_LEVEL - detailLevel);
+        return new RegionPos(
+                Math.floorDiv(posX, width),
+                Math.floorDiv(posZ, width));
+    }
+
+    public int getRegionPosX()
+    {
+        int width = 1 << (LodUtil.REGION_DETAIL_LEVEL - detailLevel);
+        return Math.floorDiv(posX, width);
+    }
+
+    public int getRegionPosZ()
+    {
+        int width = 1 << (LodUtil.REGION_DETAIL_LEVEL - detailLevel);
+        return Math.floorDiv(posZ, width);
+    }
+
+    public int getChunkPosX()
+    {
+        if (LodUtil.CHUNK_DETAIL_LEVEL >= detailLevel)
+        {
+            int width = 1 << (LodUtil.CHUNK_DETAIL_LEVEL - detailLevel);
+            return Math.floorDiv(posX, width);
+        } else
+        {
+            int width = 1 << (detailLevel - LodUtil.CHUNK_DETAIL_LEVEL);
+            return posX * width;
+        }
+    }
+
+    public int getChunkPosZ()
+    {
+        if (LodUtil.CHUNK_DETAIL_LEVEL >= detailLevel)
+        {
+            int width = 1 << (LodUtil.CHUNK_DETAIL_LEVEL - detailLevel);
+            return Math.floorDiv(posZ, width);
+        } else
+        {
+            int width = 1 << (detailLevel - LodUtil.CHUNK_DETAIL_LEVEL);
+            return posZ * width;
+        }
+    }
+
+    public ChunkPos getChunkPos()
+    {
+        if (LodUtil.CHUNK_DETAIL_LEVEL >= detailLevel)
+        {
+            int width = 1 << (LodUtil.CHUNK_DETAIL_LEVEL - detailLevel);
+            return new ChunkPos(
+                    Math.floorDiv(posX, width),
+                    Math.floorDiv(posZ, width));
+        } else
+        {
+            int width = 1 << (detailLevel - LodUtil.CHUNK_DETAIL_LEVEL);
+            return new ChunkPos(
+                    posX * width,
+                    posZ * width);
+        }
+    }
+
+    /**
+     * TODO fix the region disappearing for a second
+     */
+
+    public int maxDistance(int playerPosX, int playerPosZ, int regionPosX, int regionPosZ)
+    {
+        int width = 1 << detailLevel;
+
+        int startPosX = regionPosX * 512 + posX * width;
+        int startPosZ = regionPosZ * 512 + posZ * width;
+        int endPosX = startPosX + width;
+        int endPosZ = startPosZ + width;
+
+        int maxDistance = (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - startPosZ, 2));
+        maxDistance = Math.max(maxDistance, (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+        maxDistance = Math.max(maxDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - startPosZ, 2)));
+        maxDistance = Math.max(maxDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+
+        return maxDistance;
+    }
+
+    public int maxDistance(int playerPosX, int playerPosZ)
+    {
+        int width = 1 << detailLevel;
+
+        int startPosX = posX * width;
+        int startPosZ = posZ * width;
+        int endPosX = startPosX + width;
+        int endPosZ = startPosZ + width;
+
+        int maxDistance = (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - startPosZ, 2));
+        maxDistance = Math.max(maxDistance, (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+        maxDistance = Math.max(maxDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - startPosZ, 2)));
+        maxDistance = Math.max(maxDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+
+        return maxDistance;
+    }
+
+    public int minDistance(int playerPosX, int playerPosZ, int regionPosX, int regionPosZ)
+    {
+        int width = 1 << detailLevel;
+
+        int startPosX = regionPosX * 512 + posX * width;
+        int startPosZ = regionPosZ * 512 + posZ * width;
+        int endPosX = startPosX + width;
+        int endPosZ = startPosZ + width;
+
+        boolean inXArea = playerPosX >= startPosX && playerPosX <= endPosX;
+        boolean inZArea = playerPosZ >= startPosZ && playerPosZ <= endPosZ;
+        if (inXArea && inZArea)
+        {
+            return 0;
+        } else if (inXArea)
+        {
+            return Math.min(
+                    Math.abs(playerPosZ - startPosZ),
+                    Math.abs(playerPosZ - endPosZ)
+            );
+        } else if (inZArea)
+        {
+            return Math.min(
+                    Math.abs(playerPosX - startPosX),
+                    Math.abs(playerPosX - endPosX)
+            );
+        } else
+        {
+            int minDistance = (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - startPosZ, 2));
+            minDistance = Math.min(minDistance, (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+            minDistance = Math.min(minDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - startPosZ, 2)));
+            minDistance = Math.min(minDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+            return minDistance;
+        }
+    }
+
+    public int minDistance(int playerPosX, int playerPosZ)
+    {
+        int width = 1 << detailLevel;
+
+        int startPosX = posX * width;
+        int startPosZ = posZ * width;
+        int endPosX = startPosX + width;
+        int endPosZ = startPosZ + width;
+
+        boolean inXArea = playerPosX >= startPosX && playerPosX <= endPosX;
+        boolean inZArea = playerPosZ >= startPosZ && playerPosZ <= endPosZ;
+        if (inXArea && inZArea)
+        {
+            return 0;
+        } else if (inXArea)
+        {
+            return Math.min(
+                    Math.abs(playerPosZ - startPosZ),
+                    Math.abs(playerPosZ - endPosZ)
+            );
+        } else if (inZArea)
+        {
+            return Math.min(
+                    Math.abs(playerPosX - startPosX),
+                    Math.abs(playerPosX - endPosX)
+            );
+        } else
+        {
+            int minDistance = (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - startPosZ, 2));
+            minDistance = Math.min(minDistance, (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+            minDistance = Math.min(minDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - startPosZ, 2)));
+            minDistance = Math.min(minDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+            return minDistance;
+        }
+    }
+
+    public static LevelPosDistanceComparator getPosComparator(int playerPosX, int playerPosZ)
+    {
+        return new LevelPosDistanceComparator(playerPosX, playerPosZ);
+    }
+
+    public static LevelPosDetailComparator getPosAndDetailComparator(int playerPosX, int playerPosZ)
+    {
+        return new LevelPosDetailComparator(playerPosX, playerPosZ);
+    }
+
+    public static class LevelPosDistanceComparator implements Comparator<LevelPos>
+    {
+        int playerPosX;
+        int playerPosZ;
+
+        public LevelPosDistanceComparator(int playerPosX, int playerPosZ)
+        {
+            this.playerPosX = playerPosX;
+            this.playerPosZ = playerPosZ;
+        }
+
+        @Override
+        public int compare(LevelPos first, LevelPos second)
+        {
+            return Integer.compare(
+                    first.minDistance(playerPosX, playerPosZ),
+                    second.minDistance(playerPosX, playerPosZ));
+        }
+    }
+
+    public static class LevelPosDetailComparator implements Comparator<LevelPos>
+    {
+        int playerPosX;
+        int playerPosZ;
+
+        public LevelPosDetailComparator(int playerPosX, int playerPosZ)
+        {
+            this.playerPosX = playerPosX;
+            this.playerPosZ = playerPosZ;
+        }
+
+        @Override
+        public int compare(LevelPos first, LevelPos second)
+        {
+            int compareResult = Integer.compare(second.detailLevel, first.detailLevel);
+            if (compareResult == 0)
+            {
+                compareResult = Integer.compare(
+                        first.minDistance(playerPosX, playerPosZ),
+                        second.minDistance(playerPosX, playerPosZ));
+            }
+            return compareResult;
+        }
+    }
+
+    public static LevelPosComparator getComparator()
+    {
+        return new LevelPosComparator();
+    }
+
+    public static class LevelPosComparator implements Comparator<LevelPos>
+    {
+        @Override
+        public int compare(LevelPos first, LevelPos second)
+        {
+            int compareResult = Integer.compare(first.detailLevel, second.detailLevel);
+            if (compareResult == 0)
+            {
+                compareResult = Integer.compare(
+                        first.posX,
+                        second.posX);
+            }
+            if (compareResult == 0)
+            {
+                compareResult = Integer.compare(
+                        first.posZ,
+                        second.posZ);
+            }
+            return compareResult;
+        }
+    }
+
+    @Override
+    public int compareTo(LevelPos other)
+    {
+        int compareResult = Integer.compare(this.detailLevel, other.detailLevel);
+        if (compareResult == 0)
+        {
+            compareResult = Integer.compare(
+                    this.posX,
+                    other.posX);
+        }
+        if (compareResult == 0)
+        {
+            compareResult = Integer.compare(
+                    this.posZ,
+                    other.posZ);
+        }
+        return compareResult;
+    }
+
+
+    @Override
+    public LevelPos clone()
+    {
+        return new LevelPos(detailLevel, posX, posZ);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        int hash = 7;
+        hash = 31 * hash + (int) detailLevel;
+        hash = 31 * hash + posX;
+        hash = 31 * hash + posZ;
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object other)
+    {
+        return (this.detailLevel == ((LevelPos) other).detailLevel &&
+                this.posX == ((LevelPos) other).posX &&
+                this.posZ == ((LevelPos) other).posZ);
+    }
+
+    @Override
+    public String toString()
+    {
+        String s = (detailLevel + " " + posX + " " + posZ);
+        return s;
+    }
+}
@@ -0,0 +1,14 @@
+package com.seibel.lod.objects.LevelPos;
+
+import com.seibel.lod.util.LodUtil;
+
+public interface MutableLevelPos
+{
+	public void convert(byte newDetailLevel);
+
+	public void performRegionModule();
+
+	public void applyOffset(int xOffset, int zOffset);
+
+	public void changeParameters(byte newDetailLevel, int newPosX, int newPosZ);
+}
@@ -0,0 +1,226 @@
+package com.seibel.lod.objects;
+
+import com.seibel.lod.util.LodUtil;
+import net.minecraft.util.math.ChunkPos;
+
+import java.util.Comparator;
+
+public class LevelPosUtil
+{
+	public static int[] convert(int[] levelPos, byte newDetailLevel)
+	{
+		return convert(getDetailLevel(levelPos), getPosX(levelPos), getPosZ(levelPos), newDetailLevel);
+	}
+
+	public static int[] convert(byte detailLevel, int posX, int posZ, byte newDetailLevel)
+	{
+		int width;
+		if (newDetailLevel >= detailLevel)
+		{
+			width = 1 << (newDetailLevel - detailLevel);
+			return createLevelPos(
+					newDetailLevel,
+					Math.floorDiv(posX, width),
+					Math.floorDiv(posZ, width));
+		} else
+		{
+			width = 1 << (detailLevel - newDetailLevel);
+			return createLevelPos(
+					newDetailLevel,
+					posX * width,
+					posZ * width);
+		}
+	}
+
+	public static int[] createLevelPos(byte detailLevel, int posX, int posZ)
+	{
+		return new int[]{detailLevel, posX, posZ};
+	}
+
+	public static int[] createLevelPos(byte detailLevel, int posX, int posZ, int distance)
+	{
+		return new int[]{detailLevel, posX, posZ, distance};
+	}
+
+
+	public static byte getDetailLevel(int[] levelPos)
+	{
+		return (byte) levelPos[0];
+	}
+
+	public static int getPosX(int[] levelPos)
+	{
+		return levelPos[1];
+	}
+
+	public static int getPosZ(int[] levelPos)
+	{
+		return levelPos[2];
+	}
+
+	public static int getDistance(int[] levelPos)
+	{
+		return levelPos[3];
+	}
+
+	public static int[] getRegionModule(int[] levelPos)
+	{
+		return getRegionModule(getDetailLevel(levelPos), getPosX(levelPos), getPosZ(levelPos));
+	}
+
+	public static int[] getRegionModule(byte detailLevel, int posX, int posZ)
+	{
+		int width = 1 << (LodUtil.REGION_DETAIL_LEVEL - detailLevel);
+		return createLevelPos(
+				detailLevel,
+				Math.floorMod(posX, width),
+				Math.floorMod(posZ, width));
+	}
+
+	public static int[] applyOffset(int[] levelPos, int xOffset, int zOffset)
+	{
+		return createLevelPos(
+				getDetailLevel(levelPos),
+				getPosX(levelPos) + xOffset,
+				getPosZ(levelPos) + zOffset);
+	}
+
+	public static int[] applyLevelOffset(int[] levelPos, byte detailOffset, int xOffset, int zOffset)
+	{
+		return createLevelPos(
+				getDetailLevel(levelPos),
+				getPosX(levelPos) + xOffset * (1 << detailOffset),
+				getPosZ(levelPos) + zOffset * (1 << detailOffset));
+	}
+
+	public static int getRegionPosX(int[] levelPos)
+	{
+		int width = 1 << (LodUtil.REGION_DETAIL_LEVEL - getDetailLevel(levelPos));
+		return Math.floorDiv(getPosX(levelPos), width);
+	}
+
+	public static int getRegionPosZ(int[] levelPos)
+	{
+		int width = 1 << (LodUtil.REGION_DETAIL_LEVEL - getDetailLevel(levelPos));
+		return Math.floorDiv(getPosZ(levelPos), width);
+	}
+
+	public static int getChunkPosX(int[] levelPos)
+	{
+		levelPos = convert(levelPos, LodUtil.CHUNK_DETAIL_LEVEL);
+		return getPosX(levelPos);
+	}
+
+	public static int getChunkPosZ(int[] levelPos)
+	{
+		levelPos = convert(levelPos, LodUtil.CHUNK_DETAIL_LEVEL);
+		return getPosZ(levelPos);
+	}
+
+	public static int maxDistance(int[] levelPos, int playerPosX, int playerPosZ)
+	{
+		return maxDistance(getDetailLevel(levelPos), getPosX(levelPos), getPosZ(levelPos), playerPosX, playerPosZ);
+	}
+
+	public static int maxDistance(byte detailLevel, int posX, int posZ, int playerPosX, int playerPosZ)
+	{
+		int width = 1 << detailLevel;
+
+		int startPosX = posX * width;
+		int startPosZ = posZ * width;
+		int endPosX = startPosX + width;
+		int endPosZ = startPosZ + width;
+
+		int maxDistance = (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - startPosZ, 2));
+		maxDistance = Math.max(maxDistance, (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+		maxDistance = Math.max(maxDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - startPosZ, 2)));
+		maxDistance = Math.max(maxDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+
+		return maxDistance;
+	}
+
+
+	public static int minDistance(int[] levelPos, int playerPosX, int playerPosZ)
+	{
+		return minDistance(getDetailLevel(levelPos), getPosX(levelPos), getPosZ(levelPos), playerPosX, playerPosZ);
+	}
+
+	public static int minDistance(byte detailLevel, int posX, int posZ, int playerPosX, int playerPosZ)
+	{
+		int width = 1 << detailLevel;
+
+		int startPosX = posX * width;
+		int startPosZ = posZ * width;
+		int endPosX = startPosX + width;
+		int endPosZ = startPosZ + width;
+
+		boolean inXArea = playerPosX >= startPosX && playerPosX <= endPosX;
+		boolean inZArea = playerPosZ >= startPosZ && playerPosZ <= endPosZ;
+		if (inXArea && inZArea)
+		{
+			return 0;
+		} else if (inXArea)
+		{
+			return Math.min(
+					Math.abs(playerPosZ - startPosZ),
+					Math.abs(playerPosZ - endPosZ)
+			);
+		} else if (inZArea)
+		{
+			return Math.min(
+					Math.abs(playerPosX - startPosX),
+					Math.abs(playerPosX - endPosX)
+			);
+		} else
+		{
+			int minDistance = (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - startPosZ, 2));
+			minDistance = Math.min(minDistance, (int) Math.sqrt(Math.pow(playerPosX - startPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+			minDistance = Math.min(minDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - startPosZ, 2)));
+			minDistance = Math.min(minDistance, (int) Math.sqrt(Math.pow(playerPosX - endPosX, 2) + Math.pow(playerPosZ - endPosZ, 2)));
+			return minDistance;
+		}
+	}
+
+	public static int compareDistance(int posX, int posZ, int[] first, int[] second)
+	{
+		return Integer.compare(
+				minDistance(first, posX, posZ),
+				minDistance(second, posX, posZ));
+	}
+
+	public static int compareDistance(int[] first, int[] second)
+	{
+		return Integer.compare(
+				getDistance(first),
+				getDistance(second));
+	}
+
+	public static int compareLevelAndDistance(int[] first, int[] second)
+	{
+		int compareResult = Integer.compare(getDetailLevel(second), getDetailLevel(first));
+		if (compareResult == 0)
+		{
+			compareResult = Integer.compare(
+					getDistance(first),
+					getDistance(second));
+		}
+		return compareResult;
+	}
+
+	public static int compareLevelAndDistance(int posX, int posZ, int[] first, int[] second)
+	{
+		int compareResult = Integer.compare(getDetailLevel(second), getDetailLevel(first));
+		if (compareResult == 0)
+		{
+			compareResult = Integer.compare(
+					minDistance(first, posX, posZ),
+					minDistance(second, posX, posZ));
+		}
+		return compareResult;
+	}
+
+	public static String toString(int[] levelPos)
+	{
+		return (getDetailLevel(levelPos) + " " + getPosX(levelPos) + " " + getPosZ(levelPos));
+	}
+}
@@ -0,0 +1,727 @@
+/*
+ *    This file is part of 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.objects;
+
+import java.io.File;
+import java.io.IOException;
+import java.security.InvalidParameterException;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import org.apache.commons.lang3.mutable.MutableBoolean;
+
+import com.seibel.lod.config.LodConfig;
+import com.seibel.lod.enums.DistanceGenerationMode;
+import com.seibel.lod.handlers.LodDimensionFileHandler;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+import com.seibel.lod.util.DetailDistanceUtil;
+import com.seibel.lod.util.LodThreadFactory;
+import com.seibel.lod.util.LodUtil;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.util.math.ChunkPos;
+import net.minecraft.world.DimensionType;
+import net.minecraft.world.server.ServerChunkProvider;
+import net.minecraft.world.server.ServerWorld;
+
+
+/**
+ * This object holds all loaded LOD regions
+ * for a given dimension.
+ *
+ * @author Leonardo Amato
+ * @author James Seibel
+ * @version 8-8-2021
+ */
+public class LodDimension
+{
+
+	public final DimensionType dimension;
+
+	/**
+	 * measured in regions
+	 */
+	private volatile int width;
+	/**
+	 * measured in regions
+	 */
+	private volatile int halfWidth;
+
+
+	public volatile LodRegion regions[][];
+	public volatile boolean isRegionDirty[][];
+	public volatile boolean regen[][];
+	/** if true that means there are regions in this dimension
+	 * that need to have their buffers rebuilt. */
+	public volatile boolean regenDimension = false;
+
+	private volatile RegionPos center;
+	private volatile ChunkPos lastGenChunk;
+	private volatile ChunkPos lastCutChunk;
+	private LodDimensionFileHandler fileHandler;
+	private ExecutorService cutAndGenThreads = Executors.newSingleThreadExecutor(new LodThreadFactory(this.getClass().getSimpleName() + " - cutAndGen"));
+
+	/**
+	 * Creates the dimension centered at (0,0)
+	 *
+	 * @param newWidth in regions
+	 */
+	public LodDimension(DimensionType newDimension, LodWorld lodWorld, int newWidth)
+	{
+		lastCutChunk = null;
+		lastGenChunk = null;
+		dimension = newDimension;
+		width = newWidth;
+		halfWidth = (int) Math.floor(width / 2);
+		Minecraft mc = Minecraft.getInstance();
+		if (newDimension != null && lodWorld != null)
+		{
+			try
+			{
+
+				File saveDir;
+				if (mc.hasSingleplayerServer())
+				{
+					// local world
+
+					ServerWorld serverWorld = LodUtil.getServerWorldFromDimension(newDimension);
+
+					// provider needs a separate variable to prevent
+					// the compiler from complaining
+					ServerChunkProvider provider = serverWorld.getChunkSource();
+					saveDir = new File(provider.dataStorage.dataFolder.getCanonicalFile().getPath() + File.separatorChar + "lod");
+				} else
+				{
+					// connected to server
+
+					saveDir = new File(mc.gameDirectory.getCanonicalFile().getPath() +
+							                   File.separatorChar + "lod server data" + File.separatorChar + LodUtil.getDimensionIDFromWorld(mc.level));
+				}
+
+				fileHandler = new LodDimensionFileHandler(saveDir, this);
+			} catch (IOException e)
+			{
+				// the file handler wasn't able to be created
+				// we won't be able to read or write any files
+			}
+		}
+
+
+		regions = new LodRegion[width][width];
+		isRegionDirty = new boolean[width][width];
+		regen = new boolean[width][width];
+
+		//treeGenerator((int) mc.player.getX(),(int) mc.player.getZ());
+
+		// populate isRegionDirty
+		for (int i = 0; i < width; i++)
+			for (int j = 0; j < width; j++)
+				isRegionDirty[i][j] = false;
+
+		center = new RegionPos(0, 0);
+	}
+
+
+	/**
+	 * Move the center of this LodDimension and move all owned
+	 * regions over by the given x and z offset. <br><br>
+	 * <p>
+	 * Synchronized to prevent multiple moves happening on top of each other.
+	 */
+	public synchronized void move(RegionPos regionOffset)
+	{
+		int xOffset = regionOffset.x;
+		int zOffset = regionOffset.z;
+
+		// if the x or z offset is equal to or greater than
+		// the total size, just delete the current data
+		// and update the centerX and/or centerZ
+		if (Math.abs(xOffset) >= width || Math.abs(zOffset) >= width)
+		{
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					regions[x][z] = null;
+				}
+			}
+
+			// update the new center
+			center.x += xOffset;
+			center.z += zOffset;
+
+			return;
+		}
+
+
+		// X
+		if (xOffset > 0)
+		{
+			// move everything over to the left (as the center moves to the right)
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					if (x + xOffset < width)
+						regions[x][z] = regions[x + xOffset][z];
+					else
+						regions[x][z] = null;
+				}
+			}
+		} else
+		{
+			// move everything over to the right (as the center moves to the left)
+			for (int x = width - 1; x >= 0; x--)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					if (x + xOffset >= 0)
+						regions[x][z] = regions[x + xOffset][z];
+					else
+					{
+						regions[x][z] = null;
+					}
+				}
+			}
+		}
+
+
+		// Z
+		if (zOffset > 0)
+		{
+			// move everything up (as the center moves down)
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					if (z + zOffset < width)
+						regions[x][z] = regions[x][z + zOffset];
+					else
+						regions[x][z] = null;
+				}
+			}
+		} else
+		{
+			// move everything down (as the center moves up)
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = width - 1; z >= 0; z--)
+				{
+					if (z + zOffset >= 0)
+						regions[x][z] = regions[x][z + zOffset];
+					else
+						regions[x][z] = null;
+				}
+			}
+		}
+
+
+		// update the new center
+		center.x += xOffset;
+		center.z += zOffset;
+	}
+
+
+	/**
+	 * return needed memory in byte
+	 */
+	public int getMinMemoryNeeded()
+	{
+		int regionX;
+		int regionZ;
+		int count = 0;
+		LodRegion region;
+
+		for (int x = 0; x < regions.length; x++)
+		{
+			for (int z = 0; z < regions.length; z++)
+			{
+				region = regions[x][z];
+				if (region != null)
+				{
+					count += region.getMinMemoryNeeded();
+				}
+			}
+		}
+		return count;
+	}
+
+	/**
+	 * Gets the region at the given X and Z
+	 * <br>
+	 * Returns null if the region doesn't exist
+	 * or is outside the loaded area.
+	 */
+	public LodRegion getRegion(LevelPos levelPos)
+	{
+
+		RegionPos regionPos = levelPos.getRegionPos();
+		int xIndex = (regionPos.x - center.x) + halfWidth;
+		int zIndex = (regionPos.z - center.z) + halfWidth;
+
+		if (!regionIsInRange(regionPos.x, regionPos.z))
+			throw new ArrayIndexOutOfBoundsException("Region for level pos " + levelPos + " out of range");
+		else if (regions[xIndex][zIndex] == null)
+			throw new InvalidParameterException("Region for level pos " + levelPos + " not currently initialized");
+		else if (regions[xIndex][zIndex].getMinDetailLevel() > levelPos.detailLevel)
+			throw new InvalidParameterException("Region for level pos " + levelPos + " currently only reach level " + regions[xIndex][zIndex].getMinDetailLevel());
+		return regions[xIndex][zIndex];
+	}
+
+	/**
+	 * Gets the region at the given X and Z
+	 * <br>
+	 * Returns null if the region doesn't exist
+	 * or is outside the loaded area.
+	 */
+	public LodRegion getRegion(RegionPos regionPos)
+	{
+		int xIndex = (regionPos.x - center.x) + halfWidth;
+		int zIndex = (regionPos.z - center.z) + halfWidth;
+
+		if (!regionIsInRange(regionPos.x, regionPos.z))
+			throw new ArrayIndexOutOfBoundsException("Region " + regionPos + " out of range");
+		else if (regions[xIndex][zIndex] == null)
+			throw new InvalidParameterException("Region " + regionPos + " not currently initialized");
+		return regions[xIndex][zIndex];
+	}
+
+	/**
+	 * Overwrite the LodRegion at the location of newRegion with newRegion.
+	 *
+	 * @throws ArrayIndexOutOfBoundsException if newRegion is outside what can be stored in this LodDimension.
+	 */
+	public synchronized void addOrOverwriteRegion(LodRegion newRegion) throws ArrayIndexOutOfBoundsException
+	{
+		int xIndex = (newRegion.regionPosX - center.x) + halfWidth;
+		int zIndex = (center.z - newRegion.regionPosZ) + halfWidth;
+
+		if (!regionIsInRange(newRegion.regionPosX, newRegion.regionPosZ))
+			// out of range
+			throw new ArrayIndexOutOfBoundsException("Region " + newRegion.regionPosX + ", " + newRegion.regionPosZ + " out of range");
+
+		regions[xIndex][zIndex] = newRegion;
+	}
+
+
+	/**
+	 *
+	 */
+	public void treeCutter(int playerPosX, int playerPosZ)
+	{
+		ChunkPos newPlayerChunk = (new LevelPos((byte) 0, playerPosX, playerPosZ)).getChunkPos();
+		if (lastCutChunk == null)
+			lastCutChunk = new ChunkPos(newPlayerChunk.x + 1, newPlayerChunk.z - 1);
+		if (newPlayerChunk.x != lastCutChunk.x || newPlayerChunk.z != lastCutChunk.z)
+		{
+			lastCutChunk = newPlayerChunk;
+			Thread thread = new Thread(() ->
+			{
+				int regionX;
+				int regionZ;
+				int minDistance;
+				byte detail;
+				byte levelToCut;
+				LevelPos levelPos = new LevelPos();
+
+				for (int x = 0; x < regions.length; x++)
+				{
+					for (int z = 0; z < regions.length; z++)
+					{
+						regionX = (x + center.x) - halfWidth;
+						regionZ = (z + center.z) - halfWidth;
+						//we start checking from the first circle. If the whole region is in the circle
+						//we proceed to cut all the level lower than the level of circle 1 and we break
+						//if this is not the case w
+						if (regions[x][z] != null)
+						{
+							levelPos.changeParameters(LodUtil.REGION_DETAIL_LEVEL, regionX, regionZ);
+							minDistance = levelPos.minDistance(playerPosX, playerPosZ);
+							detail = DetailDistanceUtil.getDistanceTreeCutInverse(minDistance);
+							levelToCut = DetailDistanceUtil.getCutLodDetail(detail);
+							if (regions[x][z].getMinDetailLevel() > levelToCut)
+							{
+								regions[x][z].cutTree(levelToCut);
+							}
+						}
+
+					}// region z
+				}// region z
+
+			});
+			cutAndGenThreads.execute(thread);
+		}
+	}
+
+	/**
+	 *
+	 */
+	public void treeGenerator(int playerPosX, int playerPosZ)
+	{
+		DistanceGenerationMode generationMode = LodConfig.CLIENT.worldGenerator.distanceGenerationMode.get();
+		ChunkPos newPlayerChunk = (new LevelPos((byte) 0, playerPosX, playerPosZ)).getChunkPos();
+
+		if (lastGenChunk == null)
+			lastGenChunk = new ChunkPos(newPlayerChunk.x + 1, newPlayerChunk.z - 1);
+		if (newPlayerChunk.x != lastGenChunk.x || newPlayerChunk.z != lastGenChunk.z)
+		{
+			lastGenChunk = newPlayerChunk;
+			Thread thread = new Thread(() ->
+			{
+				int regionX;
+				int regionZ;
+				LodRegion region;
+				int minDistance;
+				byte detail;
+				byte levelToGen;
+				LevelPos levelPos = new LevelPos();
+				for (int x = 0; x < regions.length; x++)
+				{
+					for (int z = 0; z < regions.length; z++)
+					{
+						regionX = (x + center.x) - halfWidth;
+						regionZ = (z + center.z) - halfWidth;
+						levelPos.changeParameters(LodUtil.REGION_DETAIL_LEVEL, regionX, regionZ);
+						final RegionPos regionPos = new RegionPos(regionX, regionZ);
+						region = regions[x][z];
+						//We require that the region we are checking is loaded with at least this level
+
+						levelPos.changeParameters(LodUtil.REGION_DETAIL_LEVEL, regionX, regionZ);
+						minDistance = levelPos.minDistance(playerPosX, playerPosZ);
+						detail = DetailDistanceUtil.getDistanceTreeGenInverse(minDistance);
+						levelToGen = DetailDistanceUtil.getLodGenDetail(detail).detailLevel;
+						if (region == null || region.getGenerationMode() != generationMode)
+						{
+							//First case, region has to be initialized
+
+							//We check if there is a file at the target level
+							regions[x][z] = getRegionFromFile(regionPos, levelToGen, generationMode);
+
+							//if there is no file we initialize the region
+							if (regions[x][z] == null)
+							{
+								regions[x][z] = new LodRegion(levelToGen, regionPos, generationMode);
+							}
+							regen[x][z] = true;
+							regenDimension = true;
+
+						} else if (region.getMinDetailLevel() > levelToGen)
+						{
+							//Second case, region has been initialized but at a higher level
+							//We expand the region by introducing the missing layer
+							region.expand(levelToGen);
+						}
+					}
+				}
+			});
+			cutAndGenThreads.execute(thread);
+		}
+	}
+
+	/**
+	 * Add the given LOD to this dimension at the coordinate
+	 * stored in the LOD. If an LOD already exists at the given
+	 * coordinates it will be overwritten.
+	 */
+	public synchronized Boolean addData(LevelPos levelPos, short[] lodDataPoint, boolean dontSave, boolean serverQuality)
+	{
+
+		// don't continue if the region can't be saved
+		RegionPos regionPos = levelPos.getRegionPos();
+		if (!regionIsInRange(regionPos.x, regionPos.z))
+		{
+			return false;
+		}
+
+		LodRegion region = getRegion(levelPos);
+
+		boolean nodeAdded = region.addData(levelPos, lodDataPoint, serverQuality);
+		// only save valid LODs to disk
+		if (!dontSave && fileHandler != null)
+		{
+			try
+			{
+				// mark the region as dirty so it will be saved to disk
+				int xIndex = (regionPos.x - center.x) + halfWidth;
+				int zIndex = (regionPos.z - center.z) + halfWidth;
+				isRegionDirty[xIndex][zIndex] = true;
+				regen[xIndex][zIndex] = true;
+				regenDimension = true;
+			} catch (ArrayIndexOutOfBoundsException e)
+			{
+				// This method was probably called when the dimension was changing size.
+				// Hopefully this shouldn't be an issue.
+			}
+		}
+		return nodeAdded;
+	}
+
+	public void setToRegen(int xRegion, int zRegion){
+		int xIndex = (xRegion - center.x) + halfWidth;
+		int zIndex = (zRegion - center.z) + halfWidth;
+		regen[xIndex][zIndex] = true;
+	}
+
+	/**
+	 * method to get all the quadtree level that have to be generated based on the position of the player
+	 *
+	 * @return list of quadTrees
+	 */
+	public void getDataToGenerate(ConcurrentMap<LevelPos, MutableBoolean> dataToGenerate, int playerPosX, int playerPosZ)
+	{
+
+		int n = regions.length;
+		int xIndex;
+		int zIndex;
+		LodRegion region;
+		RegionPos regionPos;
+		for (int xRegion = 0; xRegion < n; xRegion++)
+		{
+			for (int zRegion = 0; zRegion < n; zRegion++)
+			{
+				try
+				{
+					xIndex = (xRegion + center.x) - halfWidth;
+					zIndex = (zRegion + center.z) - halfWidth;
+					regionPos = new RegionPos(xIndex, zIndex);
+					region = getRegion(regionPos);
+					region.getDataToGenerate(dataToGenerate, playerPosX, playerPosZ);
+
+				} catch (Exception e)
+				{
+					//e.printStackTrace();
+				}
+			}
+		}
+	}
+
+	/**
+	 * method to get all the nodes that have to be rendered based on the position of the player
+	 *
+	 * @return list of nodes
+	 */
+	public void getDataToRender(ConcurrentMap<LevelPos, MutableBoolean> dataToRender, RegionPos regionPos, int playerPosX, int playerPosZ)
+	{
+		try
+		{
+			LodRegion region = getRegion(regionPos);
+			region.getDataToRender(dataToRender, playerPosX, playerPosZ);
+		} catch (NullPointerException e)
+		{
+			System.out.println(regionPos);
+			e.printStackTrace();
+		} catch (Exception e)
+		{
+			//e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Get the LodNodeData at the given X and Z coordinates
+	 * in this dimension.
+	 * <br>
+	 * Returns null if the LodChunk doesn't exist or
+	 * is outside the loaded area.
+	 */
+	public short[] getData(ChunkPos chunkPos)
+	{
+		LevelPos levelPos = new LevelPos(LodUtil.CHUNK_DETAIL_LEVEL, chunkPos.x, chunkPos.z);
+		return getData(levelPos);
+	}
+
+	/**
+	 * Get the data point at the given X and Z coordinates
+	 * in this dimension.
+	 * <br>
+	 * Returns null if the LodChunk doesn't exist or
+	 * is outside the loaded area.
+	 */
+	public short[] getData(LevelPos levelPos)
+	{
+		if (levelPos.detailLevel > LodUtil.REGION_DETAIL_LEVEL)
+			throw new IllegalArgumentException("getLodFromCoordinates given a level of \"" + levelPos.detailLevel + "\" when \"" + LodUtil.REGION_DETAIL_LEVEL + "\" is the max.");
+
+		try
+		{
+			LodRegion region = getRegion(levelPos);
+
+			if (region == null)
+			{
+				return null;
+			}
+
+			return region.getData(levelPos);
+
+		} catch (Exception e)
+		{
+			return null;
+		}
+	}
+
+
+	/**
+	 * Get the data point at the given X and Z coordinates
+	 * in this dimension.
+	 * <br>
+	 * Returns null if the LodChunk doesn't exist or
+	 * is outside the loaded area.
+	 */
+	public void updateData(LevelPos levelPos)
+	{
+		if (levelPos.detailLevel > LodUtil.REGION_DETAIL_LEVEL)
+			throw new IllegalArgumentException("getLodFromCoordinates given a level of \"" + levelPos.detailLevel + "\" when \"" + LodUtil.REGION_DETAIL_LEVEL + "\" is the max.");
+
+		LodRegion region = getRegion(levelPos);
+
+
+		if (region == null)
+		{
+			return;
+		}
+		region.updateArea(levelPos);
+	}
+
+	/**
+	 * return true if and only if the node at that position exist
+	 */
+	public boolean doesDataExist(LevelPos levelPos)
+	{
+		try
+		{
+			LodRegion region = getRegion(levelPos);
+
+			if (region == null)
+			{
+				return false;
+			}
+
+			return region.doesDataExist(levelPos.clone());
+		} catch (Exception e)
+		{
+			return false;
+		}
+	}
+
+	/**
+	 * Get the region at the given X and Z coordinates from the
+	 * RegionFileHandler.
+	 */
+	public LodRegion getRegionFromFile(RegionPos regionPos, byte detailLevel, DistanceGenerationMode generationMode)
+	{
+		if (fileHandler != null)
+			return fileHandler.loadRegionFromFile(detailLevel, regionPos, generationMode);
+		else
+			return null;
+	}
+
+	/**
+	 * Save all dirty regions in this LodDimension to file.
+	 */
+	public void saveDirtyRegionsToFileAsync()
+	{
+		fileHandler.saveDirtyRegionsToFileAsync();
+	}
+
+
+	/**
+	 * Returns whether the region at the given X and Z coordinates
+	 * is within the loaded range.
+	 */
+	public boolean regionIsInRange(int regionX, int regionZ)
+	{
+		int xIndex = (regionX - center.x) + halfWidth;
+		int zIndex = (regionZ - center.z) + halfWidth;
+
+		return xIndex >= 0 && xIndex < width && zIndex >= 0 && zIndex < width;
+	}
+
+
+	public int getCenterX()
+	{
+		return center.x;
+	}
+
+	public int getCenterZ()
+	{
+		return center.z;
+	}
+
+
+	public int getWidth()
+	{
+		if (regions != null)
+		{
+			// we want to get the length directly from the
+			// source to make sure it is in sync with region
+			// and isRegionDirty
+			return regions.length;
+		} else
+		{
+			return width;
+		}
+	}
+
+	public void setRegionWidth(int newWidth)
+	{
+		width = newWidth;
+		halfWidth = Math.floorDiv(width, 2);
+
+		regions = new LodRegion[width][width];
+		isRegionDirty = new boolean[width][width];
+		regen = new boolean[width][width];
+
+		// populate isRegionDirty
+		for (int i = 0; i < width; i++)
+			for (int j = 0; j < width; j++)
+				isRegionDirty[i][j] = false;
+	}
+
+
+	@Override
+	public String toString()
+	{
+		int regionX;
+		int regionZ;
+		LevelPos levelPos;
+		LodRegion region;
+
+		StringBuilder stringBuilder = new StringBuilder();
+		stringBuilder.append("Dimension : \n");
+		for (int x = 0; x < regions.length; x++)
+		{
+			for (int z = 0; z < regions.length; z++)
+			{
+				region = regions[x][z];
+				if (region == null)
+				{
+					stringBuilder.append("n");
+					stringBuilder.append("\t");
+
+				} else
+				{
+					stringBuilder.append(region.getMinDetailLevel());
+					stringBuilder.append("\t");
+				}
+			}
+			stringBuilder.append("\n");
+		}
+		System.out.println(stringBuilder);
+		return stringBuilder.toString();
+	}
+}
@@ -0,0 +1,602 @@
+package com.seibel.lod.objects;
+
+import java.io.Serializable;
+import java.util.concurrent.ConcurrentMap;
+
+import org.apache.commons.lang3.mutable.MutableBoolean;
+
+import com.seibel.lod.builders.LodBuilder;
+import com.seibel.lod.enums.DistanceGenerationMode;
+import com.seibel.lod.objects.LevelPos.LevelPos;
+import com.seibel.lod.proxy.ClientProxy;
+import com.seibel.lod.util.DetailDistanceUtil;
+import com.seibel.lod.util.LodUtil;
+
+/**
+ * STANDARD TO FOLLOW
+ * every coordinate called posX or posZ is a relative coordinate and not and absolute coordinate
+ * if an array contain coordinate the order is the following
+ * 0 for x, 1 for z in 2D
+ * 0 for x, 1 for y, 2 for z in 3D
+ */
+
+public class LodRegion implements Serializable
+{
+	//x coord,
+	private byte minDetailLevel;
+	private static final byte POSSIBLE_LOD = 10;
+	private int numberOfPoints;
+	private DistanceGenerationMode generationMode;
+	//For each of the following field the first slot is for the level of detail
+	//Important: byte have a [-128, 127] range. When converting from or to int a 128 should be added or removed
+	//If there is a bug with color then it's probably caused by this.
+	//in the future other fields like transparency and light level could be added
+	private byte[][][][] colors;
+
+	private short[][][] height;
+
+	private short[][][] depth;
+
+	private boolean[][][] dataExistence;
+
+
+	public final int regionPosX;
+	public final int regionPosZ;
+
+	public LodRegion(LevelContainer levelContainer, RegionPos regionPos, DistanceGenerationMode generationMode)
+	{
+		this.generationMode = generationMode;
+		this.regionPosX = regionPos.x;
+		this.regionPosZ = regionPos.z;
+		this.minDetailLevel = levelContainer.detailLevel;
+
+		//Array of matrices of arrays
+		colors = new byte[POSSIBLE_LOD][][][];
+
+		//Arrays of matrices
+		height = new short[POSSIBLE_LOD][][];
+		depth = new short[POSSIBLE_LOD][][];
+		dataExistence = new boolean[POSSIBLE_LOD][][];
+
+		colors[minDetailLevel] = levelContainer.colors;
+		height[minDetailLevel] = levelContainer.height;
+		depth[minDetailLevel] = levelContainer.depth;
+		dataExistence[minDetailLevel] = levelContainer.dataExistence;
+
+		//Initialize all the different matrices
+		for (byte lod = (byte) (minDetailLevel + 1); lod <= LodUtil.REGION_DETAIL_LEVEL; lod++)
+		{
+			int size = (short) Math.pow(2, LodUtil.REGION_DETAIL_LEVEL - lod);
+			colors[lod] = new byte[size][size][3];
+			height[lod] = new short[size][size];
+			depth[lod] = new short[size][size];
+			dataExistence[lod] = new boolean[size][size];
+		}
+		int width;
+		LevelPos levelPos = new LevelPos();
+		for (byte tempLod = (byte) (minDetailLevel + 1); tempLod <= LodUtil.REGION_DETAIL_LEVEL; tempLod++)
+		{
+			width = 1 << (LodUtil.REGION_DETAIL_LEVEL - tempLod);
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					levelPos.changeParameters(tempLod, x, z);
+					update(levelPos);
+				}
+			}
+		}
+	}
+
+	public LodRegion(byte minDetailLevel, RegionPos regionPos, DistanceGenerationMode generationMode)
+	{
+		this.generationMode = generationMode;
+		this.minDetailLevel = minDetailLevel;
+		this.regionPosX = regionPos.x;
+		this.regionPosZ = regionPos.z;
+
+		//Array of matrices of arrays
+		colors = new byte[POSSIBLE_LOD][][][];
+
+		//Arrays of matrices
+		height = new short[POSSIBLE_LOD][][];
+		depth = new short[POSSIBLE_LOD][][];
+		dataExistence = new boolean[POSSIBLE_LOD][][];
+
+
+		//Initialize all the different matrices
+		for (byte lod = minDetailLevel; lod <= LodUtil.REGION_DETAIL_LEVEL; lod++)
+		{
+			int size = (short) Math.pow(2, LodUtil.REGION_DETAIL_LEVEL - lod);
+			colors[lod] = new byte[size][size][3];
+			height[lod] = new short[size][size];
+			depth[lod] = new short[size][size];
+			dataExistence[lod] = new boolean[size][size];
+
+		}
+	}
+
+	/**
+	 * This method can be used to insert data into the LodRegion
+	 *
+	 * @param levelPos
+	 * @param dataPoint
+	 * @return
+	 */
+	public boolean addData(LevelPos levelPos, short[] dataPoint, boolean serverQuality)
+	{
+		levelPos.performRegionModule();
+		if (!doesDataExist(levelPos) || serverQuality)
+		{
+
+			//update the number of node present
+			if (this.dataExistence[levelPos.detailLevel][levelPos.posX][levelPos.posZ]) numberOfPoints++;
+
+			//add the node data
+			this.height[levelPos.detailLevel][levelPos.posX][levelPos.posZ] = DataPoint.getHeight(dataPoint);
+			this.depth[levelPos.detailLevel][levelPos.posX][levelPos.posZ] = DataPoint.getDepth(dataPoint);
+			this.colors[levelPos.detailLevel][levelPos.posX][levelPos.posZ][0] = (byte) (DataPoint.getRed(dataPoint) - 128);
+			this.colors[levelPos.detailLevel][levelPos.posX][levelPos.posZ][1] = (byte) (DataPoint.getGreen(dataPoint) - 128);
+			this.colors[levelPos.detailLevel][levelPos.posX][levelPos.posZ][2] = (byte) (DataPoint.getBlue(dataPoint) - 128);
+			this.dataExistence[levelPos.detailLevel][levelPos.posX][levelPos.posZ] = true;
+			return true;
+		} else
+		{
+			return false;
+		}
+	}
+
+	/**
+	 * This method will return the data in the position relative to the level of detail
+	 *
+	 * @param levelPos
+	 * @return the data at the relative pos and level
+	 */
+	public short[] getData(LevelPos levelPos)
+	{
+		levelPos = levelPos.getRegionModuleLevelPos();
+		return new short[]{height[levelPos.detailLevel][levelPos.posX][levelPos.posZ],
+				depth[levelPos.detailLevel][levelPos.posX][levelPos.posZ],
+				(short) (colors[levelPos.detailLevel][levelPos.posX][levelPos.posZ][0] + 128),
+				(short) (colors[levelPos.detailLevel][levelPos.posX][levelPos.posZ][1] + 128),
+				(short) (colors[levelPos.detailLevel][levelPos.posX][levelPos.posZ][2] + 128)
+		};
+	}
+
+	/**
+	 * This method will return all the levelPos that are renderable according to the requisite given in input
+	 *
+	 * @return
+	 */
+	public void getDataToGenerate(ConcurrentMap<LevelPos, MutableBoolean> dataToGenerate, int playerPosX, int playerPosZ)
+	{
+		LevelPos levelPos = new LevelPos(LodUtil.REGION_DETAIL_LEVEL, 0, 0);
+		getDataToGenerate(dataToGenerate, levelPos, playerPosX, playerPosZ);
+
+	}
+
+	private void getDataToGenerate(ConcurrentMap<LevelPos, MutableBoolean> dataToGenerate, LevelPos levelPos, int playerPosX, int playerPosZ)
+	{
+		int size = 1 << (LodUtil.REGION_DETAIL_LEVEL - levelPos.detailLevel);
+
+		//here i calculate the the LevelPos is in range
+		//This is important to avoid any kind of hole in the generation
+		int minDistance = levelPos.minDistance(playerPosX, playerPosZ, regionPosX, regionPosZ);
+
+
+		int posX = levelPos.posX;
+		int posZ = levelPos.posZ;
+		byte detailLevel = levelPos.detailLevel;
+		byte childDetailLevel = (byte) (detailLevel - 1);
+		int childPosX = posX * 2;
+		int childPosZ = posZ * 2;
+
+		int childSize = 1 << (LodUtil.REGION_DETAIL_LEVEL - childDetailLevel);
+		//we have reached the target detail level
+
+		if (DetailDistanceUtil.getDistanceGenerationInverse(minDistance) > detailLevel)
+		{
+			return;
+		} else if (DetailDistanceUtil.getDistanceGenerationInverse(minDistance) == detailLevel)
+		{
+			if (!doesDataExist(levelPos))
+			{
+				levelPos.changeParameters(detailLevel, posX + regionPosX * size, posZ + regionPosZ * size);
+				if (dataToGenerate.containsKey(levelPos))
+				{
+					dataToGenerate.get(levelPos).setTrue();
+				} else
+				{
+					dataToGenerate.put(levelPos.clone(), new MutableBoolean(true));
+				}
+			}
+		} else
+		{
+			//we want max a request per chunk. So for lod smaller than chunk we explore only the top rigth child
+			if (detailLevel > LodUtil.CHUNK_DETAIL_LEVEL)
+			{
+				int num = 0;
+				//We take all the children that are not generated to at least the generation level taken in input
+				for (int x = 0; x <= 1; x++)
+				{
+					for (int z = 0; z <= 1; z++)
+					{
+						levelPos.changeParameters((byte) (detailLevel - 1), childPosX + x, childPosZ + z);
+
+						if (!doesDataExist(levelPos))
+						{
+							num++;
+							levelPos.changeParameters((byte) (detailLevel - 1), childPosX + x + regionPosX * childSize, childPosZ + z + regionPosZ * childSize);
+							if (dataToGenerate.containsKey(levelPos))
+							{
+								dataToGenerate.get(levelPos).setTrue();
+							} else
+							{
+								dataToGenerate.put(levelPos.clone(), new MutableBoolean(true));
+							}
+						}
+					}
+				}
+
+				//only if all the children are correctly generated we go deeper
+				if (num == 0)
+				{
+					for (int x = 0; x <= 1; x++)
+					{
+						for (int z = 0; z <= 1; z++)
+						{
+							levelPos.changeParameters((byte) (detailLevel - 1), childPosX + x, childPosZ + z);
+							getDataToGenerate(dataToGenerate, levelPos, playerPosX, playerPosZ);
+						}
+					}
+				}
+			} else
+			//now we keep exploring the top right child
+			{
+				if (DetailDistanceUtil.getLodGenDetail(childDetailLevel).detailLevel <= (childDetailLevel))
+				{
+					levelPos.changeParameters(detailLevel, posX, posZ);
+					levelPos.convert(childDetailLevel);
+					if (!doesDataExist(levelPos))
+					{
+						levelPos.changeParameters(levelPos.detailLevel, levelPos.posX + regionPosX * childSize, levelPos.posZ + regionPosZ * childSize);
+						if (dataToGenerate.containsKey(levelPos))
+						{
+							dataToGenerate.get(levelPos).setTrue();
+						} else
+						{
+							dataToGenerate.put(levelPos.clone(), new MutableBoolean(true));
+						}
+					} else
+					{
+						getDataToGenerate(dataToGenerate, levelPos, playerPosX, playerPosZ);
+					}
+				}
+			}
+		}
+	}
+
+
+	/**
+	 * @return
+	 */
+	public void getDataToRender(ConcurrentMap<LevelPos, MutableBoolean> dataToRender, int playerPosX, int playerPosZ)
+	{
+		LevelPos levelPos = new LevelPos(LodUtil.REGION_DETAIL_LEVEL, 0, 0);
+		getDataToRender(dataToRender, levelPos, playerPosX, playerPosZ);
+	}
+
+	/**
+	 * @return
+	 */
+	private void getDataToRender(ConcurrentMap<LevelPos, MutableBoolean> dataToRender, LevelPos levelPos, int playerPosX, int playerPosZ)
+	{
+		int size = 1 << (LodUtil.REGION_DETAIL_LEVEL - levelPos.detailLevel);
+
+		int posX = levelPos.posX;
+		int posZ = levelPos.posZ;
+		byte detailLevel = levelPos.detailLevel;
+
+		//here i calculate the the LevelPos is in range
+		//This is important to avoid any kind of hole in the rendering
+		int maxDistance = levelPos.maxDistance(playerPosX, playerPosZ, regionPosX, regionPosZ);
+
+		byte supposedLevel = DetailDistanceUtil.getLodDrawDetail(DetailDistanceUtil.getDistanceRenderingInverse(maxDistance));
+		if (supposedLevel > detailLevel)
+			return;
+		else if (supposedLevel == detailLevel)
+		{
+			if (dataToRender.containsKey(levelPos))
+			{
+				levelPos.changeParameters(detailLevel, posX + regionPosX * size, posZ + regionPosZ * size);
+				try
+				{
+					dataToRender.get(levelPos).setTrue();
+				}catch (Exception e){
+					/*TODO Fix this exception*/
+					// This seems to happen more often when using an elytra in an amplified world
+					// maybe it has something to do with the dimensions moving?
+					ClientProxy.LOGGER.error("getDataToRender had a error at " + levelPos.getRegionPos() + ". Exception: " + e.getMessage());
+					dataToRender.put(new LevelPos(detailLevel, posX + regionPosX * size, posZ + regionPosZ * size), new MutableBoolean(true));
+				}
+			} else
+			{
+				dataToRender.put(new LevelPos(detailLevel, posX + regionPosX * size, posZ + regionPosZ * size), new MutableBoolean(true));
+			}
+		} else //case where (detailLevel > supposedLevel)
+		{
+			int childPosX = posX * 2;
+			int childPosZ = posZ * 2;
+			int childrenCount = 0;
+			for (int x = 0; x <= 1; x++)
+			{
+				for (int z = 0; z <= 1; z++)
+				{
+					levelPos.changeParameters((byte) (detailLevel - 1), childPosX + x, childPosZ + z);
+					if (doesDataExist(levelPos)) childrenCount++;
+				}
+			}
+
+			//If all the four children exist we go deeper
+			if (childrenCount == 4)
+			{
+				for (int x = 0; x <= 1; x++)
+				{
+					for (int z = 0; z <= 1; z++)
+					{
+						levelPos.changeParameters((byte) (detailLevel - 1), childPosX + x, childPosZ + z);
+						getDataToRender(dataToRender, levelPos, playerPosX, playerPosZ);
+					}
+				}
+			} else
+			{
+
+				levelPos.changeParameters(detailLevel, posX + regionPosX * size, posZ + regionPosZ * size);
+				if (dataToRender.containsKey(levelPos))
+				{
+					if (dataToRender.get(levelPos) == null)
+						dataToRender.replace(levelPos, new MutableBoolean());
+					dataToRender.get(levelPos).setTrue();
+				} else
+				{
+					dataToRender.put(new LevelPos(detailLevel, posX + regionPosX * size, posZ + regionPosZ * size), new MutableBoolean(true));
+				}
+			}
+		}
+	}
+
+
+	/**
+	 * @param levelPos
+	 */
+	public void updateArea(LevelPos levelPos)
+	{
+		int width;
+		int startX;
+		int startZ;
+		byte detailLevel = levelPos.detailLevel;
+		int posX = levelPos.posX;
+		int posZ = levelPos.posZ;
+		for (byte bottom = (byte) (minDetailLevel + 1); bottom <= detailLevel; bottom++)
+		{
+			levelPos.convert(bottom);
+			startX = levelPos.posX;
+			startZ = levelPos.posZ;
+			width = 1 << (detailLevel - bottom);
+			for (int x = 0; x < width; x++)
+			{
+				for (int z = 0; z < width; z++)
+				{
+					levelPos.changeParameters(bottom, startX + x, startZ + z);
+					update(levelPos);
+				}
+			}
+			levelPos.changeParameters(detailLevel, posX, posZ);
+		}
+		for (byte tempLod = (byte) (detailLevel + 1); tempLod <= LodUtil.REGION_DETAIL_LEVEL; tempLod++)
+		{
+			levelPos.convert(tempLod);
+			update(levelPos);
+		}
+	}
+
+	/**
+	 * @param levelPos
+	 */
+	private void update(LevelPos levelPos)
+	{
+		levelPos.performRegionModule();
+		int numberOfChildren = 0;
+		int numberOfVoidChildren = 0;
+
+		int tempRed = 0;
+		int tempGreen = 0;
+		int tempBlue = 0;
+		int tempHeight = 0;
+		int tempDepth = 0;
+		int newPosX;
+		int newPosZ;
+		byte newDetailLevel;
+		int detailLevel = levelPos.detailLevel;
+		int posX = levelPos.posX;
+		int posZ = levelPos.posZ;
+		for (int x = 0; x <= 1; x++)
+		{
+			for (int z = 0; z <= 1; z++)
+			{
+				newPosX = 2 * posX + x;
+				newPosZ = 2 * posZ + z;
+				newDetailLevel = (byte) (detailLevel - 1);
+				levelPos.changeParameters(newDetailLevel, newPosX, newPosZ);
+				if (doesDataExist(levelPos))
+				{
+					if (height[newDetailLevel][newPosX][newPosZ] != LodBuilder.DEFAULT_HEIGHT
+							    && depth[newDetailLevel][newPosX][newPosZ] != LodBuilder.DEFAULT_DEPTH)
+					{
+						numberOfChildren++;
+
+						tempRed += colors[newDetailLevel][newPosX][newPosZ][0];
+						tempGreen += colors[newDetailLevel][newPosX][newPosZ][1];
+						tempBlue += colors[newDetailLevel][newPosX][newPosZ][2];
+						tempHeight += height[newDetailLevel][newPosX][newPosZ];
+						tempDepth += depth[newDetailLevel][newPosX][newPosZ];
+					} else
+					{
+						// void children have the default height (most likely -1)
+						// and represent a LOD with no blocks in it
+						numberOfVoidChildren++;
+					}
+				}
+			}
+		}
+
+		if (numberOfChildren > 0)
+		{
+			colors[detailLevel][posX][posZ][0] = (byte) (tempRed / numberOfChildren);
+			colors[detailLevel][posX][posZ][1] = (byte) (tempGreen / numberOfChildren);
+			colors[detailLevel][posX][posZ][2] = (byte) (tempBlue / numberOfChildren);
+			height[detailLevel][posX][posZ] = (short) (tempHeight / numberOfChildren);
+			depth[detailLevel][posX][posZ] = (short) (tempDepth / numberOfChildren);
+			dataExistence[detailLevel][posX][posZ] = true;
+		} else if (numberOfVoidChildren > 0)
+		{
+			colors[detailLevel][posX][posZ][0] = (byte) 0;
+			colors[detailLevel][posX][posZ][1] = (byte) 0;
+			colors[detailLevel][posX][posZ][2] = (byte) 0;
+
+			height[detailLevel][posX][posZ] = LodBuilder.DEFAULT_HEIGHT;
+			depth[detailLevel][posX][posZ] = LodBuilder.DEFAULT_DEPTH;
+
+			dataExistence[detailLevel][posX][posZ] = true;
+		}
+	}
+
+	/**
+	 * @param levelPos
+	 * @return
+	 */
+	public boolean doesDataExist(LevelPos levelPos)
+	{
+		try
+		{
+			levelPos = levelPos.getRegionModuleLevelPos();
+			return dataExistence[levelPos.detailLevel][levelPos.posX][levelPos.posZ];
+		} catch (NullPointerException e)
+		{
+			return false;
+		}
+	}
+
+	/**
+	 * @return
+	 */
+	public DistanceGenerationMode getGenerationMode()
+	{
+		return generationMode;
+	}
+
+	public byte getMinDetailLevel()
+	{
+		return minDetailLevel;
+	}
+
+	/**
+	 * This will be used to save a level
+	 *
+	 * @param detailLevel
+	 * @return
+	 */
+	public LevelContainer getLevel(byte detailLevel)
+	{
+		if (detailLevel < minDetailLevel)
+		{
+			throw new IllegalArgumentException("getLevel asked for a level that does not exist: minimum " + minDetailLevel + " level requested " + detailLevel);
+		}
+		return new LevelContainer(detailLevel, colors[detailLevel], height[detailLevel], depth[detailLevel], dataExistence[detailLevel]);
+	}
+
+	/**
+	 * @param levelContainer
+	 */
+	public void addLevel(LevelContainer levelContainer)
+	{
+		if (levelContainer.detailLevel < minDetailLevel - 1)
+		{
+			throw new IllegalArgumentException("addLevel requires a level that is at least the minimum level of the region -1 ");
+		}
+		if (levelContainer.detailLevel == minDetailLevel - 1) minDetailLevel = levelContainer.detailLevel;
+		colors[levelContainer.detailLevel] = levelContainer.colors;
+		height[levelContainer.detailLevel] = levelContainer.height;
+		depth[levelContainer.detailLevel] = levelContainer.depth;
+		dataExistence[levelContainer.detailLevel] = levelContainer.dataExistence;
+
+	}
+
+	/**
+	 * @param detailLevel
+	 */
+	public void cutTree(byte detailLevel)
+	{
+		if (minDetailLevel < detailLevel)
+		{
+			for (byte tempLod = 0; tempLod < detailLevel; tempLod++)
+			{
+				colors[tempLod] = new byte[0][0][0];
+				height[tempLod] = new short[0][0];
+				depth[tempLod] = new short[0][0];
+				dataExistence[tempLod] = new boolean[0][0];
+			}
+			minDetailLevel = detailLevel;
+		}
+	}
+
+	/**
+	 * @param detailLevel
+	 */
+	public void expand(byte detailLevel)
+	{
+		if (detailLevel < minDetailLevel)
+		{
+			for (byte tempLod = detailLevel; tempLod < minDetailLevel; tempLod++)
+			{
+				int size = (short) Math.pow(2, LodUtil.REGION_DETAIL_LEVEL - tempLod);
+				colors[tempLod] = new byte[size][size][3];
+				height[tempLod] = new short[size][size];
+				depth[tempLod] = new short[size][size];
+				dataExistence[tempLod] = new boolean[size][size];
+			}
+			minDetailLevel = detailLevel;
+		}
+	}
+
+	/**
+	 * return RegionPos of this lod region
+	 */
+	public RegionPos getRegionPos()
+	{
+		return new RegionPos(regionPosX, regionPosZ);
+	}
+
+	/**
+	 * return needed memory in byte
+	 */
+	public int getMinMemoryNeeded()
+	{
+		int count = 0;
+		for (byte tempLod = LodUtil.REGION_DETAIL_LEVEL; tempLod > minDetailLevel; tempLod--)
+		{
+			//i'm doing a upper limit of the minimum
+			//Color should be just 3 byte but i'm gonna calculate as 12 byte
+			//Height and depth should be just 4 byte but i'm gonna calculate as 8 byte
+			count += Math.pow(2, LodUtil.REGION_DETAIL_LEVEL - tempLod) * (8 + 3 + 2 + 2 + 1);
+			//count += Math.pow(2, LodUtil.REGION_DETAIL_LEVEL - tempLod) * (24 + 8 + 8 + 8 + 8);
+		}
+		return count;
+	}
+
+	@Override
+	public String toString()
+	{
+		return getLevel(LodUtil.REGION_DETAIL_LEVEL).toString();
+	}
+}
@@ -0,0 +1,159 @@
+/*
+ *    This file is part of 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.objects;
+
+import java.util.Hashtable;
+import java.util.Map;
+
+import com.seibel.lod.proxy.ClientProxy;
+
+import net.minecraft.world.DimensionType;
+
+/**
+ * This stores all LODs for a given world.
+ *
+ * @author James Seibel
+ * @author Leonardo Amato
+ * @version 8-17-2021
+ */
+public class LodWorld
+{
+	private String worldName;
+
+	private Map<DimensionType, LodDimension> lodDimensions;
+
+	/**
+	 * If true then the LOD world is setup and ready to use
+	 */
+	private boolean isWorldLoaded = false;
+
+	public static final String NO_WORLD_LOADED = "No world loaded";
+
+
+	public LodWorld()
+	{
+		worldName = NO_WORLD_LOADED;
+	}
+
+	/**
+	 * Set up the LodQuadTreeWorld with the given newWorldName. <br>
+	 * This should be done whenever loading a new world.
+	 *
+	 * @param newWorldName name of the world
+	 */
+	public void selectWorld(String newWorldName)
+	{
+		if (newWorldName.isEmpty())
+		{
+			deselectWorld();
+			return;
+		}
+
+		if (worldName.equals(newWorldName))
+			// don't recreate everything if we
+			// didn't actually change worlds
+			return;
+
+		worldName = newWorldName;
+		lodDimensions = new Hashtable<DimensionType, LodDimension>();
+		isWorldLoaded = true;
+	}
+
+	/**
+	 * Set the worldName to "No world loaded"
+	 * and clear the lodDimensions Map. <br>
+	 * This should be done whenever unloaded a world.
+	 */
+	public void deselectWorld()
+	{
+		worldName = NO_WORLD_LOADED;
+		lodDimensions = null;
+		isWorldLoaded = false;
+	}
+
+
+	/**
+	 * Adds newStorage to this world, if a LodQuadTreeDimension
+	 * already exists for the given dimension it is replaced.
+	 */
+	public void addLodDimension(LodDimension newStorage)
+	{
+		if (lodDimensions == null)
+			return;
+
+		lodDimensions.put(newStorage.dimension, newStorage);
+	}
+
+	/**
+	 * Returns null if no LodQuadTreeDimension exists for the given dimension
+	 */
+	public LodDimension getLodDimension(DimensionType dimension)
+	{
+		if (lodDimensions == null)
+			return null;
+
+		return lodDimensions.get(dimension);
+	}
+
+	/**
+	 * Resizes the max width in regions that each LodDimension
+	 * should use.
+	 */
+	public void resizeDimensionRegionWidth(int newWidth)
+	{
+		if (lodDimensions == null)
+			return;
+
+		saveAllDimensions();
+
+		for (DimensionType key : lodDimensions.keySet())
+			lodDimensions.get(key).setRegionWidth(newWidth);
+	}
+
+	/**
+	 * Requests all dimensions save any dirty regions they may have.
+	 */
+	public void saveAllDimensions()
+	{
+		if (lodDimensions == null)
+			return;
+
+		ClientProxy.LOGGER.info("Saving LODs");
+
+		for (DimensionType key : lodDimensions.keySet())
+			lodDimensions.get(key).saveDirtyRegionsToFileAsync();
+	}
+
+
+	public boolean getIsWorldLoaded()
+	{
+		return isWorldLoaded;
+	}
+
+	public String getWorldName()
+	{
+		return worldName;
+	}
+
+	@Override
+	public String toString()
+	{
+		return "World name: " + worldName;
+	}
+}
+
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`these are tools needed for looking at obfuscated minecraft code.`
				`@@ -1 +0,0 @@`
				`these are tools needed for deobfuscating and looking at the code of optifine.`