Incomplete instance based config

This might cause issues with the Replay mod, but we'll see

api/src/main/java/com/seibel/distanthorizons/api/DhApi.java

@@ -180,7 +180,7 @@ public class DhApi
 	 * This version should be updated whenever non-breaking fixes are added to the Distant Horizons API. 
 	 * @since API 1.0.0 
 	 */
-	public static int getApiPatchVersion() { return ModInfo.API_PATH_VERSION; }
+	public static int getApiPatchVersion() { return ModInfo.API_PATCH_VERSION; }
 	
 	/**
 	 * Returns the mod's semantic version number in the format: Major.Minor.Patch

api/src/main/java/com/seibel/distanthorizons/api/enums/EDhApiDetailLevel.java

@@ -24,7 +24,7 @@ package com.seibel.distanthorizons.api.enums;
  * CHUNK  - Detail Level: 4, width 16 block, <br>
  * REGION - Detail Level: 9, width 512 block <br> <br>
  *
- * Detail levels in Distant Horizons represent how large a section (of either LODs or MC chunks)
+ * Detail levels in Distant Horizons represent how large a LOD
  * is, with the smallest being 0 (1 block wide). <br>
  * The width of a detail level can be calculated by putting the detail level to the power of 2. <br>
  * Example for the chunk detail level (4): 2^4 = 16 blocks wide <Br><br>

api/src/main/java/com/seibel/distanthorizons/api/enums/config/EDhApiGpuUploadMethod.java

@@ -23,13 +23,12 @@ package com.seibel.distanthorizons.api.enums.config;
  * AUTO, 					<br>
  * BUFFER_STORAGE, 			<br>
  * SUB_DATA, 				<br>
- * BUFFER_MAPPING, 			<br>
  * DATA						<br>
  *
  * @author Leetom
  * @author James Seibel
  * @version 2024-4-6
- * @since API 2.0.0
+ * @since API 3.0.0
  */
 public enum EDhApiGpuUploadMethod
 {
@@ -49,7 +48,10 @@ public enum EDhApiGpuUploadMethod
 	 * May end up storing buffers in System memory. <br>
 	 * Fast rending if in GPU memory, slow if in system memory, <br>
 	 * but won't stutter when uploading.
+	 * 
+	 * @deprecated not currently supported
 	 */
+	@Deprecated
 	BUFFER_MAPPING(true, false),
 	
 	/** Fast rendering but may stutter when uploading. */

api/src/main/java/com/seibel/distanthorizons/api/enums/rendering/EDhApiBlockMaterial.java

@@ -21,6 +21,7 @@ package com.seibel.distanthorizons.api.enums.rendering;
  * AIR, <br>
  * ILLUMINATED, <br>
  * 
+ * @author IMS
  * @author James Seibel
  * @since API 3.0.0
  * @version 2024-7-11

api/src/main/java/com/seibel/distanthorizons/api/interfaces/block/IDhApiBlockStateWrapper.java

@@ -19,6 +19,7 @@
 
 package com.seibel.distanthorizons.api.interfaces.block;
 
+import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
 import com.seibel.distanthorizons.api.interfaces.IDhApiUnsafeWrapper;
 
 /**
@@ -44,7 +45,11 @@ public interface IDhApiBlockStateWrapper extends IDhApiUnsafeWrapper
 	 * @since API 3.0.0 
 	 */
 	String getSerialString();
-	/** @since API 3.0.0 */
+	/**
+	 * Returns the byte value representing the {@link EDhApiBlockMaterial} enum.
+	 * @see EDhApiBlockMaterial 
+	 * @since API 3.0.0 
+	 */
 	byte getMaterialId();
 	
 }

api/src/main/java/com/seibel/distanthorizons/api/interfaces/config/IDhApiConfig.java

@@ -36,7 +36,6 @@ public interface IDhApiConfig
 	IDhApiWorldGenerationConfig worldGenerator();
 	IDhApiMultiplayerConfig multiplayer();
 	IDhApiMultiThreadingConfig multiThreading();
-	IDhApiGpuBuffersConfig gpuBuffers();
 	// note: DON'T add the Auto Updater to this API. We only want the user's to have the ability to control when things are downloaded to their machines.
 	//IDhApiLoggingConfig logging(); // TODO implement
 	IDhApiDebuggingConfig debugging();

api/src/main/java/com/seibel/distanthorizons/api/interfaces/config/client/IDhApiGpuBuffersConfig.java

@@ -1,48 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.api.interfaces.config.client;
-
-import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod;
-import com.seibel.distanthorizons.api.interfaces.config.IDhApiConfigGroup;
-import com.seibel.distanthorizons.api.interfaces.config.IDhApiConfigValue;
-
-/**
- * Distant Horizons' OpenGL buffer configuration.
- *
- * @author James Seibel
- * @version 2023-6-14
- * @since API 1.0.0
- */
-public interface IDhApiGpuBuffersConfig extends IDhApiConfigGroup
-{
-	
-	/** Defines how geometry data is uploaded to the GPU. */
-	IDhApiConfigValue<EDhApiGpuUploadMethod> gpuUploadMethod();
-	
-	/**
-	 * Defines how long we should wait after uploading one
-	 * Megabyte of geometry data to the GPU before uploading
-	 * the next Megabyte of data. <br>
-	 * This can be set to a non-zero number to reduce stuttering caused by
-	 * uploading buffers to the GPU.
-	 */
-	IDhApiConfigValue<Integer> gpuUploadPerMegabyteInMilliseconds();
-	
-}

api/src/main/java/com/seibel/distanthorizons/api/interfaces/factories/IDhApiWrapperFactory.java

@@ -79,11 +79,34 @@ public interface IDhApiWrapperFactory
 	
 	
 	
-	///**
-	// * Specifically designed to be used with the API.
-	// *
-	// * @throws ClassCastException with instructions on expected objects if the object couldn't be cast
-	// */
-	//IChunkWrapper createChunkWrapper(Object[] objectArray) throws ClassCastException;
+	/**
+	 * Constructs a {@link IDhApiBiomeWrapper} for use by other DhApi methods.
+	 *
+	 * @param resourceLocationString example: "minecraft:plains"
+	 *
+	 * @param levelWrapper Expects a {@link IDhApiLevelWrapper} returned by one of DH's {@link DhApi.Delayed#worldProxy} methods. <br>
+	 *                      A custom implementation of {@link IDhApiLevelWrapper} will not be accepted.
+	 *
+	 * @throws IOException if the resourceLocationString wasn't able to be parsed or converted into a valid {@link IDhApiBiomeWrapper}
+	 * @throws ClassCastException if the wrong levelWrapper type was given
+	 *
+	 * @since API 3.0.0
+	 */
+	IDhApiBiomeWrapper getBiomeWrapper(String resourceLocationString, IDhApiLevelWrapper levelWrapper) throws IOException, ClassCastException;
+	
+	/**
+	 * Constructs a {@link IDhApiBlockStateWrapper} for use by other DhApi methods.
+	 * This returns the default blockstate for the given resource location.
+	 *
+	 * @param resourceLocationString examples: "minecraft:bedrock", "minecraft:stone", "minecraft:grass_block"
+	 * @param levelWrapper Expects a {@link IDhApiBlockStateWrapper} returned by one of DH's {@link DhApi.Delayed#worldProxy} methods. <br>
+	 *                      A custom implementation of {@link IDhApiBlockStateWrapper} will not be accepted.
+	 *
+	 * @throws IOException if the resourceLocationString wasn't able to be parsed or converted into a valid {@link IDhApiBlockStateWrapper}
+	 * @throws ClassCastException if the wrong levelWrapper type was given
+	 *
+	 * @since API 3.0.0
+	 */
+	IDhApiBlockStateWrapper getDefaultBlockStateWrapper(String resourceLocationString, IDhApiLevelWrapper levelWrapper) throws IOException, ClassCastException;
 	
 }

api/src/main/java/com/seibel/distanthorizons/api/interfaces/override/worldGenerator/AbstractDhApiChunkWorldGenerator.java

@@ -22,6 +22,8 @@ package com.seibel.distanthorizons.api.interfaces.override.worldGenerator;
 import com.seibel.distanthorizons.api.enums.EDhApiDetailLevel;
 import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiDistantGeneratorMode;
 import com.seibel.distanthorizons.api.interfaces.override.IDhApiOverrideable;
+import com.seibel.distanthorizons.api.objects.data.DhApiChunk;
+import com.seibel.distanthorizons.api.objects.data.DhApiTerrainDataPoint;
 import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
 
 import java.io.Closeable;
@@ -77,13 +79,41 @@ public abstract class AbstractDhApiChunkWorldGenerator implements Closeable, IDh
 		}, worldGeneratorThreadPool);
 	}
 	
+	@Override
+	public final CompletableFuture<Void> generateApiChunks(
+			int chunkPosMinX,
+			int chunkPosMinZ,
+			byte granularity,
+			byte targetDataDetail,
+			EDhApiDistantGeneratorMode generatorMode,
+			ExecutorService worldGeneratorThreadPool,
+			Consumer<DhApiChunk> resultConsumer
+		)
+	{
+		return CompletableFuture.runAsync(() ->
+		{
+			// TODO what does this mean?
+			int genChunkWidth = BitShiftUtil.powerOfTwo(granularity - 4);
+			
+			for (int chunkX = chunkPosMinX; chunkX < chunkPosMinX + genChunkWidth; chunkX++)
+			{
+				for (int chunkZ = chunkPosMinZ; chunkZ < chunkPosMinZ + genChunkWidth; chunkZ++)
+				{
+					DhApiChunk apiChunk = this.generateApiChunk(chunkX, chunkZ, generatorMode);
+					resultConsumer.accept(apiChunk);
+				}
+			}
+		}, worldGeneratorThreadPool);
+	}
+	
+	
 	/**
 	 * This method is called to generate terrain over a given area
 	 * from a thread defined by Distant Horizons. <br><br>
 	 * 
 	 * @param chunkPosX the chunk X position in the level (not to be confused with the chunk's BlockPos in the level)
 	 * @param chunkPosZ the chunk Z position in the level (not to be confused with the chunk's BlockPos in the level)
-	 * @param generatorMode how far into the world gen pipeline this method run. See {@link EDhApiDistantGeneratorMode} for additional documentation.
+	 * @param generatorMode how far into the world gen pipeline this method should run. See {@link EDhApiDistantGeneratorMode} for additional documentation.
 	 * 
 	 * @return See {@link IDhApiWorldGenerator#generateChunks(int, int, byte, byte, EDhApiDistantGeneratorMode, ExecutorService, Consumer) IDhApiWorldGenerator.generateChunks}
 	 *         for the list of Object's this method should return along with additional documentation.
@@ -92,4 +122,21 @@ public abstract class AbstractDhApiChunkWorldGenerator implements Closeable, IDh
 	 */
 	public abstract Object[] generateChunk(int chunkPosX, int chunkPosZ, EDhApiDistantGeneratorMode generatorMode);
 	
+	/**
+	 * This method is called to generate terrain over a given area
+	 * from a thread defined by Distant Horizons. <br><br>
+	 * 
+	 * @param chunkPosX the chunk X position in the level (not to be confused with the chunk's BlockPos in the level)
+	 * @param chunkPosZ the chunk Z position in the level (not to be confused with the chunk's BlockPos in the level)
+	 * @param generatorMode how far into the world gen pipeline this method should run. See {@link EDhApiDistantGeneratorMode} for additional documentation.
+	 * 
+	 * @return A {@link DhApiChunk} with the generated {@link DhApiTerrainDataPoint} including air blocks.
+	 *          Note: if air blocks aren't included with the proper lighting, lower detail levels will appear as black/unlit.
+	 *         
+	 * @see IDhApiWorldGenerator#generateApiChunks(int, int, byte, byte, EDhApiDistantGeneratorMode, ExecutorService, Consumer)
+	 * 
+	 * @since API 3.0.0
+	 */
+	public abstract DhApiChunk generateApiChunk(int chunkPosX, int chunkPosZ, EDhApiDistantGeneratorMode generatorMode);
+	
 }

api/src/main/java/com/seibel/distanthorizons/api/interfaces/override/worldGenerator/IDhApiWorldGenerator.java

@@ -90,11 +90,29 @@ public interface IDhApiWorldGenerator extends Closeable, IDhApiOverrideable
 	 */
 	default byte getMaxGenerationGranularity() { return (byte) (EDhApiDetailLevel.CHUNK.detailLevel + 2); }
 	
-	/** 
-	 * @return true if the generator is unable to accept new generation requests.
+	/**
+	 * Starting in API 3.0.0 DH now handles future queuing/management internally. <br><br>
+	 * 
+	 * Previous description: <br>
+	 * true if the generator is unable to accept new generation requests. <br>
+	 * 
 	 * @since API 1.0.0
+	 * @deprecated API 3.0.0
 	 */
-	boolean isBusy();
+	@Deprecated
+	default boolean isBusy() { return false; }
+	
+	/** 
+	 * Only used if {@link #getReturnType()} returns {@link EDhApiWorldGeneratorReturnType#API_CHUNKS}. <Br> 
+	 * If true DH will run additional validation on the {@link DhApiChunk}'s returned. <Br>
+	 * This should be disabled during release but should be enabled during development to help spot issues with your data format.
+	 * 
+	 * @see #getReturnType()
+	 * @see DhApiChunk
+	 * @see EDhApiWorldGeneratorReturnType#API_CHUNKS
+	 * @since API 3.0.0
+	 */
+	default boolean runApiChunkValidation() { return true; }
 	
 	
 	
@@ -154,6 +172,7 @@ public interface IDhApiWorldGenerator extends Closeable, IDhApiOverrideable
 	 *
 	 * After the {@link DhApiChunk} has been generated, it should be passed into the
 	 * resultConsumer's {@link Consumer#accept(Object)} method.
+	 * Note: if air blocks aren't included in the with the {@link DhApiChunk} with proper lighting, lower detail levels will appear as black/unlit.
 	 *
 	 * @implNote the default implementation of this method throws an {@link UnsupportedOperationException},
 	 * and must be overridden when {@link #getReturnType()} returns {@link EDhApiWorldGeneratorReturnType#API_CHUNKS}.

api/src/main/java/com/seibel/distanthorizons/api/interfaces/render/IDhApiRenderProxy.java

@@ -26,7 +26,7 @@ import com.seibel.distanthorizons.api.objects.DhApiResult;
  * Used to interact with Distant Horizons' rendering system.
  *
  * @author James Seibel
- * @version 2023-10-13
+ * @version 2024-7-27
  * @since API 1.0.0
  */
 public interface IDhApiRenderProxy
@@ -39,10 +39,8 @@ public interface IDhApiRenderProxy
 	 * If this is called on a dedicated server it won't do anything and will return {@link DhApiResult#success} = false <Br><Br>
 	 *
 	 * Background: <Br>
-	 * Distant Horizons has two different file formats: Full data and Render data. <Br>
-	 * - Full data files store the block, biome, etc. information and is the result of loading or generating new chunks. <Br>
-	 * - Render data files store LOD colors and are created using the Full data and currently loaded resource packs. <Br>
-	 * This is the data cleared by this method.
+	 * When rendering Distant Horizons bakes each block's color into the geometry that's rendered. <Br>
+	 * This improves rendering speed and VRAM size, but prevents dynamically changing LOD colors. <Br>
 	 */
 	DhApiResult<Boolean> clearRenderDataCache();
 	

api/src/main/java/com/seibel/distanthorizons/api/interfaces/world/IDhApiDimensionTypeWrapper.java

@@ -28,8 +28,6 @@ import com.seibel.distanthorizons.api.interfaces.IDhApiUnsafeWrapper;
  */
 public interface IDhApiDimensionTypeWrapper extends IDhApiUnsafeWrapper
 {
-	String getDimensionName();
-	
 	boolean hasCeiling();
 	
 	boolean hasSkyLight();

api/src/main/java/com/seibel/distanthorizons/api/interfaces/world/IDhApiLevelWrapper.java

@@ -28,20 +28,34 @@ import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegist
  * A level is equivalent to a dimension in vanilla Minecraft.
  *
  * @author James Seibel
- * @version 2022-7-14
+ * @version 2024-7-28
  * @since API 1.0.0
  */
 public interface IDhApiLevelWrapper extends IDhApiUnsafeWrapper
 {
 	IDhApiDimensionTypeWrapper getDimensionType();
 	
+	/** @since API 4.0.0 */
+	String getDimensionName();
+
 	EDhApiLevelType getLevelType();
 	
 	boolean hasCeiling();
 	
 	boolean hasSkyLight();
 	
-	/** Returns the max block height of the level(?) */
+	/** 
+	 * Deprecated, use {@link IDhApiLevelWrapper#getMaxHeight} instead. <br>
+	 * Returns the max block height of the level.
+	 * 
+	 * @see IDhApiLevelWrapper#getMaxHeight
+	 */
+	@Deprecated
+	default int getHeight() { return this.getMaxHeight(); }
+	/** 
+	 * Returns the max block height of the level 
+	 * @since API 3.0.0 
+	 */
 	int getMaxHeight();
 	
 	/**
@@ -53,6 +67,8 @@ public interface IDhApiLevelWrapper extends IDhApiUnsafeWrapper
 	/** 
 	 * Will return null if called on the server,
 	 * or if called before the renderer has been set up.
+	 * 
+	 * @since API 3.0.0
 	 */
 	IDhApiCustomRenderRegister getRenderRegister();
 	

api/src/main/java/com/seibel/distanthorizons/api/objects/data/DhApiChunk.java

@@ -21,15 +21,17 @@ package com.seibel.distanthorizons.api.objects.data;
 
 import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory;
 import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator;
+import org.apache.logging.log4j.LogManager;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 /**
  * Contains a list of {@link DhApiTerrainDataPoint} representing the blocks in a Minecraft chunk.
  *
  * @author Builderb0y, James Seibel
- * @version 2023-12-21
+ * @version 2024-7-21
  * @since API 2.0.0
  * 
  * @see IDhApiWrapperFactory
@@ -41,8 +43,8 @@ public class DhApiChunk
 	public final int chunkPosX;
 	public final int chunkPosZ;
 	
-	public final int topYBlockPos;
 	public final int bottomYBlockPos;
+	public final int topYBlockPos;
 	
 	private final List<List<DhApiTerrainDataPoint>> dataPoints;
 	
@@ -52,12 +54,32 @@ public class DhApiChunk
 	// constructors //
 	//==============//
 	
+	/** 
+	 * Deprecated due to the topYBlockPos and bottomYBlockPos variables being put in the wrong order. 
+	 * They should have been in bottom -> top order. 
+	 * 
+	 * @see DhApiChunk#create(int, int, int, int) 
+	 */
+	@Deprecated
 	public DhApiChunk(int chunkPosX, int chunkPosZ, int topYBlockPos, int bottomYBlockPos) 
+	{ this(chunkPosX, chunkPosZ, bottomYBlockPos, topYBlockPos, false); }
+	
+	/**
+	 * @since API 3.0.0 
+	 */
+	public static DhApiChunk create(int chunkPosX, int chunkPosZ, int bottomYBlockPos, int topYBlockPos)
+	{ return new DhApiChunk(chunkPosX, chunkPosZ, bottomYBlockPos, topYBlockPos, false); }
+	
+	/** 
+	 * Only visible to internal DH methods 
+	 * @param ignoredParameter is only present to differentiate the two constructors and isn't actually used
+	 */
+	private DhApiChunk(int chunkPosX, int chunkPosZ, int bottomYBlockPos, int topYBlockPos, boolean ignoredParameter)
 	{
 		this.chunkPosX = chunkPosX;
 		this.chunkPosZ = chunkPosZ;
-		this.topYBlockPos = topYBlockPos;
 		this.bottomYBlockPos = bottomYBlockPos;
+		this.topYBlockPos = topYBlockPos;
 		
 		// populate the array to prevent null pointers
 		this.dataPoints = new ArrayList<>(16 * 16); // 256
@@ -94,27 +116,34 @@ public class DhApiChunk
 	 */
 	public void setDataPoints(int relX, int relZ, List<DhApiTerrainDataPoint> dataPoints) throws IndexOutOfBoundsException, IllegalArgumentException
 	{
+		//==================//
+		// basic validation //
+		//==================//
+		
+		// heavier validation is done in the world generator if requested
+		
+		int internalArrayIndex = (relZ << 4) | relX;
 		throwIfRelativePosOutOfBounds(relX, relZ);
 		
-		// validate the incoming datapoints
-		if (dataPoints != null)
+		if (dataPoints == null)
 		{
-			for (int i = 0; i < dataPoints.size(); i++) // standard for-loop used instead of an enhanced for-loop to slightly reduce GC overhead due to iterator allocation
-			{
-				DhApiTerrainDataPoint dataPoint = dataPoints.get(i);
-				if (dataPoint == null)
-				{
-					throw new IllegalArgumentException("Null DhApiTerrainDataPoints are not allowed. If you want to represent empty terrain, please use AIR.");
-				}
-				
-				if (dataPoint.detailLevel != 0)
-				{
-					throw new IllegalArgumentException("DhApiTerrainDataPoints has the wrong detail level ["+dataPoint.detailLevel+"], all data points must be block sized; IE their detail level must be [0].");
-				}
-			}
+			// we don't allow null columns
+			throw new IllegalArgumentException("Null columns aren't allowed. If you want to remove all data from a column please clear the list or pass in an empty list.");
 		}
 		
-		this.dataPoints.set((relZ << 4) | relX, dataPoints); 
+		
+		
+		//================//
+		// set datapoints //
+		//================//
+		
+		List<DhApiTerrainDataPoint> column = this.dataPoints.get(internalArrayIndex);
+		if (column == null)
+		{
+			column = new ArrayList<>();
+			this.dataPoints.set(internalArrayIndex, column);
+		}
+		column.addAll(dataPoints); 
 	}
 	
 	

api/src/main/java/com/seibel/distanthorizons/api/objects/data/DhApiTerrainDataPoint.java

@@ -19,14 +19,17 @@
 
 package com.seibel.distanthorizons.api.objects.data;
 
+import com.seibel.distanthorizons.api.enums.EDhApiDetailLevel;
 import com.seibel.distanthorizons.api.interfaces.block.IDhApiBiomeWrapper;
 import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper;
 
+import java.util.ArrayList;
+
 /**
  * Holds a single datapoint of terrain data.
  *
  * @author James Seibel
- * @version 2022-11-13
+ * @version 2024-7-20
  * @since API 1.0.0
  */
 public class DhApiTerrainDataPoint
@@ -37,27 +40,79 @@ public class DhApiTerrainDataPoint
 	 * 2 = 4x4 blocks <br>
 	 * 4 = chunk (16x16 blocks) <br>
 	 * 9 = region (512x512 blocks) <br>
+	 * 
+	 * @see EDhApiDetailLevel
 	 */
 	public final byte detailLevel;
 	
 	public final int blockLightLevel;
 	public final int skyLightLevel;
-	public final int topYBlockPos;
 	public final int bottomYBlockPos;
+	public final int topYBlockPos;
 	
 	public final IDhApiBlockStateWrapper blockStateWrapper;
 	public final IDhApiBiomeWrapper biomeWrapper;
 	
 	
 	
-	public DhApiTerrainDataPoint(byte detailLevel, int blockLightLevel, int skyLightLevel, int topYBlockPos, int bottomYBlockPos, IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper)
+	//==============//
+	// constructors //
+	//==============//
+	
+	/**
+	 * Deprecated due to the topYBlockPos and bottomYBlockPos variables being put in the wrong order. 
+	 * They should have been in bottom -> top order. 
+	 *
+	 * @see DhApiTerrainDataPoint#create(byte, int, int, int, int, IDhApiBlockStateWrapper, IDhApiBiomeWrapper) 
+	 */
+	@Deprecated
+	public DhApiTerrainDataPoint(
+			byte detailLevel, 
+			int blockLightLevel, int skyLightLevel, 
+			int topYBlockPos, int bottomYBlockPos, 
+			IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper)
+	{
+		this(detailLevel, blockLightLevel, skyLightLevel,
+			bottomYBlockPos, topYBlockPos,
+			blockStateWrapper, biomeWrapper, 
+			false);
+	}
+	
+	/**
+	 * @since API 3.0.0 
+	 */
+	public static DhApiTerrainDataPoint create(
+			byte detailLevel,
+			int blockLightLevel, int skyLightLevel,
+			int bottomYBlockPos, int topYBlockPos,
+			IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper
+		)
+	{ 
+		return new DhApiTerrainDataPoint(
+			detailLevel, blockLightLevel, skyLightLevel,
+			bottomYBlockPos, topYBlockPos,
+			blockStateWrapper, biomeWrapper,
+			false); 
+	}
+	
+	/**
+	 * Only visible to internal DH methods 
+	 * @param ignoredParameter is only present to differentiate the two constructors and isn't actually used
+	 */
+	private DhApiTerrainDataPoint(
+			byte detailLevel,
+			int blockLightLevel, int skyLightLevel,
+			int bottomYBlockPos, int topYBlockPos,
+			IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper,
+			boolean ignoredParameter
+		)
 	{
 		this.detailLevel = detailLevel;
 		
 		this.blockLightLevel = blockLightLevel;
 		this.skyLightLevel = skyLightLevel;
-		this.topYBlockPos = topYBlockPos;
 		this.bottomYBlockPos = bottomYBlockPos;
+		this.topYBlockPos = topYBlockPos;
 		
 		this.blockStateWrapper = blockStateWrapper;
 		this.biomeWrapper = biomeWrapper;

api/src/main/java/com/seibel/distanthorizons/coreapi/ModInfo.java

@@ -26,27 +26,28 @@ package com.seibel.distanthorizons.coreapi;
 public final class ModInfo
 {
 	public static final String ID = "distanthorizons";
-	/** The internal protocol version used for networking */
-	public static final int PROTOCOL_VERSION = 1;
-	/** The protocol version used for multiverse networking */
-	public static final int MULTIVERSE_PLUGIN_PROTOCOL_VERSION = 1;
+	
+	public static final String RESOURCE_NAMESPACE = "distant_horizons";
+	public static final String DEDICATED_SERVER_INITIAL_PATH = "dedicated_server_initial";
+	
+	/** Incremented every time any packets are added, changed or removed, with a few exceptions. */
+	public static final int PROTOCOL_VERSION = 4;
+	public static final String WRAPPER_PACKET_PATH = "message";
+	
 	/** The internal mod name */
 	public static final String NAME = "DistantHorizons";
 	/** Human-readable version of NAME */
 	public static final String READABLE_NAME = "Distant Horizons";
-	public static final String VERSION = "2.1.3-a-dev";
+	public static final String VERSION = "2.3.0-a-dev";
 	/** Returns true if the current build is an unstable developer build, false otherwise. */
 	public static boolean IS_DEV_BUILD = VERSION.toLowerCase().contains("dev");
 	
 	/** This version should only be updated when breaking changes are introduced to the DH API */
-	public static final int API_MAJOR_VERSION = 3;
+	public static final int API_MAJOR_VERSION = 4;
 	/** This version should be updated whenever new methods are added to the DH API */
 	public static final int API_MINOR_VERSION = 0;
 	/** This version should be updated whenever non-breaking fixes are added to the DH API */
-	public static final int API_PATH_VERSION = 0;
-	
-	public static final String NETWORKING_RESOURCE_NAMESPACE = "distant_horizons";
-	public static final String MULTIVERSE_PLUGIN_NAMESPACE = "world_control";
+	public static final int API_PATCH_VERSION = 0;
 	
 	/** All DH owned threads should start with this string to allow for easier debugging and profiling. */
 	public static final String THREAD_NAME_PREFIX = "DH-";

api/src/main/java/com/seibel/distanthorizons/coreapi/interfaces/config/IConfigEntry.java

@@ -67,10 +67,11 @@ public interface IConfigEntry<T>
 	 * Checks if the option is valid
 	 *
 	 * 0 == valid
+	 * 2 == invalid
 	 * 1 == number too high
 	 * -1 == number too low
 	 */
-	byte isValid();
+	byte isValid(); // TODO replace with an enum
 	/** Checks if a value is valid */
 	byte isValid(T value);
 	

api/src/main/java/com/seibel/distanthorizons/coreapi/util/StringUtil.java

@@ -24,12 +24,12 @@ import java.util.Arrays;
 
 /**
  * Miscellaneous string helper functions.
- *
- * @author James Seibel
- * @version 2022-7-19
  */
 public class StringUtil
 {
+	private static final char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();
+	
+	
 	/**
 	 * Returns the n-th index of the given string. <br> <br>
 	 *
@@ -67,8 +67,6 @@ public class StringUtil
 		return stringBuilder.toString();
 	}
 	
-	
-	private static final char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();
 	/**
 	 * Converts the given byte array into a hex string representation. <br>
 	 * source: https://stackoverflow.com/a/9855338
@@ -85,4 +83,20 @@ public class StringUtil
 		return new String(hexChars);
 	}
 	
+	/**
+	 * Returns a shortened version of the given string that is no longer than maxLength. <br>
+	 * If null returns the empty string.
+	 */
+	public static String shortenString(String str, int maxLength)
+	{
+		if (str == null)
+		{
+			return "";
+		}
+		else
+		{
+			return str.substring(0, Math.min(str.length(), maxLength));
+		}
+	}
+	
 }

core/src/main/java/com/seibel/distanthorizons/core/Initializer.java

@@ -23,6 +23,7 @@ import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory;
 import com.seibel.distanthorizons.core.sql.DatabaseUpdater;
 import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import com.seibel.distanthorizons.core.world.DhApiWorldProxy;
 import com.seibel.distanthorizons.core.api.external.methods.config.DhApiConfig;
@@ -40,6 +41,8 @@ import java.awt.*;
 public class Initializer
 {
 	private static final Logger LOGGER = LogManager.getLogger(ModInfo.NAME + "-" + Initializer.class.getSimpleName());
+	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
+	
 	
 	public static void init()
 	{
@@ -77,16 +80,18 @@ public class Initializer
 			throw new RuntimeException(e);
 		}
 		
-		
-		// attempt to setup Swing so we can display dialogs (popup windows)
-		System.setProperty("java.awt.headless", "false");
-		if (GraphicsEnvironment.isHeadless())
+		if (MC_CLIENT != null)
 		{
-			LOGGER.warn("Java.awt.headless is false. This means Distant Horizons can't display error and info dialog windows.");
-		}
-		else
-		{
-			LOGGER.info("Java.awt.headless set to true. Distant Horizons can correctly display error and info dialog windows.");
+			// attempt to set up Swing so we can display dialogs (popup windows)
+			System.setProperty("java.awt.headless", "false");
+			if (GraphicsEnvironment.isHeadless())
+			{
+				LOGGER.warn("Java.awt.headless is false. This means Distant Horizons can't display error and info dialog windows.");
+			}
+			else
+			{
+				LOGGER.info("Java.awt.headless set to true. Distant Horizons can correctly display error and info dialog windows.");
+			}
 		}
 		
 		// link Core's config to the API

core/src/main/java/com/seibel/distanthorizons/core/api/external/methods/config/DhApiConfig.java

@@ -42,8 +42,6 @@ public class DhApiConfig implements IDhApiConfig
 	@Override
 	public IDhApiMultiThreadingConfig multiThreading() { return DhApiMultiThreadingConfig.INSTANCE; }
 	@Override
-	public IDhApiGpuBuffersConfig gpuBuffers() { return DhApiGpuBuffersConfig.INSTANCE; }
-	@Override
 	public IDhApiDebuggingConfig debugging() { return DhApiDebuggingConfig.INSTANCE; }
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/api/external/methods/config/client/DhApiDebuggingConfig.java

@@ -33,19 +33,19 @@ public class DhApiDebuggingConfig implements IDhApiDebuggingConfig
 	
 	
 	
-	public IDhApiConfigValue<EDhApiDebugRendering> debugRendering()
+	@Override public IDhApiConfigValue<EDhApiDebugRendering> debugRendering()
 	{ return new DhApiConfigValue<EDhApiDebugRendering, EDhApiDebugRendering>(Config.Client.Advanced.Debugging.debugRendering); }
 	
-	public IDhApiConfigValue<Boolean> debugKeybindings()
+	@Override public IDhApiConfigValue<Boolean> debugKeybindings()
 	{ return new DhApiConfigValue<Boolean, Boolean>(Config.Client.Advanced.Debugging.enableDebugKeybindings); }
 	
-	public IDhApiConfigValue<Boolean> renderWireframe()
+	@Override public IDhApiConfigValue<Boolean> renderWireframe()
 	{ return new DhApiConfigValue<Boolean, Boolean>(Config.Client.Advanced.Debugging.renderWireframe); }
 	
-	public IDhApiConfigValue<Boolean> lodOnlyMode()
+	@Override public IDhApiConfigValue<Boolean> lodOnlyMode()
 	{ return new DhApiConfigValue<Boolean, Boolean>(Config.Client.Advanced.Debugging.lodOnlyMode); }
 	
-	public IDhApiConfigValue<Boolean> debugWireframeRendering()
+	@Override public IDhApiConfigValue<Boolean> debugWireframeRendering()
 	{ return new DhApiConfigValue<Boolean, Boolean>(Config.Client.Advanced.Debugging.DebugWireframe.enableRendering); }
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/api/external/methods/config/client/DhApiGpuBuffersConfig.java

@@ -1,42 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.core.api.external.methods.config.client;
-
-import com.seibel.distanthorizons.api.interfaces.config.IDhApiConfigValue;
-import com.seibel.distanthorizons.api.interfaces.config.client.IDhApiGpuBuffersConfig;
-import com.seibel.distanthorizons.api.objects.config.DhApiConfigValue;
-import com.seibel.distanthorizons.core.config.Config;
-import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod;
-
-public class DhApiGpuBuffersConfig implements IDhApiGpuBuffersConfig
-{
-	public static DhApiGpuBuffersConfig INSTANCE = new DhApiGpuBuffersConfig();
-	
-	private DhApiGpuBuffersConfig() { }
-	
-	
-	
-	public IDhApiConfigValue<EDhApiGpuUploadMethod> gpuUploadMethod()
-	{ return new DhApiConfigValue<>(Config.Client.Advanced.GpuBuffers.gpuUploadMethod); }
-	
-	public IDhApiConfigValue<Integer> gpuUploadPerMegabyteInMilliseconds()
-	{ return new DhApiConfigValue<>(Config.Client.Advanced.GpuBuffers.gpuUploadPerMegabyteInMilliseconds); }
-	
-}

core/src/main/java/com/seibel/distanthorizons/core/api/external/methods/config/client/DhApiMultiplayerConfig.java

@@ -33,10 +33,10 @@ public class DhApiMultiplayerConfig implements IDhApiMultiplayerConfig
 	
 	
 	
-	public IDhApiConfigValue<EDhApiServerFolderNameMode> folderSavingMode()
+	@Override public IDhApiConfigValue<EDhApiServerFolderNameMode> folderSavingMode()
 	{ return new DhApiConfigValue<EDhApiServerFolderNameMode, EDhApiServerFolderNameMode>(Config.Client.Advanced.Multiplayer.serverFolderNameMode); }
 	
-	public IDhApiConfigValue<Double> multiverseSimilarityRequirement()
+	@Override public IDhApiConfigValue<Double> multiverseSimilarityRequirement()
 	{ return new DhApiConfigValue<Double, Double>(Config.Client.Advanced.Multiplayer.multiverseSimilarityRequiredPercent); }
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/api/external/methods/data/DhApiTerrainDataRepo.java

@@ -326,9 +326,10 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 		int height = FullDataPointUtil.getHeight(dataPoint);
 		int topY = bottomY + height;
 		
-		return new DhApiTerrainDataPoint(detailLevel,
+		return DhApiTerrainDataPoint.create(
+				detailLevel,
 				FullDataPointUtil.getBlockLight(dataPoint), FullDataPointUtil.getSkyLight(dataPoint),
-				topY, bottomY,
+				bottomY, topY,
 				blockState, biomeWrapper);
 	}
 	

core/src/main/java/com/seibel/distanthorizons/core/api/internal/ClientApi.java

@@ -23,18 +23,21 @@ import com.seibel.distanthorizons.api.DhApi;
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiRenderPass;
 import com.seibel.distanthorizons.api.methods.events.abstractEvents.*;
 import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
-import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager;
+import com.seibel.distanthorizons.core.file.structure.ClientOnlySaveStructure;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.render.DhApiRenderProxy;
+import com.seibel.distanthorizons.core.util.TimerUtil;
 import com.seibel.distanthorizons.core.util.objects.Pair;
-import com.seibel.distanthorizons.core.world.*;
 import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector;
 import com.seibel.distanthorizons.core.level.IDhClientLevel;
 import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
+import com.seibel.distanthorizons.core.network.session.NetworkSession;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiDebugRendering;
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiRendererMode;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
+import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel;
 import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
 import com.seibel.distanthorizons.core.logging.ConfigBasedSpamLogger;
 import com.seibel.distanthorizons.core.logging.SpamReducedLogger;
@@ -42,20 +45,21 @@ import com.seibel.distanthorizons.core.util.math.Mat4f;
 import com.seibel.distanthorizons.core.render.glObject.GLProxy;
 import com.seibel.distanthorizons.core.render.renderer.TestRenderer;
 import com.seibel.distanthorizons.core.util.RenderUtil;
+import com.seibel.distanthorizons.core.world.AbstractDhWorld;
+import com.seibel.distanthorizons.core.world.DhClientServerWorld;
+import com.seibel.distanthorizons.core.world.DhClientWorld;
+import com.seibel.distanthorizons.core.world.IDhClientWorld;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
-import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
-//import io.netty.buffer.ByteBuf;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.NotNull;
 import org.lwjgl.glfw.GLFW;
 
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Queue;
+import java.io.File;
+import java.util.*;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
 
@@ -73,9 +77,7 @@ public class ClientApi
 	public static final ClientApi INSTANCE = new ClientApi();
 	public static final TestRenderer TEST_RENDERER = new TestRenderer();
 	
-	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
-	private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class);
-	private static final IKeyedClientLevelManager KEYED_CLIENT_LEVEL_MANAGER = SingletonInjector.INSTANCE.get(IKeyedClientLevelManager.class);
+	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	
 	public static final long SPAM_LOGGER_FLUSH_NS = TimeUnit.NANOSECONDS.convert(1, TimeUnit.SECONDS);
 	
@@ -88,10 +90,11 @@ public class ClientApi
 	
 	private long lastFlushNanoTime = 0;
 	
-	private boolean isServerCommunicationEnabled = false;
+	private final ClientPluginChannelApi pluginChannelApi = new ClientPluginChannelApi(this::clientLevelLoadEvent, this::clientLevelUnloadEvent);
 	
-	/** set to true if any unexpected responses are received from the server */
-	private boolean serverNetworkingIsMalformed = false;
+	/** Delay loading the first level to give the server some time to respond with level to actually load */
+	private Timer firstLevelLoadTimer;
+	private static final long FIRST_LEVEL_LOAD_DELAY_IN_MS = 1_000;
 	
 	/** Holds any levels that were loaded before the {@link ClientApi#onClientOnlyConnected} was fired. */
 	public final HashSet<IClientLevelWrapper> waitingClientLevels = new HashSet<>();
@@ -125,14 +128,36 @@ public class ClientApi
 	public synchronized void onClientOnlyConnected()
 	{
 		// only continue if the client is connected to a different server
-		if (MC.clientConnectedToDedicatedServer())
+		boolean connectedToServer = MC_CLIENT.clientConnectedToDedicatedServer();
+		boolean connectedToReplay = MC_CLIENT.connectedToReplay();
+		if (connectedToServer || connectedToReplay)
 		{
-			LOGGER.info("Client on ClientOnly mode connecting.");
+			if (connectedToServer)
+			{
+				LOGGER.info("Client on ClientOnly mode connecting.");
+			}
+			else
+			{
+				LOGGER.info("Replay on ClientServer mode connecting.");
+				
+				if (Config.Client.Advanced.Logging.showReplayWarningOnStartup.get())
+				{
+					MC_CLIENT.sendChatMessage("\u00A76" + "Distant Horizons: Replay detected." + "\u00A7r"); // gold color
+					MC_CLIENT.sendChatMessage("DH may behave strangely or have missing functionality.");
+					MC_CLIENT.sendChatMessage("In order to use pre-generated LODs, put your DH database(s) in:");
+					MC_CLIENT.sendChatMessage("\u00A77"+".Minecraft" + File.separator + ClientOnlySaveStructure.SERVER_DATA_FOLDER_NAME + File.separator + ClientOnlySaveStructure.REPLAY_SERVER_FOLDER_NAME + File.separator + "DIMENSION_NAME"+"\u00A7r"); // light gray color
+					MC_CLIENT.sendChatMessage("This can be disabled in DH's config under Advanced -> Logging.");
+					MC_CLIENT.sendChatMessage("");
+				}
+			}
 			
 			// firing after clientLevelLoadEvent
 			// TODO if level has prepped to load it should fire level load event
-			SharedApi.setDhWorld(new DhClientWorld());
+			DhClientWorld world = new DhClientWorld();
+			SharedApi.setDhWorld(world);
 			
+			this.pluginChannelApi.onJoinServer(world.networkState.getSession());
+			world.networkState.sendConfigMessage();
 			
 			LOGGER.info("Loading [" + this.waitingClientLevels.size() + "] waiting client level wrappers.");
 			for (IClientLevelWrapper level : this.waitingClientLevels)
@@ -147,6 +172,13 @@ public class ClientApi
 	/** Synchronized to prevent a rare issue where multiple disconnect events are triggered on top of each other. */
 	public synchronized void onClientOnlyDisconnected()
 	{
+		// clear the first time timer
+		if (this.firstLevelLoadTimer != null)
+		{
+			this.firstLevelLoadTimer.cancel();
+			this.firstLevelLoadTimer = null;
+		}
+		
 		AbstractDhWorld world = SharedApi.getAbstractDhWorld();
 		if (world != null)
 		{
@@ -156,11 +188,7 @@ public class ClientApi
 			SharedApi.setDhWorld(null);
 		}
 		
-		// clear the previous server's information
-		this.isServerCommunicationEnabled = false;
-		this.serverNetworkingIsMalformed = false;
-		KEYED_CLIENT_LEVEL_MANAGER.setUseOverrideWrapper(false);
-		KEYED_CLIENT_LEVEL_MANAGER.setServerKeyedLevel(null);
+		this.pluginChannelApi.reset();
 		
 		// remove any waiting items
 		this.waitingChunkByClientLevelAndPos.clear();
@@ -173,16 +201,16 @@ public class ClientApi
 	// level events //
 	//==============//
 	
-	public void clientLevelUnloadEvent(@Nullable IClientLevelWrapper level)
+	public void clientLevelUnloadEvent(IClientLevelWrapper level)
 	{
 		try
 		{
-			if (level == null)
+			LOGGER.info("Unloading client level [" + level + "]-["+level.getDimensionName()+"].");
+			
+			if (level instanceof IServerKeyedClientLevel)
 			{
-				// can happen on certain multiverse servers
-				return;
+				this.pluginChannelApi.onClientLevelUnload();
 			}
-			LOGGER.info("Unloading client level [" + level + "]-["+level.getDimensionType().getDimensionName()+"].");
 			
 			AbstractDhWorld world = SharedApi.getAbstractDhWorld();
 			if (world != null)
@@ -202,30 +230,42 @@ public class ClientApi
 		}
 	}
 	
-	public void clientLevelLoadEvent(@Nullable IClientLevelWrapper level) { this.clientLevelLoadEvent(level, false); }
-	public void multiverseClientLevelLoadEvent(@Nullable IClientLevelWrapper level) { this.clientLevelLoadEvent(level, true); }
-	private void clientLevelLoadEvent(@Nullable IClientLevelWrapper level, boolean isServerCommunication)
+	public void clientLevelLoadEvent(IClientLevelWrapper level)
 	{
+		// wait a moment before loading the level to give the server a chance to handle the client's login request
+		if (MC_CLIENT.clientConnectedToDedicatedServer())
+		{
+			if (this.firstLevelLoadTimer == null)
+			{
+				this.firstLevelLoadTimer = TimerUtil.CreateTimer("FirstLevelLoadTimer");
+				this.firstLevelLoadTimer.schedule(new TimerTask()
+				{
+					@Override
+					public void run() { ClientApi.this.clientLevelLoadEvent(level); }
+				}, FIRST_LEVEL_LOAD_DELAY_IN_MS);
+				return;
+			}
+			this.firstLevelLoadTimer.cancel();
+		}
+		
+		
 		try
 		{
-			if (this.isServerCommunicationEnabled && !isServerCommunication)
-			{
-				LOGGER.info("Server supports communication, deferring loading.");
-				return;
-			}
-			if (level == null)
-			{
-				// can happen on certain multiverse servers
-				return;
-			}
-			
-			
-			
-			LOGGER.info("Loading " + (isServerCommunication ? "Multiverse" : "") + " client level [" + level + "]-["+level.getDimensionType().getDimensionName()+"].");
+			LOGGER.info("Loading client level [" + level + "]-["+level.getDimensionName()+"].");
 			
 			AbstractDhWorld world = SharedApi.getAbstractDhWorld();
 			if (world != null)
 			{
+				if (!this.pluginChannelApi.allowLevelLoading(level))
+				{
+					LOGGER.info("Levels in this connection are managed by the server, skipping auto-load.");
+					
+					// Instead of attempting to load themselves, send the config and wait for a server provided level key.
+					((DhClientWorld) world).networkState.sendConfigMessage();
+					return;
+				}
+				
+				
 				world.getOrLoadLevel(level);
 				ApiEventInjector.INSTANCE.fireAllEvents(DhApiLevelLoadEvent.class, new DhApiLevelLoadEvent.EventParam(level));
 				
@@ -274,7 +314,7 @@ public class ClientApi
 	{
 		LOGGER.info("Renderer shutting down.");
 		
-		IProfilerWrapper profiler = MC.getProfiler();
+		IProfilerWrapper profiler = MC_CLIENT.getProfiler();
 		profiler.push("DH-RendererShutdown");
 		
 		profiler.pop();
@@ -284,7 +324,7 @@ public class ClientApi
 	{
 		LOGGER.info("Renderer starting up.");
 		
-		IProfilerWrapper profiler = MC.getProfiler();
+		IProfilerWrapper profiler = MC_CLIENT.getProfiler();
 		profiler.push("DH-RendererStartup");
 		
 		// make sure the GLProxy is created before the LodBufferBuilder needs it
@@ -294,7 +334,7 @@ public class ClientApi
 	
 	public void clientTickEvent()
 	{
-		IProfilerWrapper profiler = MC.getProfiler();
+		IProfilerWrapper profiler = MC_CLIENT.getProfiler();
 		profiler.push("DH-ClientTick");
 		
 		try
@@ -316,7 +356,7 @@ public class ClientApi
 				// Ignore local world gen, as it's managed by server ticking
 				if (!(clientWorld instanceof DhClientServerWorld))
 				{
-					SharedApi.worldGenTick(clientWorld::doWorldGen);
+					SharedApi.worldGenTick(clientWorld::worldGenTick);
 				}
 			}
 		}
@@ -334,124 +374,15 @@ public class ClientApi
 	//============//
 	// networking //
 	//============//
-
-//	/** @param byteBuf is Netty's {@link ByteBuffer} wrapper. */
-//	public void serverMessageReceived(ByteBuf byteBuf)
-//	{
-//		if (!Config.Client.Advanced.Multiplayer.enableMultiverseNetworking.get())
-//		{
-//			// multiverse networking disabled, ignore anything sent from the server
-//			return;
-//		}
-//		
-//		
-//		
-//		// either value can be set to true to debug the received byte stream
-//		boolean stopAndDisplayInputAsByteArray = false;
-//		boolean stopAndDisplayInputAsString = false;
-//		if (stopAndDisplayInputAsByteArray || stopAndDisplayInputAsString)
-//		{
-//			String messageString = "";
-//			if (stopAndDisplayInputAsByteArray)
-//			{
-//				int byteCount = byteBuf.readableBytes();
-//				byte[] arr = new byte[byteCount];
-//				StringBuilder stringBuilder = new StringBuilder("Server message received: [");
-//				for (int i = 0; i < byteCount; i++)
-//				{
-//					arr[i] = byteBuf.readByte();
-//					stringBuilder.append(arr[i]);
-//				}
-//				stringBuilder.append("]");
-//				
-//				messageString = stringBuilder.toString();
-//			}
-//			else if (stopAndDisplayInputAsString)
-//			{
-//				messageString = byteBuf.toString(StandardCharsets.UTF_8);
-//			}
-//			
-//			// this is logged as an error so it is easier to see in an Intellij log
-//			LOGGER.error(messageString);
-//			return;
-//		}
-//		
-//		
-//		
-//		
-//		// It is important to ensure malicious server input is ignored.
-//		if (this.serverNetworkingIsMalformed)
-//		{
-//			return;
-//		}
-//		
-//		// check that the incoming message is within the expected size
-//		short commandLength = byteBuf.readShort();
-//		if (commandLength < 1 || commandLength > 32)
-//		{
-//			LOGGER.error("Server command length ["+commandLength+"] outside the expected range of 1 to 32 (inclusive).");
-//			ClientApi.INSTANCE.serverNetworkingIsMalformed = true;
-//			return;
-//		}
-//		
-//		// parse the command
-//		String eventType;
-//		try
-//		{
-//			eventType = byteBuf.readCharSequence(commandLength, StandardCharsets.UTF_8).toString();
-//		}
-//		catch (Exception e)
-//		{
-//			LOGGER.error("Server sent un-parsable command. Error: "+e.getMessage());
-//			return;
-//		}
-//		
-//		switch (eventType)
-//		{
-//			case "ServerCommsEnabled":
-//				LOGGER.info("Server supports DH multiverse protocol.");
-//				ClientApi.INSTANCE.isServerCommunicationEnabled = true;
-//				KEYED_CLIENT_LEVEL_MANAGER.setUseOverrideWrapper(true);
-//				MC.executeOnRenderThread(() -> 
-//				{
-//					// Unload the current world, since it may be wrong.
-//					// A followup WorldChanged event should be received from the server soon after this.
-//					LOGGER.info("Unloading current client level so the server can define the correct multiverse level.");
-//					this.clientLevelUnloadEvent((IClientLevelWrapper) MC.getWrappedClientWorld());
-//				});
-//				break;
-//			
-//			case "LevelChanged":
-//				short levelKeyLength = byteBuf.readShort();
-//				if (levelKeyLength < 1 || levelKeyLength > 128) // TODO 128 should be put into a constant somewhere
-//				{
-//					LOGGER.error("Server [LevelChanged] command length ["+commandLength+"] outside the expected range of 1 to 128 (inclusive).");
-//					this.serverNetworkingIsMalformed = true;
-//					return;
-//				}
-//				
-//				String levelKey = byteBuf.readCharSequence(levelKeyLength, StandardCharsets.UTF_8).toString();
-//				if (!levelKey.matches("[a-zA-Z0-9_]+"))
-//				{
-//					LOGGER.error("Server sent invalid world key name, and is being ignored.");
-//					this.isServerCommunicationEnabled = false;
-//					this.serverNetworkingIsMalformed = true;
-//					return;
-//				}
-//				
-//				LOGGER.info("Server level change event received, changing the level to ["+levelKey+"].");
-//				MC.executeOnRenderThread(() -> {
-//					if (MC.getWrappedClientWorld() != null)
-//					{
-//						this.clientLevelUnloadEvent((IClientLevelWrapper) MC.getWrappedClientWorld());
-//					}
-//					IServerKeyedClientLevel clientLevel = KEYED_CLIENT_LEVEL_MANAGER.getServerKeyedLevel(MC.getWrappedClientWorld(), levelKey);
-//					KEYED_CLIENT_LEVEL_MANAGER.setServerKeyedLevel(clientLevel);
-//					this.multiverseClientLevelLoadEvent(clientLevel);
-//				});
-//				break;
-//		}
-//	}
+	
+	public void pluginMessageReceived(@NotNull AbstractNetworkMessage message)
+	{
+		NetworkSession networkSession = this.pluginChannelApi.networkSession;
+		if (networkSession != null)
+		{
+			networkSession.tryHandleMessage(message);
+		}
+	}
 	
 	
 	
@@ -476,9 +407,9 @@ public class ClientApi
 	{
 		// logging //
 		
-		this.sendChatMessagesNow();
+		this.sendQueuedChatMessages();
 		
-		IProfilerWrapper profiler = MC.getProfiler();
+		IProfilerWrapper profiler = MC_CLIENT.getProfiler();
 		profiler.pop(); // get out of "terrain"
 		profiler.push("DH-RenderLevel");
 		
@@ -529,10 +460,24 @@ public class ClientApi
 			{
 				return;
 			}
-			IDhClientLevel level = dhClientWorld.getOrLoadClientLevel(levelWrapper);
+			
+			IDhClientLevel level = (IDhClientLevel) dhClientWorld.getLevel(levelWrapper);
+			if (level == null)
+			{
+				return;
+			}
+			
 			
 			if (this.rendererDisabledBecauseOfExceptions)
 			{
+				// re-enable rendering if the user toggles DH rendering
+				if (!Config.Client.quickEnableRendering.get())
+				{
+					LOGGER.info("DH Renderer re-enabled after exception. Some rendering issues may occur. Please reboot Minecraft if you see any rendering issues.");
+					this.rendererDisabledBecauseOfExceptions = false;
+					Config.Client.quickEnableRendering.set(true);
+				}
+				
 				return;
 			}
 			
@@ -582,10 +527,10 @@ public class ClientApi
 			this.rendererDisabledBecauseOfExceptions = true;
 			LOGGER.error("Unexpected Renderer error in render pass [" + renderPass + "]. Error: " + e.getMessage(), e);
 			
-			MC.sendChatMessage("\u00A74\u00A7l\u00A7uERROR: Distant Horizons renderer has encountered an exception!");
-			MC.sendChatMessage("\u00A74Renderer is now disabled to prevent further issues.");
-			MC.sendChatMessage("\u00A74Please restart your game to re-enable Distant Horizons' LOD rendering.");
-			MC.sendChatMessage("\u00A74Exception detail: " + e);
+			MC_CLIENT.sendChatMessage("\u00A74\u00A7l\u00A7uERROR: Distant Horizons renderer has encountered an exception!");
+			MC_CLIENT.sendChatMessage("\u00A74Renderer disabled to try preventing GL state corruption.");
+			MC_CLIENT.sendChatMessage("\u00A74Toggle DH rendering via the config UI to re-activate DH rendering.");
+			MC_CLIENT.sendChatMessage("\u00A74Error: " + e);
 		}
 		finally
 		{
@@ -625,32 +570,34 @@ public class ClientApi
 		if (glfwKey == GLFW.GLFW_KEY_F8)
 		{
 			Config.Client.Advanced.Debugging.debugRendering.set(EDhApiDebugRendering.next(Config.Client.Advanced.Debugging.debugRendering.get()));
-			MC.sendChatMessage("F8: Set debug mode to " + Config.Client.Advanced.Debugging.debugRendering.get());
+			MC_CLIENT.sendChatMessage("F8: Set debug mode to " + Config.Client.Advanced.Debugging.debugRendering.get());
 		}
 		else if (glfwKey == GLFW.GLFW_KEY_F6)
 		{
 			Config.Client.Advanced.Debugging.rendererMode.set(EDhApiRendererMode.next(Config.Client.Advanced.Debugging.rendererMode.get()));
-			MC.sendChatMessage("F6: Set rendering to " + Config.Client.Advanced.Debugging.rendererMode.get());
+			MC_CLIENT.sendChatMessage("F6: Set rendering to " + Config.Client.Advanced.Debugging.rendererMode.get());
 		}
 		else if (glfwKey == GLFW.GLFW_KEY_P)
 		{
 			prefLoggerEnabled = !prefLoggerEnabled;
-			MC.sendChatMessage("P: Debug Pref Logger is " + (prefLoggerEnabled ? "enabled" : "disabled"));
+			MC_CLIENT.sendChatMessage("P: Debug Pref Logger is " + (prefLoggerEnabled ? "enabled" : "disabled"));
 		}
 	}
 	
-	private void sendChatMessagesNow()
+	private void sendQueuedChatMessages()
 	{
 		// dev build
-		if (ModInfo.IS_DEV_BUILD && !this.configOverrideReminderPrinted && MC.playerExists())
+		if (ModInfo.IS_DEV_BUILD && !this.configOverrideReminderPrinted && MC_CLIENT.playerExists())
 		{
 			this.configOverrideReminderPrinted = true;
 			
 			// remind the user that this is a development build
-			MC.sendChatMessage("\u00A72" + "Distant Horizons: nightly/unstable build, version: [" + ModInfo.VERSION+"]." + "\u00A7r");
-			MC.sendChatMessage("Issues may occur with this version.");
-			MC.sendChatMessage("Here be dragons!");
-			MC.sendChatMessage("");
+			String message = 
+					// green text
+					"\u00A72" + "Distant Horizons: nightly/unstable build, version: [" + ModInfo.VERSION+"]." + "\u00A7r\n" +
+					"Issues may occur with this version.\n" +
+					"Here be dragons!\n";
+			MC_CLIENT.sendChatMessage(message);
 		}
 		
 		// memory
@@ -665,11 +612,13 @@ public class ClientApi
 			long maxMemoryInBytes = Runtime.getRuntime().maxMemory();
 			if (maxMemoryInBytes < minimumRecommendedMemoryInBytes)
 			{
-				MC.sendChatMessage("\u00A76" + "Distant Horizons: Low memory detected." + "\u00A7r");
-				MC.sendChatMessage("Stuttering or low FPS may occur.");
-				MC.sendChatMessage("Please increase Minecraft's available memory to 4 gigabytes.");
-				MC.sendChatMessage("This warning can be disabled in DH's config under Advanced -> Logging.");
-				MC.sendChatMessage("");
+				String message =
+						// orange text		
+						"\u00A76" + "Distant Horizons: Low memory detected." + "\u00A7r \n" +
+						"Stuttering or low FPS may occur. \n" +
+						"Please increase Minecraft's available memory to 4 gigabytes. \n" +
+						"This warning can be disabled in DH's config under Advanced -> Logging. \n";
+				MC_CLIENT.sendChatMessage(message);
 			}
 		}
 		
@@ -682,7 +631,7 @@ public class ClientApi
 				// done to prevent potential null pointers
 				message = "";
 			}
-			MC.sendChatMessage(message);
+			MC_CLIENT.sendChatMessage(message);
 		}
 	}
 	

core/src/main/java/com/seibel/distanthorizons/core/api/internal/ClientPluginChannelApi.java

@@ -0,0 +1,134 @@
+package com.seibel.distanthorizons.core.api.internal;
+
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
+import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager;
+import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel;
+import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
+import com.seibel.distanthorizons.core.network.event.internal.CloseInternalEvent;
+import com.seibel.distanthorizons.core.network.messages.base.CurrentLevelKeyMessage;
+import com.seibel.distanthorizons.core.network.session.NetworkSession;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
+import org.apache.logging.log4j.LogManager;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+
+/**
+ * This class is used to manage the level keys.
+ */
+public class ClientPluginChannelApi
+{
+	private static final ConfigBasedLogger LOGGER = new ConfigBasedLogger(LogManager.getLogger(),
+			() -> Config.Client.Advanced.Logging.logNetworkEvent.get());
+	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
+	private static final IKeyedClientLevelManager KEYED_CLIENT_LEVEL_MANAGER = SingletonInjector.INSTANCE.get(IKeyedClientLevelManager.class);
+	
+	private final Consumer<IServerKeyedClientLevel> levelLoadHandler;
+	private final Consumer<IClientLevelWrapper> levelUnloadHandler;
+	
+	@Nullable
+	public NetworkSession networkSession;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public ClientPluginChannelApi(Consumer<IServerKeyedClientLevel> levelLoadHandler, Consumer<IClientLevelWrapper> levelUnloadHandler)
+	{
+		this.levelLoadHandler = levelLoadHandler;
+		this.levelUnloadHandler = levelUnloadHandler;
+	}
+	
+	
+	
+	//============//
+	// properties //
+	//============//
+	
+	/** @return true if the level loading is handled by the server */
+	public boolean allowLevelLoading(IClientLevelWrapper level)
+	{
+		return (KEYED_CLIENT_LEVEL_MANAGER.hasLevelSet() && level instanceof IServerKeyedClientLevel)
+				|| !KEYED_CLIENT_LEVEL_MANAGER.hasLevelSet();
+	}
+	
+	
+	
+	//================//
+	// network events //
+	//================//
+	
+	/** fired when this client connects to a server with DH support */
+	public void onJoinServer(@NonNull NetworkSession networkSession)
+	{
+		Objects.requireNonNull(networkSession);
+		this.networkSession = networkSession;
+		this.networkSession.registerHandler(CurrentLevelKeyMessage.class, this::onCurrentLevelKeyMessage);
+		this.networkSession.registerHandler(CloseInternalEvent.class, this::onClose);
+	}
+	
+	private void onCurrentLevelKeyMessage(CurrentLevelKeyMessage msg)
+	{
+		// prefix@namespace:path
+		// 1-50 characters in total, all parts except namespace can be omitted
+		if (!msg.levelKey.matches("^(?=.{1,50}$)([a-zA-Z0-9-_]+@)?[a-zA-Z0-9-_]+(:[a-zA-Z0-9-_]+)?$"))
+		{
+			throw new IllegalArgumentException("Server sent invalid level key.");
+		}
+		
+		LOGGER.info("Server level key received: [" + msg.levelKey + "].");
+		
+		MC.executeOnRenderThread(() -> 
+		{
+			IClientLevelWrapper clientLevel = MC.getWrappedClientLevel(true);
+			IServerKeyedClientLevel existingKeyedClientLevel = KEYED_CLIENT_LEVEL_MANAGER.getServerKeyedLevel();
+
+			if (existingKeyedClientLevel != null)
+			{
+				if (!existingKeyedClientLevel.getServerLevelKey().equals(msg.levelKey))
+				{
+					LOGGER.info("Unloading previous level with key: [" + existingKeyedClientLevel.getServerLevelKey() + "].");
+					this.levelUnloadHandler.accept(existingKeyedClientLevel);
+				}
+				else
+				{
+					LOGGER.info("Level key matches the previous level key, ignoring the message.");
+				}
+			}
+			else
+			{
+				LOGGER.info("Unloading non-keyed level: [" + clientLevel.getDimensionName() + "].");
+				this.levelUnloadHandler.accept(clientLevel);
+			}
+			
+			if (existingKeyedClientLevel == null || !existingKeyedClientLevel.getServerLevelKey().equals(msg.levelKey))
+			{
+				LOGGER.info("Loading level with key: [" + msg.levelKey + "].");
+				IServerKeyedClientLevel keyedLevel = KEYED_CLIENT_LEVEL_MANAGER.setServerKeyedLevel(clientLevel, msg.levelKey);
+				this.levelLoadHandler.accept(keyedLevel);
+			}
+		});
+	}
+	
+	public void onClientLevelUnload() { KEYED_CLIENT_LEVEL_MANAGER.clearKeyedLevel(); }
+	
+	
+	
+	//==========//
+	// shutdown //
+	//==========//
+	
+	private void onClose(CloseInternalEvent event) { this.reset(); }
+	public void reset()
+	{
+		this.networkSession = null;
+		KEYED_CLIENT_LEVEL_MANAGER.clearKeyedLevel();
+	}
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/api/internal/ServerApi.java

@@ -21,13 +21,9 @@ package com.seibel.distanthorizons.core.api.internal;
 
 import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiLevelLoadEvent;
 import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiLevelUnloadEvent;
-import com.seibel.distanthorizons.core.config.Config;
-import com.seibel.distanthorizons.core.generation.DhLightingEngine;
-import com.seibel.distanthorizons.core.util.ThreadUtil;
+import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
 import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IServerPlayerWrapper;
-import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector;
-import com.seibel.distanthorizons.core.level.IDhLevel;
 import com.seibel.distanthorizons.core.world.AbstractDhWorld;
 import com.seibel.distanthorizons.core.world.DhClientServerWorld;
 import com.seibel.distanthorizons.core.world.DhServerWorld;
@@ -37,6 +33,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
 import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
 
 /**
  * This holds the methods that should be called by the host mod loader (Fabric,
@@ -70,7 +67,7 @@ public class ServerApi
 			if (serverWorld != null)
 			{
 				serverWorld.serverTick();
-				SharedApi.worldGenTick(serverWorld::doWorldGen);
+				SharedApi.worldGenTick(serverWorld::worldGenTick);
 			}
 		}
 		catch (Exception e)
@@ -154,7 +151,7 @@ public class ServerApi
 		IDhServerWorld serverWorld = SharedApi.getIDhServerWorld();
 		if (serverWorld instanceof DhServerWorld) // TODO add support for DhClientServerWorld's (lan worlds) as well
 		{
-			LOGGER.debug("Waiting for player to connect: " + player.getUUID());
+			LOGGER.info("Player [" + player.getName()+ "] joined.");
 			((DhServerWorld) serverWorld).addPlayer(player);
 		}
 	}
@@ -163,9 +160,27 @@ public class ServerApi
 		IDhServerWorld serverWorld = SharedApi.getIDhServerWorld();
 		if (serverWorld instanceof DhServerWorld) // TODO add support for DhClientServerWorld's (lan worlds) as well
 		{
-			LOGGER.debug("Removing player from connect wait list: " + player.getUUID());
+			LOGGER.info("Player [" + player.getName() + "] disconnected.");
 			((DhServerWorld) serverWorld).removePlayer(player);
 		}
 	}
+	public void serverPlayerLevelChangeEvent(IServerPlayerWrapper player, IServerLevelWrapper originLevel, IServerLevelWrapper destinationLevel)
+	{
+		IDhServerWorld serverWorld = SharedApi.getIDhServerWorld();
+		if (serverWorld instanceof DhServerWorld) // TODO add support for DhClientServerWorld's (lan worlds) as well
+		{
+			LOGGER.info("Player [" + player.getName() + "] changed level: ["+originLevel.getKeyedLevelDimensionName()+"] -> ["+destinationLevel.getKeyedLevelDimensionName()+"].");
+			((DhServerWorld) serverWorld).changePlayerLevel(player, originLevel, destinationLevel);
+		}
+	}
+	
+	public void pluginMessageReceived(IServerPlayerWrapper player, @NotNull AbstractNetworkMessage message)
+	{
+		IDhServerWorld serverWorld = SharedApi.getIDhServerWorld();
+		if (serverWorld instanceof DhServerWorld) // TODO add support for DhClientServerWorld's (lan worlds) as well
+		{
+			((DhServerWorld) serverWorld).remotePlayerConnectionHandler.handlePluginMessage(player, message);
+		}
+	}
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/api/internal/SharedApi.java

@@ -26,16 +26,16 @@ import com.seibel.distanthorizons.core.generation.DhLightingEngine;
 import com.seibel.distanthorizons.core.level.IDhLevel;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.logging.f3.F3Screen;
-import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
-import com.seibel.distanthorizons.core.sql.dto.BeaconBeamDTO;
 import com.seibel.distanthorizons.core.sql.repo.AbstractDhRepo;
-import com.seibel.distanthorizons.core.util.TimerUtil;
+import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.objects.Pair;
 import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
 import com.seibel.distanthorizons.core.world.*;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
@@ -43,9 +43,8 @@ import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.*;
+import java.util.concurrent.locks.ReentrantLock;
 
 /** Contains code and variables used by both {@link ClientApi} and {@link ServerApi} */
 public class SharedApi
@@ -54,17 +53,15 @@ public class SharedApi
 	
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class);
-	private static final Set<DhChunkPos> UPDATING_CHUNK_POS_SET = ConcurrentHashMap.newKeySet();
-	/** how many chunks can be queued for updating per thread, used to prevent updates from infinitely pilling up if the user flys around extremely fast */
-	private static final int MAX_UPDATING_CHUNK_COUNT_PER_THREAD = 500;
-	private static final int MIN_MS_BETWEEN_OVERLOADED_LOG_MESSAGE = 30_000;
+	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	
-	private static final Timer CHUNK_UPDATE_TIMER = TimerUtil.CreateTimer("ChunkUpdateTimer");
+	private static final UpdateChunkPosManager UPDATE_POS_MANAGER = new UpdateChunkPosManager();
+	/** how many chunks can be queued for updating per thread, used to prevent updates from infinitely pilling up if the user flies around extremely fast */
+	private static final int MAX_UPDATING_CHUNK_COUNT_PER_THREAD = 500;
 	
 	
 	private static AbstractDhWorld currentWorld;
 	private static int lastWorldGenTickDelta = 0;
-	private static long lastOverloadedLogMessageMsTime = 0;
 	
 	
 	
@@ -101,7 +98,7 @@ public class SharedApi
 			// shouldn't be necessary, but if we missed closing one of the connections this should make sure they're all closed
 			AbstractDhRepo.closeAllConnections();
 			// needs to be closed on world shutdown to clear out un-processed chunks
-			UPDATING_CHUNK_POS_SET.clear();
+			UPDATE_POS_MANAGER.clear();
 			
 			// recommend that the garbage collector cleans up any objects from the old world and thread pools
 			System.gc();
@@ -137,25 +134,15 @@ public class SharedApi
 	 * This is important since asking MC for a chunk is slow and may block the render thread.
 	 */
 	public static boolean isChunkAtBlockPosAlreadyUpdating(int blockPosX, int blockPosZ)
-	{ return UPDATING_CHUNK_POS_SET.contains(new DhChunkPos(new DhBlockPos2D(blockPosX, blockPosZ))); }
+	{ return UPDATE_POS_MANAGER.contains(new DhChunkPos(new DhBlockPos2D(blockPosX, blockPosZ))); }
+	
+	public static boolean isChunkAtChunkPosAlreadyUpdating(int chunkPosX, int chunkPosZ)
+	{ return UPDATE_POS_MANAGER.contains(new DhChunkPos(chunkPosX, chunkPosZ)); }
 	
 	
 	/** handles both block place and break events */
 	public void chunkBlockChangedEvent(IChunkWrapper chunk, ILevelWrapper level) { this.applyChunkUpdate(chunk, level, true); }
-	
 	public void chunkLoadEvent(IChunkWrapper chunk, ILevelWrapper level) { this.applyChunkUpdate(chunk, level, false); }
-	public void chunkUnloadEvent(IChunkWrapper chunk, ILevelWrapper level) 
-	{
-		// temporarily disabled since this was originally incorrectly designated as "chunkSaveEvent"
-		// but didn't actually fire on chunk save
-		// and generally this is unnecessary and drastically reduces LOD building performance
-		// when traveling around the world
-		if (false)
-		{
-			this.applyChunkUpdate(chunk, level, false);
-		}
-	}
-	
 	
 	public void applyChunkUpdate(IChunkWrapper chunkWrapper, ILevelWrapper level, boolean updateNeighborChunks)
 	{
@@ -199,43 +186,6 @@ public class SharedApi
 		
 		
 		
-		//=====================//
-		// task limiting check //
-		//=====================//
-		
-		int currentQueueCount = UPDATING_CHUNK_POS_SET.size();
-		int maxQueueCount = MAX_UPDATING_CHUNK_COUNT_PER_THREAD * Config.Client.Advanced.MultiThreading.numberOfLodBuilderThreads.get();
-		if (currentQueueCount >= maxQueueCount)
-		{
-			// The maximum number of chunks are already queued, don't add more.
-			// This is done to prevent overloading the system if the user fly's extremely fast and queues too many chunks
-			
-			long msBetweenLastLog = System.currentTimeMillis() - lastOverloadedLogMessageMsTime;
-			if (msBetweenLastLog >= MIN_MS_BETWEEN_OVERLOADED_LOG_MESSAGE)
-			{
-				lastOverloadedLogMessageMsTime = System.currentTimeMillis();
-				
-				String message = "Distant Horizons overloaded, too many chunks queued for updating. " +
-						"\nThis may result in holes in your LODs. " +
-						"\nPlease move through the world slower, decrease your vanilla render distance, slow down your world pre-generator, or increase the Distant Horizons' CPU load config. " +
-						"\nMax queue count ["+maxQueueCount+"] (["+MAX_UPDATING_CHUNK_COUNT_PER_THREAD+"] per thread).";
-				ClientApi.INSTANCE.showChatMessageNextFrame(message);
-				LOGGER.warn(message);
-			}
-			
-			return;
-		}
-		
-		// prevent duplicate update requests
-		if (UPDATING_CHUNK_POS_SET.contains(chunkWrapper.getChunkPos()))
-		{
-			// this chunk is already being updated
-			return;
-		}
-		UPDATING_CHUNK_POS_SET.add(chunkWrapper.getChunkPos());
-		
-		
-		
 		//===============================//
 		// update the necessary chunk(s) //
 		//===============================//
@@ -244,7 +194,7 @@ public class SharedApi
 		{
 			// only update the center chunk
 			
-			bakeChunkLightingAndSendToLevelAsync(chunkWrapper, null, dhLevel);
+			queueChunkUpdate(chunkWrapper, null, dhLevel);
 		}
 		else
 		{
@@ -265,7 +215,7 @@ public class SharedApi
 					else
 					{
 						// neighboring chunk
-						DhChunkPos neighbourPos = new DhChunkPos(chunkWrapper.getChunkPos().x + xOffset, chunkWrapper.getChunkPos().z + zOffset);
+						DhChunkPos neighbourPos = new DhChunkPos(chunkWrapper.getChunkPos().getX() + xOffset, chunkWrapper.getChunkPos().getZ() + zOffset);
 						IChunkWrapper neighbourChunk = dhLevel.getLevelWrapper().tryGetChunk(neighbourPos);
 						if (neighbourChunk != null)
 						{
@@ -278,113 +228,120 @@ public class SharedApi
 			// light and send the chunks
 			for (IChunkWrapper litChunk : neighbourChunkList)
 			{
-				bakeChunkLightingAndSendToLevelAsync(litChunk, neighbourChunkList, dhLevel);
+				queueChunkUpdate(litChunk, neighbourChunkList, dhLevel);
 			}
 		}
 	}
-	private static void bakeChunkLightingAndSendToLevelAsync(IChunkWrapper chunkWrapper, @Nullable ArrayList<IChunkWrapper> neighbourChunkList, IDhLevel dhLevel)
+	private static void queueChunkUpdate(IChunkWrapper chunkWrapper, @Nullable ArrayList<IChunkWrapper> neighbourChunkList, IDhLevel dhLevel)
 	{
-		// lighting the chunk needs to be done on a separate thread to prevent lagging any of the event threads
-		ThreadPoolExecutor executor = ThreadPoolUtil.getLightPopulatorExecutor();
-		if (executor == null)
+		if (MC_CLIENT != null && MC_CLIENT.playerExists())
+		{
+			UPDATE_POS_MANAGER.setCenter(MC_CLIENT.getPlayerChunkPos());
+			UPDATE_POS_MANAGER.maxSize = MAX_UPDATING_CHUNK_COUNT_PER_THREAD * Config.Client.Advanced.MultiThreading.numberOfLodBuilderThreads.get();
+		}
+		
+		UpdateChunkData updateData = new UpdateChunkData(chunkWrapper, neighbourChunkList, dhLevel);
+		UPDATE_POS_MANAGER.addItem(chunkWrapper.getChunkPos(), updateData);
+		
+		
+		
+		// queue updates up to the number of CPU cores allocated for the job
+		// (this prevents doing extra work queuing tasks that may not be necessary)
+		// and makes sure the chunks closest to the player are updated first
+		ThreadPoolExecutor executor = ThreadPoolUtil.getChunkToLodBuilderExecutor();
+		if (executor != null && executor.getQueue().size() < executor.getCorePoolSize())
+		{
+			try
+			{
+				executor.execute(SharedApi::processQueuedChunkUpdate);
+			}
+			catch (RejectedExecutionException ignore)
+			{
+				// the executor was shut down, it should be back up shortly and able to accept new jobs
+			}
+		}
+	}
+	
+	
+	/** returning a {@link CompletableFuture} isn't necessary, but allows Intellij to properly show the full stack trace when debugging. */
+	@SuppressWarnings("UnusedReturnValue")
+	private static void processQueuedChunkUpdate()
+	{
+		//LOGGER.trace(chunkWrapper.getChunkPos() + " " + executor.getActiveCount() + " / " + executor.getQueue().size() + " - " + executor.getCompletedTaskCount());
+		
+		UpdateChunkData updateData = UPDATE_POS_MANAGER.popClosest();
+		if (updateData == null)
 		{
 			return;
 		}
 		
+		IChunkWrapper chunkWrapper = updateData.chunkWrapper;
+		@Nullable ArrayList<IChunkWrapper> neighbourChunkList = updateData.neighbourChunkList;
+		IDhLevel dhLevel = updateData.dhLevel;
+		
+		
 		try
 		{
-			executor.execute(() ->
+			boolean checkChunkHash = !Config.Client.Advanced.LodBuilding.disableUnchangedChunkCheck.get();
+			
+			// check if this chunk has been converted into an LOD already
+			int oldChunkHash = dhLevel.getChunkHash(chunkWrapper.getChunkPos()); // shouldn't happen on the render thread since it may take a few moments to run
+			int newChunkHash = chunkWrapper.getBlockBiomeHashCode();
+			if (checkChunkHash)
+			{
+				if (oldChunkHash == newChunkHash)
+				{
+					// if the chunk hashes are the same then we don't need to bother with lighting the chunk
+					// or creating/updating the LODs
+					//LOGGER.info("skipping: "+chunkWrapper.getChunkPos()+" "+newChunkHash);
+					return;
+				}
+				else
+				{
+					//LOGGER.info("g: "+chunkWrapper.getChunkPos()+" "+newChunkHash);
+				}
+			}
+			
+			
+			// having a list of the nearby chunks is needed for lighting and beacon generation
+			ArrayList<IChunkWrapper> nearbyChunkList;
+			if (neighbourChunkList != null)
+			{
+				nearbyChunkList = neighbourChunkList;
+			}
+			else
+			{
+				nearbyChunkList = new ArrayList<>(1);
+				nearbyChunkList.add(chunkWrapper);
+			}
+			
+			
+			// sky lighting is populated later at the data source level
+			DhLightingEngine.INSTANCE.bakeChunkBlockLighting(chunkWrapper, nearbyChunkList, dhLevel.hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT);
+			
+			dhLevel.updateBeaconBeamsForChunk(chunkWrapper, nearbyChunkList);
+			dhLevel.updateChunkAsync(chunkWrapper, newChunkHash);
+		}
+		catch (Exception e)
+		{
+			LOGGER.error("Unexpected error when updating chunk at pos: [" + chunkWrapper.getChunkPos() + "]", e);
+		}
+		finally
+		{
+			// queue the next position if there are still positions to process
+			ThreadPoolExecutor executor = ThreadPoolUtil.getChunkToLodBuilderExecutor();
+			if (executor != null && !UPDATE_POS_MANAGER.positionMap.isEmpty())
 			{
-				//LOGGER.trace(chunkWrapper.getChunkPos() + " " + executor.getActiveCount() + " / " + executor.getQueue().size() + " - " + executor.getCompletedTaskCount());
-				
 				try
 				{
-					// check if this chunk has been converted into an LOD already
-					int oldChunkHash = dhLevel.getChunkHash(chunkWrapper.getChunkPos()); // shouldn't happen on the render thread since it may take a few moments to run
-					int newChunkHash = chunkWrapper.getBlockBiomeHashCode();
-					if (oldChunkHash == newChunkHash)
-					{
-						// if the chunk hashes are the same then we don't need to bother with lighting the chunk
-						// or creating/updating the LODs
-						//LOGGER.info("skipping: "+chunkWrapper.getChunkPos()+" "+newChunkHash);
-						return;
-					}
-					else
-					{
-						//LOGGER.info("g: "+chunkWrapper.getChunkPos()+" "+newChunkHash);
-					}
-					
-					
-					// having a list of the nearby chunks is needed for lighting and beacon generation
-					ArrayList<IChunkWrapper> nearbyChunkList;
-					if (neighbourChunkList != null)
-					{
-						nearbyChunkList = neighbourChunkList;
-					}
-					else
-					{
-						nearbyChunkList = new ArrayList<>(1);
-						nearbyChunkList.add(chunkWrapper);
-					}
-					
-					
-					// Save or populate the chunk wrapper's lighting
-					// this is done so we don't have to worry about MC unloading the lighting data for this chunk
-					boolean onlyUseDhLighting = Config.Client.Advanced.LodBuilding.onlyUseDhLightingEngine.get();
-					if (!onlyUseDhLighting && chunkWrapper.isLightCorrect())
-					{
-						try
-						{
-							// If MC's lighting engine isn't thread safe this may cause the server thread to lag
-							chunkWrapper.bakeDhLightingUsingMcLightingEngine();
-						}
-						catch (IllegalStateException e)
-						{
-							LOGGER.warn("Chunk light baking error: " + e.getMessage(), e);
-						}
-					}
-					else
-					{
-						// generate the chunk's lighting, using neighboring chunks if present
-						DhLightingEngine.INSTANCE.lightChunk(chunkWrapper, nearbyChunkList, dhLevel.hasSkyLight() ? 15 : 0);
-					}
-					
-					
-					
-					// get this chunk's active beacons
-					List<BeaconBeamDTO> beaconBeamList = chunkWrapper.getAllActiveBeacons(nearbyChunkList);
-					dhLevel.setBeaconBeamsForChunk(chunkWrapper.getChunkPos(), beaconBeamList);
-					
-					
-					dhLevel.updateChunkAsync(chunkWrapper);
-					dhLevel.setChunkHash(chunkWrapper.getChunkPos(), newChunkHash);
+					executor.execute(SharedApi::processQueuedChunkUpdate);
 				}
-				catch (Exception e)
+				catch (RejectedExecutionException ignore)
 				{
-					LOGGER.error("Unexpected error when updating chunk at pos: [" + chunkWrapper.getChunkPos() + "]", e);
+					// the executor was shut down, it should be back up shortly and able to accept new jobs
 				}
-				finally
-				{
-					// the LOD chunk has finished being updated
-					int updateTimeoutInSec = Config.Client.Advanced.LodBuilding.minTimeBetweenChunkUpdatesInSeconds.get();
-					if (updateTimeoutInSec != 0)
-					{
-						// prevent updating this chunk again until the timeout finishes
-						CHUNK_UPDATE_TIMER.schedule(new TimerTask()
-						{
-							@Override
-							public void run() { UPDATING_CHUNK_POS_SET.remove(chunkWrapper.getChunkPos()); }
-						}, updateTimeoutInSec * 1000L);
-					}
-					else
-					{
-						// instantly allow this chunk to be updated again
-						UPDATING_CHUNK_POS_SET.remove(chunkWrapper.getChunkPos());
-					}
-				}
-			});
+			}
 		}
-		catch (RejectedExecutionException ignore) { /* the executor was shut down, it should be back up shortly and able to accept new jobs */ }
 	}
 	
 	
@@ -395,11 +352,185 @@ public class SharedApi
 	
 	public String getDebugMenuString()
 	{
-		int maxUpdateCount = MAX_UPDATING_CHUNK_COUNT_PER_THREAD * Config.Client.Advanced.MultiThreading.numberOfLodBuilderThreads.get();
-		String updatingCountStr = F3Screen.NUMBER_FORMAT.format(UPDATING_CHUNK_POS_SET.size());
-		String maxUpdateCountStr = F3Screen.NUMBER_FORMAT.format(maxUpdateCount);
+		String updatingCountStr = F3Screen.NUMBER_FORMAT.format(UPDATE_POS_MANAGER.closestQueue.size());
+		String maxUpdateCountStr = F3Screen.NUMBER_FORMAT.format(UPDATE_POS_MANAGER.maxSize);
 		return "Queued chunk updates: "+updatingCountStr+" / "+maxUpdateCountStr;
 	}
 	
 	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	/** contains the objects needed to update a chunk */
+	private static class UpdateChunkData
+	{
+		public IChunkWrapper chunkWrapper;
+		@Nullable
+		public ArrayList<IChunkWrapper> neighbourChunkList;
+		public IDhLevel dhLevel;
+		
+		public UpdateChunkData(IChunkWrapper chunkWrapper, @Nullable ArrayList<IChunkWrapper> neighbourChunkList, IDhLevel dhLevel)
+		{
+			this.chunkWrapper = chunkWrapper;
+			this.neighbourChunkList = neighbourChunkList;
+			this.dhLevel = dhLevel;
+		}
+	}
+	
+	/** keeps track of which chunks need to be updated */
+	private static class UpdateChunkPosManager
+	{
+		private final PriorityQueue<DhChunkPos> closestQueue;
+		private final PriorityQueue<DhChunkPos> furthestQueue;
+		private final HashMap<DhChunkPos, UpdateChunkData> positionMap;
+		
+		private final ReentrantLock lock = new ReentrantLock();
+		
+		private DhChunkPos center;
+		private int maxSize = 500;
+		
+		
+		
+		//=============//
+		// constructor //
+		//=============//
+		
+		public UpdateChunkPosManager()
+		{
+			this.closestQueue = new PriorityQueue<>(Comparator.comparingDouble(pos -> pos.squaredDistance(this.center)));
+			this.furthestQueue = new PriorityQueue<>(Comparator.comparingDouble(pos -> ((DhChunkPos)pos).squaredDistance(this.center)).reversed());
+			this.positionMap = new HashMap<>();
+			// defaulting to 0,0 is fine since it'll be updated once we start adding items 
+			this.center = new DhChunkPos(0, 0);
+		}
+		
+		
+		
+		//==================//
+		// list/set methods //
+		//==================//
+		
+		public boolean contains(DhChunkPos pos)
+		{
+			try
+			{
+				this.lock.lock();
+				
+				return this.positionMap.containsKey(pos);
+			}
+			finally
+			{
+				this.lock.unlock();
+			}
+		}
+		
+		public void clear()
+		{
+			try
+			{
+				this.lock.lock();
+				
+				this.positionMap.clear();
+				this.closestQueue.clear();
+				this.furthestQueue.clear();
+			}
+			finally
+			{
+				this.lock.unlock();
+			}
+		}
+		
+		public void addItem(DhChunkPos pos, UpdateChunkData updateData)
+		{
+			try
+			{
+				this.lock.lock();
+				
+				if (this.positionMap.containsKey(pos))
+				{
+					return;
+				}
+				
+				if (this.positionMap.size() >= this.maxSize)
+				{
+					// Remove item furthest from the center
+					DhChunkPos furthest = this.furthestQueue.poll();
+					this.closestQueue.remove(furthest);
+					this.positionMap.remove(furthest);
+				}
+				
+				this.positionMap.put(pos, updateData);
+				this.closestQueue.add(pos);
+				this.furthestQueue.add(pos);
+			}
+			finally
+			{
+				this.lock.unlock();
+			}
+		}
+		
+		
+		
+		//==================//
+		// position methods //
+		//==================//
+		
+		public void setCenter(DhChunkPos newCenter)
+		{
+			// if the rebuild time takes too long 
+			// (in James' testing a queue of 500 items only took around 0.1 milliseconds)
+			// this equation could be changed to only update after moving 2 or 4 chunks from the center
+			if (newCenter.equals(this.center))
+			{
+				return;
+			}
+			
+			try
+			{
+				this.lock.lock();
+				
+				this.center = newCenter;
+				
+				// rebuild the priority queues to match the new center
+				this.closestQueue.clear();
+				this.furthestQueue.clear();
+				for (DhChunkPos pos : this.positionMap.keySet())
+				{
+					this.closestQueue.add(pos);
+					this.furthestQueue.add(pos);
+				}
+			}
+			finally
+			{
+				this.lock.unlock();
+			}
+		}
+		
+		public UpdateChunkData popClosest()
+		{
+			if (this.closestQueue.isEmpty())
+			{
+				return null;
+			}
+			
+			try
+			{
+				this.lock.lock();
+				
+				DhChunkPos closest = this.closestQueue.poll();
+				this.furthestQueue.remove(closest);
+				return this.positionMap.remove(closest);
+			}
+			finally
+			{
+				this.lock.unlock();
+			}
+		}
+		
+	}
+	
+	
+	
 }

core/src/main/java/com/seibel/distanthorizons/core/config/IConfigProvider.java

@@ -0,0 +1,6 @@
+package com.seibel.distanthorizons.core.config;
+
+public interface IConfigProvider
+{
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/config/eventHandlers/ReloadLodsConfigEventHandler.java

@@ -23,9 +23,9 @@ import com.seibel.distanthorizons.api.DhApi;
 import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderProxy;
 import com.seibel.distanthorizons.core.config.listeners.IConfigListener;
 
-public class DebugColumnConfigEventHandler implements IConfigListener
+public class ReloadLodsConfigEventHandler implements IConfigListener
 {
-	public static DebugColumnConfigEventHandler INSTANCE = new DebugColumnConfigEventHandler();
+	public static ReloadLodsConfigEventHandler INSTANCE = new ReloadLodsConfigEventHandler();
 	
 	@Override
 	public void onConfigValueSet()

core/src/main/java/com/seibel/distanthorizons/core/config/eventHandlers/RenderCacheConfigEventHandler.java

@@ -102,7 +102,7 @@ public class RenderCacheConfigEventHandler
 		// create a new timer task
 		TimerTask timerTask = new TimerTask()
 		{
-			public void run()
+			@Override public void run()
 			{
 				DhApi.Delayed.renderProxy.clearRenderDataCache();
 			}

core/src/main/java/com/seibel/distanthorizons/core/config/eventHandlers/ResetConfigEventHandler.java

@@ -32,7 +32,7 @@ public class ResetConfigEventHandler
 	/** private since we only ever need one handler at a time */
 	private ResetConfigEventHandler()
 	{
-		this.configChangeListener = new ConfigChangeListener<>(Config.Client.ResetConfirmation.resetAllSettings, (resetSettings) -> { doStuff(resetSettings); });
+		this.configChangeListener = new ConfigChangeListener<>(Config.Client.ResetConfirmation.resetAllSettings, (resetSettings) -> { this.doStuff(resetSettings); });
 		
 	}
 	

core/src/main/java/com/seibel/distanthorizons/core/config/eventHandlers/presets/AbstractPresetConfigEventHandler.java

@@ -19,7 +19,6 @@
 
 package com.seibel.distanthorizons.core.config.eventHandlers.presets;
 
-import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.config.ConfigBase;
 import com.seibel.distanthorizons.core.config.ConfigEntryWithPresetOptions;
 import com.seibel.distanthorizons.core.config.listeners.IConfigListener;
@@ -30,6 +29,7 @@ import com.seibel.distanthorizons.coreapi.interfaces.config.IConfigEntry;
 import com.seibel.distanthorizons.coreapi.util.StringUtil;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 
@@ -38,6 +38,7 @@ public abstract class AbstractPresetConfigEventHandler<TPresetEnum extends Enum<
 	private static final Logger LOGGER = LogManager.getLogger();
 	private static final long MS_DELAY_BEFORE_APPLYING_PRESET = 3_000;
 	
+	@Nullable
 	private static IConfigGui configGui = SingletonInjector.INSTANCE.get(IConfigGui.class);
 	private static boolean guiListenersAdded = false;
 	
@@ -57,7 +58,11 @@ public abstract class AbstractPresetConfigEventHandler<TPresetEnum extends Enum<
 	
 	public AbstractPresetConfigEventHandler()
 	{
-		configGui.addOnScreenChangeListener(() -> this.onConfigUiClosed());
+		// don't update the UI when running on a server
+		if (configGui != null) 
+		{
+			configGui.addOnScreenChangeListener(this::onConfigUiClosed);
+		}
 	}
 	
 	
@@ -168,7 +173,7 @@ public abstract class AbstractPresetConfigEventHandler<TPresetEnum extends Enum<
 		
 		if (newPreset != currentPreset)
 		{
-			this.getPresetConfigEntry().set(this.getCustomPresetEnum());
+			this.getPresetConfigEntry().set(newPreset);
 		}
 	}
 	

core/src/main/java/com/seibel/distanthorizons/core/config/eventHandlers/presets/RenderQualityPresetConfigEventHandler.java

@@ -33,6 +33,7 @@ import org.apache.logging.log4j.Logger;
 
 import java.util.*;
 
+@SuppressWarnings("FieldCanBeLocal")
 public class RenderQualityPresetConfigEventHandler extends AbstractPresetConfigEventHandler<EDhApiQualityPreset>
 {
 	public static final RenderQualityPresetConfigEventHandler INSTANCE = new RenderQualityPresetConfigEventHandler();

core/src/main/java/com/seibel/distanthorizons/core/config/eventHandlers/presets/ThreadPresetConfigEventHandler.java

@@ -32,6 +32,7 @@ import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 
+@SuppressWarnings("FieldCanBeLocal")
 public class ThreadPresetConfigEventHandler extends AbstractPresetConfigEventHandler<EDhApiThreadPreset>
 {
 	public static final ThreadPresetConfigEventHandler INSTANCE = new ThreadPresetConfigEventHandler();
@@ -128,6 +129,28 @@ public class ThreadPresetConfigEventHandler extends AbstractPresetConfigEventHan
 			}});
 	
 	
+	public static int getNetworkCompressionDefaultThreadCount() { return getThreadCountByPercent(0.3); }
+	private final ConfigEntryWithPresetOptions<EDhApiThreadPreset, Integer> networkCompressionThreadCount = new ConfigEntryWithPresetOptions<>(Config.Client.Advanced.MultiThreading.numberOfNetworkCompressionThreads,
+			new HashMap<EDhApiThreadPreset, Integer>()
+			{{
+				this.put(EDhApiThreadPreset.MINIMAL_IMPACT, 1);
+				this.put(EDhApiThreadPreset.LOW_IMPACT, getNetworkCompressionDefaultThreadCount());
+				this.put(EDhApiThreadPreset.BALANCED, getThreadCountByPercent(0.4));
+				this.put(EDhApiThreadPreset.AGGRESSIVE, getThreadCountByPercent(0.6));
+				this.put(EDhApiThreadPreset.I_PAID_FOR_THE_WHOLE_CPU, getThreadCountByPercent(0.8));
+			}});
+	public static double getNetworkCompressionDefaultRunTimeRatio() { return 0.5; }
+	private final ConfigEntryWithPresetOptions<EDhApiThreadPreset, Double> networkCompressionRunTime = new ConfigEntryWithPresetOptions<>(Config.Client.Advanced.MultiThreading.runTimeRatioForNetworkCompressionThreads,
+			new HashMap<EDhApiThreadPreset, Double>()
+			{{
+				this.put(EDhApiThreadPreset.MINIMAL_IMPACT, 0.25);
+				this.put(EDhApiThreadPreset.LOW_IMPACT, getNetworkCompressionDefaultRunTimeRatio());
+				this.put(EDhApiThreadPreset.BALANCED, 0.75);
+				this.put(EDhApiThreadPreset.AGGRESSIVE, 1.0);
+				this.put(EDhApiThreadPreset.I_PAID_FOR_THE_WHOLE_CPU, 1.0);
+			}});
+	
+	
 	
 	//==============//
 	// constructors //
@@ -149,6 +172,9 @@ public class ThreadPresetConfigEventHandler extends AbstractPresetConfigEventHan
 		this.configList.add(this.lodBuilderThreadCount);
 		this.configList.add(this.lodBuilderRunTime);
 		
+		this.configList.add(this.networkCompressionThreadCount);
+		this.configList.add(this.networkCompressionRunTime);
+		
 		
 		for (ConfigEntryWithPresetOptions<EDhApiThreadPreset, ?> config : this.configList)
 		{

core/src/main/java/com/seibel/distanthorizons/core/config/file/ConfigFileHandling.java

@@ -20,11 +20,13 @@
 package com.seibel.distanthorizons.core.config.file;
 
 import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import com.seibel.distanthorizons.core.config.types.enums.EConfigEntryRelevantSide;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.config.ConfigBase;
 import com.seibel.distanthorizons.core.config.types.AbstractConfigType;
 import com.seibel.distanthorizons.core.config.types.ConfigEntry;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -40,23 +42,35 @@ import java.nio.file.Path;
  */
 public class ConfigFileHandling
 {
+	private static final IMinecraftSharedWrapper MC_SHARED = SingletonInjector.INSTANCE.get(IMinecraftSharedWrapper.class);
+	
+	
 	public final ConfigBase configBase;
 	public final Path configPath;
 	
-	private final Logger LOGGER;
+	private final Logger logger;
 	
 	/** This is the object for night-config */
 	private final CommentedFileConfig nightConfig;
 	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
 	public ConfigFileHandling(ConfigBase configBase, Path configPath)
 	{
-		this.LOGGER = LogManager.getLogger(this.getClass().getSimpleName() + ", " + configBase.modID);
+		this.logger = LogManager.getLogger(this.getClass().getSimpleName() + ", " + configBase.modID);
 		this.configBase = configBase;
 		this.configPath = configPath;
 		
 		this.nightConfig = CommentedFileConfig.builder(this.configPath.toFile()).build();
 	}
 	
+	
+	
+	
 	/** Saves the entire config to the file */
 	public void saveToFile()
 	{
@@ -102,7 +116,7 @@ public class ConfigFileHandling
 	 */
 	public void loadFromFile()
 	{
-		int currentCfgVersion = configBase.configVersion;
+		int currentCfgVersion = this.configBase.configVersion;
 		try
 		{
 			// Dont load the real `this.nightConfig`, instead create a tempoary one
@@ -113,27 +127,29 @@ public class ConfigFileHandling
 			tmpNightConfig.close();
 		} catch (Exception ignored) { }
 		
-		if (currentCfgVersion == configBase.configVersion)
-		{}
-		else if (currentCfgVersion > configBase.configVersion)
+		if (currentCfgVersion == this.configBase.configVersion)
 		{
-			LOGGER.warn("Found config version [" + String.valueOf(currentCfgVersion) + "] which is newer than current mods config version of [" + String.valueOf(configBase.configVersion) + "]. You may have downgraded the mod and items may have been moved, you have been warned");
+			// handle normally
+		}
+		else if (currentCfgVersion > this.configBase.configVersion)
+		{
+			this.logger.warn("Found config version [" + currentCfgVersion + "] which is newer than current mods config version of [" + this.configBase.configVersion + "]. You may have downgraded the mod and items may have been moved, you have been warned");
 		}
 		else // if (currentCfgVersion < configBase.configVersion)
 		{
-			LOGGER.warn(configBase.modName +" config is of an older version, currently there is no config updater... so resetting config");
+			this.logger.warn(this.configBase.modName +" config is of an older version, currently there is no config updater... so resetting config");
 			try
 			{
-				Files.delete(configPath);
+				Files.delete(this.configPath);
 			}
 			catch (Exception e)
 			{
-				LOGGER.error(e);
+				this.logger.error(e);
 			}
 		}
 		
-		loadFromFile(nightConfig);
-		nightConfig.set("_version", configBase.configVersion);
+		this.loadFromFile(this.nightConfig);
+		this.nightConfig.set("_version", this.configBase.configVersion);
 	}
 	/**
 	 * Loads the entire config from the file
@@ -184,24 +200,34 @@ public class ConfigFileHandling
 	// Save an entry when only given the entry
 	public void saveEntry(ConfigEntry<?> entry)
 	{
-		saveEntry(entry, nightConfig);
-		nightConfig.save();
+		this.saveEntry(entry, this.nightConfig);
+		this.nightConfig.save();
 	}
 	/** Save an entry */
 	public void saveEntry(ConfigEntry<?> entry, CommentedFileConfig workConfig)
 	{
-		if (!entry.getAppearance().showInFile) return;
-		if (entry.getTrueValue() == null)
-			throw new IllegalArgumentException("Entry [" + entry.getNameWCategory() + "] is null, this may be a problem with [" + configBase.modName + "]. Please contact the authors");
+		if (!entry.getAppearance().showInFile)
+		{
+			return;
+		}
+		else if ((entry.getRelevantSide() == EConfigEntryRelevantSide.CLIENT && MC_SHARED.isDedicatedServer())
+				|| (entry.getRelevantSide() == EConfigEntryRelevantSide.SERVER && !MC_SHARED.isDedicatedServer()))
+		{
+			// don't save server/client specific configs on the opposite
+			// (this keeps the config file clean of unnecessary items)
+			return;
+		}
+		else if (entry.getTrueValue() == null)
+		{
+			// TODO when can this happen?
+			throw new IllegalArgumentException("Entry [" + entry.getNameWCategory() + "] is null, this may be a problem with [" + this.configBase.modName + "]. Please contact the authors.");
+		}
 		
 		workConfig.set(entry.getNameWCategory(), ConfigTypeConverters.attemptToConvertToString(entry.getType(), entry.getTrueValue()));
 	}
 	
 	/** Loads an entry when only given the entry */
-	public void loadEntry(ConfigEntry<?> entry)
-	{
-		loadEntry(entry, nightConfig);
-	}
+	public void loadEntry(ConfigEntry<?> entry) { this.loadEntry(entry, this.nightConfig); }
 	/** Loads an entry */
 	@SuppressWarnings("unchecked")
 	public <T> void loadEntry(ConfigEntry<T> entry, CommentedFileConfig nightConfig)
@@ -211,7 +237,7 @@ public class ConfigFileHandling
 		
 		if (!nightConfig.contains(entry.getNameWCategory()))
 		{
-			saveEntry(entry, nightConfig);
+			this.saveEntry(entry, nightConfig);
 			return;
 		}
 		
@@ -230,7 +256,7 @@ public class ConfigFileHandling
 			Object convertedValue = ConfigTypeConverters.attemptToConvertFromString(expectedValueClass, value);
 			if (!convertedValue.getClass().equals(expectedValueClass))
 			{
-				LOGGER.error("Unable to convert config value ["+value+"] from ["+(value != null ? value.getClass() : "NULL")+"] to ["+expectedValueClass+"] for config ["+entry.name+"], " +
+				this.logger.error("Unable to convert config value ["+value+"] from ["+(value != null ? value.getClass() : "NULL")+"] to ["+expectedValueClass+"] for config ["+entry.name+"], " +
 						"the default config value will be used instead ["+entry.getDefaultValue()+"]. " +
 						"Make sure a converter is defined in ["+ConfigTypeConverters.class.getSimpleName()+"].");
 				convertedValue = entry.getDefaultValue();
@@ -239,31 +265,39 @@ public class ConfigFileHandling
 			
 			if (entry.getTrueValue() == null) 
 			{
-				LOGGER.warn("Entry [" + entry.getNameWCategory() + "] returned as null from the config. Using default value.");
+				this.logger.warn("Entry [" + entry.getNameWCategory() + "] returned as null from the config. Using default value.");
 				entry.pureSet(entry.getDefaultValue());
 			}
 		}
 		catch (Exception e)
 		{
 //                e.printStackTrace();
-			LOGGER.warn("Entry [" + entry.getNameWCategory() + "] had an invalid value when loading the config. Using default value.");
+			this.logger.warn("Entry [" + entry.getNameWCategory() + "] had an invalid value when loading the config. Using default value.");
 			entry.pureSet(entry.getDefaultValue());
 		}
 	}
 	
 	// Creates the comment for an entry when only given the entry
-	public void createComment(ConfigEntry<?> entry)
-	{
-		createComment(entry, nightConfig);
-	}
+	public void createComment(ConfigEntry<?> entry) { this.createComment(entry, this.nightConfig); }
 	// Creates a comment for an entry
 	public void createComment(ConfigEntry<?> entry, CommentedFileConfig nightConfig)
 	{
-		if (
-				!entry.getAppearance().showInFile || 
-				entry.getComment() == null
-		)
+		if (!entry.getAppearance().showInFile 
+			|| entry.getComment() == null)
+		{
 			return;
+		}
+		
+		
+		
+		if ((entry.getRelevantSide() == EConfigEntryRelevantSide.CLIENT && MC_SHARED.isDedicatedServer())
+				|| (entry.getRelevantSide() == EConfigEntryRelevantSide.SERVER && !MC_SHARED.isDedicatedServer()))
+		{
+			// don't save server/client specific configs on the opposite
+			// (this keeps the config file clean of unnecessary items)
+			return;
+		}
+		
 		
 		String comment = entry.getComment().replaceAll("\n", "\n ").trim();
 		// the new line makes it easier to read and separate configs
@@ -302,7 +336,7 @@ public class ConfigFileHandling
 			}
 			catch (Exception e)
 			{
-				LOGGER.warn("Loading file failed because of this expectation:\n" + e);
+				this.logger.warn("Loading file failed because of this expectation:\n" + e);
 				
 				reCreateFile(this.configPath);
 				
@@ -312,7 +346,7 @@ public class ConfigFileHandling
 		catch (Exception ex)
 		{
 			System.out.println("Creating file failed");
-			LOGGER.error(ex);
+			this.logger.error(ex);
 			SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class).crashMinecraft("Loading file and resetting config file failed at path [" + configPath + "]. Please check the file is ok and you have the permissions", ex);
 		}
 	}

core/src/main/java/com/seibel/distanthorizons/core/config/types/ConfigEntry.java

@@ -20,16 +20,23 @@
 package com.seibel.distanthorizons.core.config.types;
 
 
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Table;
 import com.seibel.distanthorizons.core.config.NumberUtil;
 import com.seibel.distanthorizons.core.config.listeners.ConfigChangeListener;
 import com.seibel.distanthorizons.core.config.listeners.IConfigListener;
 import com.seibel.distanthorizons.core.config.types.enums.EConfigEntryAppearance;
 import com.seibel.distanthorizons.core.config.types.enums.EConfigEntryPerformance;
+import com.seibel.distanthorizons.core.config.types.enums.EConfigEntryRelevantSide;
 import com.seibel.distanthorizons.coreapi.interfaces.config.IConfigEntry;
 
-import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.*;
 import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Use for making the config variables
@@ -44,6 +51,10 @@ public class ConfigEntry<T> extends AbstractConfigType<T, ConfigEntry<T>> implem
 	private T min;
 	private T max;
 	private final ArrayList<IConfigListener> listenerList;
+	private final String serversideShortName;
+	
+	private final EConfigEntryPerformance performance;
+	private final EConfigEntryRelevantSide relevantSide;
 	
 	// API control //
 	/**
@@ -53,19 +64,25 @@ public class ConfigEntry<T> extends AbstractConfigType<T, ConfigEntry<T>> implem
 	public final boolean allowApiOverride;
 	private T apiValue;
 	
-	private final EConfigEntryPerformance performance;
 	
 	
 	/** Creates the entry */
-	private ConfigEntry(EConfigEntryAppearance appearance, T value, String comment, T min, T max, boolean allowApiOverride, EConfigEntryPerformance performance, ArrayList<IConfigListener> listenerList)
+	private ConfigEntry(
+			EConfigEntryAppearance appearance, 
+			T value, String comment, T min, T max, 
+			String serversideShortName, boolean allowApiOverride, 
+			EConfigEntryPerformance performance, EConfigEntryRelevantSide relevantSide, 
+			ArrayList<IConfigListener> listenerList)
 	{
 		super(appearance, value);
 		
 		this.comment = comment;
 		this.min = min;
 		this.max = max;
+		this.serversideShortName = serversideShortName;
 		this.allowApiOverride = allowApiOverride;
 		this.performance = performance;
+		this.relevantSide = relevantSide;
 		this.listenerList = listenerList;
 	}
 	
@@ -124,9 +141,9 @@ public class ConfigEntry<T> extends AbstractConfigType<T, ConfigEntry<T>> implem
 	@Override
 	public T get()
 	{
-		if (allowApiOverride && apiValue != null)
+		if (this.allowApiOverride && this.apiValue != null)
 		{
-			return apiValue;
+			return this.apiValue;
 		}
 		
 		return super.get();
@@ -175,10 +192,19 @@ public class ConfigEntry<T> extends AbstractConfigType<T, ConfigEntry<T>> implem
 	public void clampWithinRange(T min, T max)
 	{
 		byte validness = this.isValid(min, max);
-		if (validness == -1) this.value = (T) NumberUtil.getMinimum(this.value.getClass());
-		if (validness == 1) this.value = (T) NumberUtil.getMaximum(this.value.getClass());
+		if (validness == -1)
+		{
+			this.value = (T) NumberUtil.getMinimum(this.value.getClass());
+		}
+		if (validness == 1)
+		{
+			this.value = (T) NumberUtil.getMaximum(this.value.getClass());
+		}
 	}
 	
+	// TODO is this for command line use?
+	public String getServersideShortName() { return this.serversideShortName; }
+	
 	@Override
 	public String getComment() { return this.comment; }
 	@Override
@@ -186,9 +212,11 @@ public class ConfigEntry<T> extends AbstractConfigType<T, ConfigEntry<T>> implem
 	
 	/** Gets the performance impact of an option */
 	public EConfigEntryPerformance getPerformance() { return this.performance; }
+	/** Gets whether this config should apply to the client, server, or both */
+	public EConfigEntryRelevantSide getRelevantSide() { return this.relevantSide; }
 	
 	/** Fired whenever the config value changes to a new value. */
-	public void addValueChangeListener(Consumer<T> onValueChangeFunc)
+	@Override public void addValueChangeListener(Consumer<T> onValueChangeFunc)
 	{
 		ConfigChangeListener<T> changeListener = new ConfigChangeListener<>(this, onValueChangeFunc);
 		this.addListener(changeListener);
@@ -219,7 +247,7 @@ public class ConfigEntry<T> extends AbstractConfigType<T, ConfigEntry<T>> implem
 	 * <p> -1 == number too low
 	 */
 	@Override
-	public byte isValid() { return isValid(this.value, this.min, this.max); }
+	public byte isValid() { return this.isValid(this.value, this.min, this.max); }
 	/**
 	 * Checks if a new value is valid
 	 *
@@ -256,117 +284,197 @@ public class ConfigEntry<T> extends AbstractConfigType<T, ConfigEntry<T>> implem
 	public byte isValid(T value, T min, T max)
 	{
 		if (this.configBase.disableMinMax)
+		{
 			return 0;
-		
-		if (value == null || this.value == null || value.getClass() != this.value.getClass()) // If the 2 variables aren't the same type then it will be invalid
+		}
+		else if (min == null && max == null)
+		{
+			// no validation is needed for this field
+			return 0;
+		}
+		else if (value == null || this.value == null
+				|| value.getClass() != this.value.getClass())
+		{
+			// If the 2 variables aren't the same type then it will be invalid
 			return 2;
-		if (Number.class.isAssignableFrom(value.getClass()))
-		{ // Only check min max if it is a number
+		}
+		else if (Number.class.isAssignableFrom(value.getClass()))
+		{ 
+			// Only check min max if it is a number
 			if (max != null && NumberUtil.greaterThan((Number) value, (Number) max))
+			{
 				return 1;
+			}
 			if (min != null && NumberUtil.lessThan((Number) value, (Number) min))
+			{
 				return -1;
+			}
 			
 			return 0;
 		}
-		return 0;
+		else
+		{
+			return 0;
+		}
 	}
 	
 	/** This should normally not be called since set() automatically calls this */
-	public void save() { configBase.configFileINSTANCE.saveEntry(this); }
+	public void save() { this.configBase.configFileINSTANCE.saveEntry(this); }
 	/** This should normally not be called except for special circumstances */
-	public void load() { configBase.configFileINSTANCE.loadEntry(this); }
+	public void load() { this.configBase.configFileINSTANCE.loadEntry(this); }
 	
 	
 	@Override
-	public boolean equals(IConfigEntry<?> obj) { return obj.getClass() == ConfigEntry.class && equals((ConfigEntry<?>) obj); }
+	public boolean equals(IConfigEntry<?> obj) { return obj.getClass() == ConfigEntry.class && this.equals((ConfigEntry<?>) obj); }
 	/** Is the value of this equal to another */
 	public boolean equals(ConfigEntry<?> obj)
 	{
 		// Can all of this just be "return this.value.equals(obj.value)"?
 		
 		if (Number.class.isAssignableFrom(this.value.getClass()))
+		{
 			return this.value == obj.value;
+		}
 		else
+		{
 			return this.value.equals(obj.value);
+		}
 	}
 	
-	
-	public static class Builder<T> extends AbstractConfigType.Builder<T, Builder<T>>
+	public static class Builder<TValue> extends AbstractConfigType.Builder<TValue, Builder<TValue>>
 	{
 		private String tmpComment = null;
-		private T tmpMin = null;
-		private T tmpMax = null;
+		private TValue tmpMin = null;
+		private TValue tmpMax = null;
+		protected String tmpServersideShortName = null;
 		private boolean tmpUseApiOverwrite = true;
 		private EConfigEntryPerformance tmpPerformance = EConfigEntryPerformance.DONT_SHOW;
+		private EConfigEntryRelevantSide tmpRelevantSide = EConfigEntryRelevantSide.CLIENT;
 		protected ArrayList<IConfigListener> tmpIConfigListener = new ArrayList<>();
 		
-		public Builder<T> comment(String newComment)
+		private Supplier<TValue> computedValueGetter;
+		private Consumer<TValue> computedValueSetter;
+		private boolean preventAutoApplyUntilExit;
+		
+		public Builder<TValue> comment(String newComment)
 		{
 			this.tmpComment = newComment;
 			return this;
 		}
 		
+		public Builder<TValue> computed(Supplier<TValue> computedValueGetter, Consumer<TValue> computedValueSetter)
+		{
+			this.computedValueGetter = computedValueGetter;
+			this.computedValueSetter = computedValueSetter;
+			this.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI);
+			return this;
+		}
+		
+		public Builder<TValue> linkedTo(DeferredAccessor<TValue> otherConfigAccessor)
+		{
+			return this.computed(
+					otherConfigAccessor::get,
+					otherConfigAccessor::set
+			);
+		}
+		
+		public Builder<TValue> preset(PresetBuilder<TValue> presetBuilder)
+		{
+			return this.computed(
+					() -> {
+						List<TValue> values = presetBuilder.presetValues.entrySet().stream()
+								.map(entry -> entry.getValue().inverse().get(entry.getKey().get()))
+								.distinct().limit(2)
+								.collect(Collectors.toList());
+						
+						if (values.size() != 1)
+						{
+							return presetBuilder.customStateValue;
+						}
+						
+						return values.get(0);
+					},
+					value -> {
+						for (Map.Entry<DeferredAccessor<Object>, BiMap<TValue, Object>> entry : presetBuilder.presetValues.entrySet())
+						{
+							entry.getKey().set(entry.getValue().get(value));
+						}
+					}
+			);
+		}
+		
 		/** Allows most values to be set by 1 setter */
-		public Builder<T> setMinDefaultMax(T newMin, T newDefault, T newMax)
+		public Builder<TValue> setMinDefaultMax(TValue newMin, TValue newDefault, TValue newMax)
 		{
 			this.set(newDefault);
 			this.setMinMax(newMin, newMax);
 			return this;
 		}
 		
-		public Builder<T> setMinMax(T newMin, T newMax)
+		public Builder<TValue> setMinMax(TValue newMin, TValue newMax)
 		{
 			this.tmpMin = newMin;
 			this.tmpMax = newMax;
 			return this;
 		}
 		
-		public Builder<T> setMin(T newMin)
+		public Builder<TValue> setMin(TValue newMin)
 		{
 			this.tmpMin = newMin;
 			return this;
 		}
 		
-		public Builder<T> setMax(T newMax)
+		public Builder<TValue> setMax(TValue newMax)
 		{
 			this.tmpMax = newMax;
 			return this;
 		}
 		
-		public Builder<T> setUseApiOverwrite(boolean newUseApiOverwrite)
+		public Builder<TValue> setServersideShortName(String name)
+		{
+			this.tmpServersideShortName = name;
+			return this;
+		}
+		
+		public Builder<TValue> setUseApiOverwrite(boolean newUseApiOverwrite)
 		{
 			this.tmpUseApiOverwrite = newUseApiOverwrite;
 			return this;
 		}
 		
-		public Builder<T> setPerformance(EConfigEntryPerformance newPerformance)
+		public Builder<TValue> setPerformance(EConfigEntryPerformance newPerformance)
 		{
 			this.tmpPerformance = newPerformance;
 			return this;
 		}
 		
+		public Builder<TValue> setSide(EConfigEntryRelevantSide relevantSide)
+		{
+			this.tmpRelevantSide = relevantSide;
+			return this;
+		}
 		
 		
-		public Builder<T> replaceListeners(ArrayList<IConfigListener> newConfigListener)
+		
+		public Builder<TValue> replaceListeners(ArrayList<IConfigListener> newConfigListener)
 		{
 			this.tmpIConfigListener = newConfigListener;
 			return this;
 		}
 		
-		public Builder<T> addListeners(IConfigListener... newConfigListener)
+		public Builder<TValue> addListeners(IConfigListener... newConfigListener)
 		{
 			this.tmpIConfigListener.addAll(Arrays.asList(newConfigListener));
 			return this;
 		}
 		
-		public Builder<T> addListener(IConfigListener newConfigListener)
+		public Builder<TValue> addListener(IConfigListener newConfigListener)
 		{
 			this.tmpIConfigListener.add(newConfigListener);
 			return this;
 		}
 		
-		public Builder<T> clearListeners()
+		public Builder<TValue> clearListeners()
 		{
 			this.tmpIConfigListener.clear();
 			return this;
@@ -374,9 +482,55 @@ public class ConfigEntry<T> extends AbstractConfigType<T, ConfigEntry<T>> implem
 		
 		
 		
-		public ConfigEntry<T> build()
+		public ConfigEntry<TValue> build()
 		{
-			return new ConfigEntry<>(this.tmpAppearance, this.tmpValue, this.tmpComment, this.tmpMin, this.tmpMax, this.tmpUseApiOverwrite, this.tmpPerformance, this.tmpIConfigListener);
+			return new ConfigEntry<>(
+					this.tmpAppearance, 
+					this.tmpValue, this.tmpComment, this.tmpMin, this.tmpMax, 
+					this.tmpServersideShortName, this.tmpUseApiOverwrite, 
+					this.tmpPerformance, this.tmpRelevantSide, this.tmpIConfigListener);
+		}
+		
+	}
+	
+	/**
+	 * Wraps deferred accesses to a ConfigEntry. <br>
+	 * It replaces the direct uses of ConfigEntry in places where Java runtime should not attempt
+	 * to dereference path to said entry, until initialization is done.
+	 */
+	@FunctionalInterface
+	public interface DeferredAccessor<T>
+	{
+		ConfigEntry<T> getEntry();
+		
+		default T get() { return this.getEntry().get(); }
+		default void set(T value) { this.getEntry().set(value); }
+		
+	}
+	
+	public static class PresetBuilder<TValue>
+	{
+		public final TValue customStateValue;
+		public final Map<DeferredAccessor<Object>, BiMap<TValue, Object>> presetValues = new HashMap<>();
+		
+		public PresetBuilder(TValue customStateValue)
+		{
+			this.customStateValue = customStateValue;
+		}
+		
+		@SuppressWarnings("unchecked")
+		public <TControlledEntryValue> PresetBuilder<TValue> addConfigEntry(
+				DeferredAccessor<TControlledEntryValue> controlledEntrySupplier,
+				Consumer<Map<TValue, TControlledEntryValue>> presetValueInitializer
+		)
+		{
+			presetValueInitializer.accept(
+					(Map<TValue, TControlledEntryValue>) this.presetValues.computeIfAbsent(
+							(DeferredAccessor<Object>) controlledEntrySupplier,
+							ignored -> HashBiMap.create()
+					)
+			);
+			return this;
 		}
 		
 	}

core/src/main/java/com/seibel/distanthorizons/core/config/types/ConfigLinkedEntry.java

@@ -1,63 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.core.config.types;
-
-import com.seibel.distanthorizons.core.config.types.enums.EConfigEntryAppearance;
-
-/**
- * Creates a UI element that copies everything from another element.
- * This only effects the UI
- *
- * @author coolGi
- */
-@Deprecated // FIXME doesn't work with localization
-public class ConfigLinkedEntry extends AbstractConfigType<AbstractConfigType<?, ?>, ConfigLinkedEntry>
-{
-	public ConfigLinkedEntry(AbstractConfigType<?, ?> value)
-	{
-		super(EConfigEntryAppearance.ONLY_IN_GUI, value);
-	}
-	
-	/** Appearance shouldn't be changed */
-	@Override
-	public void setAppearance(EConfigEntryAppearance newAppearance) { }
-	
-	/** Value shouldn't be changed after creation */
-	@Override
-	public void set(AbstractConfigType<?, ?> newValue) { }
-	
-	
-	public static class Builder extends AbstractConfigType.Builder<AbstractConfigType<?, ?>, Builder>
-	{
-		/** Appearance shouldn't be changed */
-		@Override
-		public Builder setAppearance(EConfigEntryAppearance newAppearance)
-		{
-			return this;
-		}
-		
-		public ConfigLinkedEntry build()
-		{
-			return new ConfigLinkedEntry(this.tmpValue);
-		}
-		
-	}
-	
-}

core/src/main/java/com/seibel/distanthorizons/core/config/types/enums/EConfigEntryRelevantSide.java

@@ -17,14 +17,20 @@
  *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package com.seibel.distanthorizons.core.network.protocol;
+package com.seibel.distanthorizons.core.config.types.enums;
 
 /**
- * CLIENT, <br>
- * SERVER, <br>
+ * BOTH,    <br>
+ * SERVER,  <br>
+ * CLIENT,  <br>
+ * 
+ * Defines whether this config entry is for the client, server, or both.
+ * TODO this needs a better name.
  */
-public enum EMessageHandlerSide
+public enum EConfigEntryRelevantSide
 {
+	BOTH,
+	SERVER,
 	CLIENT,
-	SERVER
+	
 }

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/fullData/sources/FullDataSourceV2.java

@@ -62,6 +62,8 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 	
 	/** measured in data columns */
 	public static final int WIDTH = 64;
+	/** how many chunks wide this datasource is. */
+	public static final int NUMB_OF_CHUNKS_WIDE = WIDTH / LodUtil.CHUNK_WIDTH;
 	
 	public static final byte DATA_FORMAT_VERSION = 1;
 	
@@ -88,12 +90,14 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 	
 	/** 
 	 * stores how far each column has been generated should start with {@link EDhApiWorldGenerationStep#EMPTY}
-	 * @see EDhApiWorldGenerationStep 
+	 *
+	 * @see EDhApiWorldGenerationStep
 	 */
 	public byte[] columnGenerationSteps;
 	/** 
 	 * stores what world compression was used for each column.
-	 * @see EDhApiWorldCompressionMode 
+	 *
+	 * @see EDhApiWorldCompressionMode
 	 */
 	public byte[] columnWorldCompressionMode;
 	
@@ -142,7 +146,7 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 		this.columnWorldCompressionMode = columnWorldCompressionMode;
 	}
 	
-	public static FullDataSourceV2 createFromChunk(IChunkWrapper chunkWrapper) { return LodDataBuilder.createGeneratedDataSource(chunkWrapper); }
+	public static FullDataSourceV2 createFromChunk(IChunkWrapper chunkWrapper) { return LodDataBuilder.createFromChunk(chunkWrapper); }
 	
 	public static FullDataSourceV2 createFromLegacyDataSourceV1(FullDataSourceV1 legacyData)
 	{
@@ -178,7 +182,7 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 						
 						boolean isAir = legacyData.mapping.getBlockStateWrapper(FullDataPointUtil.getId(dataPoint)).isAir();
 						byte blockLight = (byte) FullDataPointUtil.getBlockLight(dataPoint);
-
+						
 						if (isAir)
 						{
 							// air shouldn't have any light, otherwise down sampling will look weird
@@ -377,7 +381,7 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 		for (int x = 0; x < WIDTH; x += 2)
 		{
 			for (int z = 0; z < WIDTH; z += 2)
-			{			
+			{
 				int recipientX = (x / 2) + recipientOffsetX;
 				int recipientZ = (z / 2) + recipientOffsetZ;
 				int recipientIndex = relativePosToIndex(recipientX, recipientZ);
@@ -610,7 +614,7 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 			int id = determineMostValueInColumnSlice(mergeIds, inputDataSource.mapping);
 			byte blockLight = (byte) determineAverageValueInColumnSlice(mergeBlockLights);
 			byte skyLight = (byte) determineAverageValueInColumnSlice(mergeSkyLights);
-
+			
 			// if this slice is different then the last one, create a new one
 			if (id != lastId
 				// block and sky light might not be necessary
@@ -696,7 +700,7 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 		{
 			LodUtil.assertTrue(sliceArray.length == 4, "Column Slice should only contain 4 values.");
 		}
-			
+		
 		int value0 = sliceArray[0];
 		int count0 = 0;
 		int value1 = sliceArray[1];
@@ -717,26 +721,42 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 			}
 			
 			if (value == value0)
+			{
 				count0++;
+			}
 			else if (value == value1)
+			{
 				count1++;
+			}
 			else if (value == value2)
+			{
 				count2++;
+			}
 			else
+			{
 				count3++;
+			}
 		}
 		
 		// return the most common occurance
 		int maxCount = Math.max(count0, Math.max(count1, Math.max(count2, count3)));
 		if (maxCount == count0)
-			// if the max count is 1 then we'll just go with the first column
+		// if the max count is 1 then we'll just go with the first column
+		{
 			return value0;
+		}
 		else if (maxCount == count1)
+		{
 			return value1;
+		}
 		else if (maxCount == count2)
+		{
 			return value2;
-		else 
+		}
+		else
+		{
 			return value3;
+		}
 	}
 	private static int determineAverageValueInColumnSlice(int[] sliceArray)
 	{
@@ -874,8 +894,8 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 	{
 		int index = relativePosToIndex(relX, relZ);
 		this.dataPoints[index] = longArray;
-		this.columnGenerationSteps[index] =  worldGenStep.value;
-		this.columnWorldCompressionMode[index] =  worldCompressionMode.value;
+		this.columnGenerationSteps[index] = worldGenStep.value;
+		this.columnWorldCompressionMode[index] = worldCompressionMode.value;
 		
 		
 		if (RUN_UPDATE_DEV_VALIDATION)
@@ -940,7 +960,7 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 			// the positions are the same, use the hash as a quick method
 			// to determine if the data inside is the same.
 			// Note: this isn't perfect, but should work well enough for our use case.
-			return other.hashCode() == this.hashCode();	
+			return other.hashCode() == this.hashCode();
 		}
 	}
 	

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/render/ColumnRenderSource.java

@@ -25,7 +25,7 @@ import com.seibel.distanthorizons.core.dataObjects.transformers.FullDataToRender
 import com.seibel.distanthorizons.core.file.DataSourcePool;
 import com.seibel.distanthorizons.core.file.IDataSource;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnArrayView;
@@ -182,7 +182,7 @@ public class ColumnRenderSource implements IDataSource<IDhClientLevel>
 						EDhApiWorldGenerationStep worldGenStep = inputFullDataSource.getWorldGenStepAtRelativePos(x, z);
 						if (dataColumn != null && worldGenStep != EDhApiWorldGenerationStep.EMPTY)
 						{
-							FullDataToRenderDataTransformer.convertColumnData(
+							FullDataToRenderDataTransformer.updateOrReplaceRenderDataViewColumnWithFullDataColumn(
 									level, inputFullDataSource.mapping,
 									minBlockPos.x + x,
 									minBlockPos.z + z,
@@ -288,7 +288,7 @@ public class ColumnRenderSource implements IDataSource<IDhClientLevel>
 		String SUBDATA_DELIMITER = ",";
 		StringBuilder stringBuilder = new StringBuilder();
 		
-		stringBuilder.append(this.pos);
+		stringBuilder.append(DhSectionPos.toString(this.pos));
 		stringBuilder.append(LINE_DELIMITER);
 		
 		int size = 1;

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/render/bufferBuilding/BufferQuad.java

@@ -67,9 +67,13 @@ public final class BufferQuad
 			EDhDirection direction)
 	{
 		if (widthEastWest == 0 || widthNorthSouthOrUpDown == 0)
+		{
 			throw new IllegalArgumentException("Size 0 quad!");
+		}
 		if (widthEastWest < 0 || widthNorthSouthOrUpDown < 0)
+		{
 			throw new IllegalArgumentException("Negative sized quad!");
+		}
 		
 		this.x = x;
 		this.y = y;
@@ -95,7 +99,9 @@ public final class BufferQuad
 	public int compare(BufferQuad quad, BufferMergeDirectionEnum compareDirection)
 	{
 		if (this.direction != quad.direction)
+		{
 			throw new IllegalArgumentException("The other quad is not in the same direction: " + quad.direction + " vs " + this.direction);
+		}
 		
 		if (compareDirection == BufferMergeDirectionEnum.EastWest)
 		{
@@ -150,11 +156,15 @@ public final class BufferQuad
 	public boolean tryMerge(BufferQuad quad, BufferMergeDirectionEnum mergeDirection)
 	{
 		if (quad.hasError || this.hasError)
+		{
 			return false;
+		}
 		
 		// only merge quads that are in the same direction
 		if (this.direction != quad.direction)
+		{
 			return false;
+		}
 		
 		// make sure these quads share the same perpendicular axis
 		if ((mergeDirection == BufferMergeDirectionEnum.EastWest && this.y != quad.y) ||

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/render/bufferBuilding/ColumnBox.java

@@ -19,29 +19,60 @@
 
 package com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding;
 
-import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
+import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
+import com.seibel.distanthorizons.core.level.IDhClientLevel;
 import com.seibel.distanthorizons.core.util.ColorUtil;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.RenderDataPointUtil;
-import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnArrayView;
 import com.seibel.distanthorizons.core.render.renderer.LodRenderer;
 import com.seibel.distanthorizons.coreapi.util.MathUtil;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
 
 public class ColumnBox
 {
 	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	
+	/** 
+	 * if the skylight has this value that means 
+	 * no data is expected 
+	 */
+	private static final byte SKYLIGHT_EMPTY = -1;
+	/** 
+	 * if the skylight has this value that means
+	 * that block position is covered/occuled by an adjacent block/column.
+	 */
+	private static final byte SKYLIGHT_COVERED = -2;
+	
+	private static final ThreadLocal<byte[]> THREAD_LOCAL_SKY_LIGHT_ARRAY = ThreadLocal.withInitial(() ->
+	{
+		byte[] array = new byte[RenderDataPointUtil.MAX_WORLD_Y_SIZE];
+		Arrays.fill(array, SKYLIGHT_EMPTY);
+		return array;
+	});
+	
+	
+	
+	//=========//
+	// builder //
+	//=========//
+	
 	public static void addBoxQuadsToBuilder(
-			LodQuadBuilder builder,
+			LodQuadBuilder builder, IDhClientLevel clientLevel,
 			short xSize, short ySize, short zSize,
 			short x, short minY, short z,
 			int color, byte irisBlockMaterialId, byte skyLight, byte blockLight,
-			long topData, long bottomData, ColumnArrayView[][] adjData)
+			long topData, long bottomData, ColumnArrayView[] adjData, boolean[] isAdjDataSameDetailLevel)
 	{
+		//================//
+		// variable setup //
+		//================//
+		
 		short maxX = (short) (x + xSize);
 		short maxY = (short) (minY + ySize);
 		short maxZ = (short) (z + zSize);
@@ -53,33 +84,24 @@ public class ColumnBox
 		boolean isTopTransparent = RenderDataPointUtil.getAlpha(topData) < 255 && LodRenderer.transparencyEnabled;
 		boolean isBottomTransparent = RenderDataPointUtil.getAlpha(bottomData) < 255 && LodRenderer.transparencyEnabled;
 		
+		// defaulting to a value far below what we can normally render means we
+		// don't need to have an additional "is cave culling enabled" check
+		int caveCullingMaxY = Integer.MIN_VALUE;
+		if (Config.Client.Advanced.Graphics.AdvancedGraphics.enableCaveCulling.get())
+		{
+			caveCullingMaxY = Config.Client.Advanced.Graphics.AdvancedGraphics.caveCullingHeight.get() - clientLevel.getMinY();
+		}
+		
+		
+		
 		// if there isn't any data below this LOD, make this LOD's color opaque to prevent seeing void through transparent blocks
 		// Note: this LOD should still be considered transparent for this method's checks, otherwise rendering bugs may occur
-		// FIXME this transparency change should be applied before this point since this could affect other areas
-		//  This may also be better than handling the LOD as transparent, but that is TBD
 		if (!RenderDataPointUtil.doesDataPointExist(bottomData))
 		{
 			color = ColorUtil.setAlpha(color, 255);
 		}
 		
 		
-		// cave culling prevention
-		// prevents certain faces from being culled underground that should be allowed
-		if (builder.skipQuadsWithZeroSkylight
-			&& 0 == skyLight
-			&& builder.skyLightCullingBelow > maxY
-			&& (
-					(RenderDataPointUtil.getAlpha(topData) < 255 && RenderDataPointUtil.getYMax(topData) >= builder.skyLightCullingBelow)
-					|| (RenderDataPointUtil.getYMin(topData) >= builder.skyLightCullingBelow)
-					|| !RenderDataPointUtil.doesDataPointExist(topData)
-				)
-			)
-		{
-			maxY = builder.skyLightCullingBelow;
-		}
-		
-		
-		
 		// fake ocean transparency
 		if (LodRenderer.transparencyEnabled && LodRenderer.fakeOceanFloor)
 		{
@@ -99,7 +121,9 @@ public class ColumnBox
 		
 		
 		
-		// add top and bottom faces if requested //
+		//==========================//
+		// add top and bottom faces //
+		//==========================//
 		
 		boolean skipTop = RenderDataPointUtil.doesDataPointExist(topData) && (RenderDataPointUtil.getYMin(topData) == maxY) && !isTopTransparent;
 		if (!skipTop)
@@ -114,409 +138,291 @@ public class ColumnBox
 		}
 		
 		
-		// add North, south, east, and west faces if requested //
 		
-		// TODO merge duplicate code
-		//NORTH face vertex creation
+		//========================================//
+		// add North, south, east, and west faces //
+		//========================================//
+		
+		// NORTH face
 		{
-			ColumnArrayView[] adjDataNorth = adjData[EDhDirection.NORTH.ordinal() - 2]; // TODO can we use something other than ordinal-2?
-			int adjOverlapNorth = ColorUtil.INVISIBLE;
-			if (adjDataNorth == null)
+			ColumnArrayView adjCol = adjData[EDhDirection.NORTH.ordinal() - 2]; // TODO can we use something other than ordinal-2?
+			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.NORTH.ordinal() - 2];
+			// if the adjacent column is null that generally means the adjacent area hasn't been generated yet
+			if (adjCol == null)
 			{
-				// add an adjacent face if this is opaque face or transparent over the void
+				// Add an adjacent face if this is opaque face or transparent over the void.
 				if (!isTransparent || overVoid)
 				{
 					builder.addQuadAdj(EDhDirection.NORTH, x, minY, z, xSize, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
 				}
 			}
-			else if (adjDataNorth.length == 1)
-			{
-				makeAdjVerticalQuad(builder, adjDataNorth[0], EDhDirection.NORTH, x, minY, z, xSize, ySize,
-						color, adjOverlapNorth, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
-			}
 			else
 			{
-				makeAdjVerticalQuad(builder, adjDataNorth[0], EDhDirection.NORTH, x, minY, z, (short) (xSize / 2), ySize,
-						color, adjOverlapNorth, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
-				makeAdjVerticalQuad(builder, adjDataNorth[1], EDhDirection.NORTH, (short) (x + xSize / 2), minY, z, (short) (xSize / 2), ySize,
-						color, adjOverlapNorth, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
+				makeAdjVerticalQuad(builder, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.NORTH, x, minY, z, xSize, ySize,
+						color, irisBlockMaterialId, blockLight);
 			}
 		}
 		
-		//SOUTH face vertex creation
+		// SOUTH face
 		{
-			ColumnArrayView[] adjDataSouth = adjData[EDhDirection.SOUTH.ordinal() - 2];
-			int adjOverlapSouth = ColorUtil.INVISIBLE;
-			if (adjDataSouth == null)
+			ColumnArrayView adjCol = adjData[EDhDirection.SOUTH.ordinal() - 2];
+			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.SOUTH.ordinal() - 2];
+			if (adjCol == null)
 			{
 				if (!isTransparent || overVoid)
+				{
 					builder.addQuadAdj(EDhDirection.SOUTH, x, minY, maxZ, xSize, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
-			}
-			else if (adjDataSouth.length == 1)
-			{
-				makeAdjVerticalQuad(builder, adjDataSouth[0], EDhDirection.SOUTH, x, minY, maxZ, xSize, ySize,
-						color, adjOverlapSouth, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
+				}
 			}
 			else
 			{
-				makeAdjVerticalQuad(builder, adjDataSouth[0], EDhDirection.SOUTH, x, minY, maxZ, (short) (xSize / 2), ySize,
-						color, adjOverlapSouth, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
-				
-				makeAdjVerticalQuad(builder, adjDataSouth[1], EDhDirection.SOUTH, (short) (x + xSize / 2), minY, maxZ, (short) (xSize / 2), ySize,
-						color, adjOverlapSouth, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
+				makeAdjVerticalQuad(builder, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.SOUTH, x, minY, maxZ, xSize, ySize,
+						color, irisBlockMaterialId, blockLight);
 			}
 		}
 		
-		//WEST face vertex creation
+		// WEST face
 		{
-			ColumnArrayView[] adjDataWest = adjData[EDhDirection.WEST.ordinal() - 2];
-			int adjOverlapWest = ColorUtil.INVISIBLE;
-			if (adjDataWest == null)
+			ColumnArrayView adjCol = adjData[EDhDirection.WEST.ordinal() - 2];
+			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.WEST.ordinal() - 2];
+			if (adjCol == null)
 			{
 				if (!isTransparent || overVoid)
+				{
 					builder.addQuadAdj(EDhDirection.WEST, x, minY, z, zSize, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
-			}
-			else if (adjDataWest.length == 1)
-			{
-				makeAdjVerticalQuad(builder, adjDataWest[0], EDhDirection.WEST, x, minY, z, zSize, ySize,
-						color, adjOverlapWest, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
+				}
 			}
 			else
 			{
-				makeAdjVerticalQuad(builder, adjDataWest[0], EDhDirection.WEST, x, minY, z, (short) (zSize / 2), ySize,
-						color, adjOverlapWest, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
-				makeAdjVerticalQuad(builder, adjDataWest[1], EDhDirection.WEST, x, minY, (short) (z + zSize / 2), (short) (zSize / 2), ySize,
-						color, adjOverlapWest, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
+				makeAdjVerticalQuad(builder, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.WEST, x, minY, z, zSize, ySize,
+						color, irisBlockMaterialId, blockLight);
 			}
 		}
 		
-		//EAST face vertex creation
+		// EAST face
 		{
-			ColumnArrayView[] adjDataEast = adjData[EDhDirection.EAST.ordinal() - 2];
-			int adjOverlapEast = ColorUtil.INVISIBLE;
-			if (adjData[EDhDirection.EAST.ordinal() - 2] == null)
+			ColumnArrayView adjCol = adjData[EDhDirection.EAST.ordinal() - 2];
+			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.EAST.ordinal() - 2];
+			if (adjCol == null)
 			{
 				if (!isTransparent || overVoid)
+				{
 					builder.addQuadAdj(EDhDirection.EAST, maxX, minY, z, zSize, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
-			}
-			else if (adjDataEast.length == 1)
-			{
-				makeAdjVerticalQuad(builder, adjDataEast[0], EDhDirection.EAST, maxX, minY, z, zSize, ySize,
-						color, adjOverlapEast, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
+				}
 			}
 			else
 			{
-				makeAdjVerticalQuad(builder, adjDataEast[0], EDhDirection.EAST, maxX, minY, z, (short) (zSize / 2), ySize,
-						color, adjOverlapEast, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
-				makeAdjVerticalQuad(builder, adjDataEast[1], EDhDirection.EAST, maxX, minY, (short) (z + zSize / 2), (short) (zSize / 2), ySize,
-						color, adjOverlapEast, irisBlockMaterialId, skyLightTop, blockLight,
-						topData, bottomData);
+				makeAdjVerticalQuad(builder, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.EAST, maxX, minY, z, zSize, ySize,
+						color, irisBlockMaterialId, blockLight);
 			}
 		}
 	}
 	
-	// the overlap color can be used to see faces that shouldn't be rendered
 	private static void makeAdjVerticalQuad(
-			LodQuadBuilder builder, ColumnArrayView adjColumnView, EDhDirection direction,
+			LodQuadBuilder builder, @NotNull ColumnArrayView adjColumnView, boolean adjacentIsSameDetailLevel, int caveCullingMaxY, EDhDirection direction, 
 			short x, short yMin, short z, short horizontalWidth, short ySize,
-			int color, int debugOverlapColor, byte irisBlockMaterialId, byte skyLightTop, byte blockLight,
-			long topData, long bottomData)
+			int color, byte irisBlockMaterialId, byte blockLight)
 	{
+		//==================//
+		// create face with //
+		// no adjacent data //
+		//==================//
+		
 		color = ColorUtil.applyShade(color, MC.getShade(direction));
 		
-		if (adjColumnView == null || adjColumnView.size == 0 || RenderDataPointUtil.isVoid(adjColumnView.get(0)))
+		// if there isn't any data adjacent to this LOD,
+		// just add the full vertical quad
+		if (adjColumnView.size == 0 || RenderDataPointUtil.isVoid(adjColumnView.get(0)))
 		{
-			// there isn't any data adjacent to this LOD, add the vertical quad
+			
 			builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
 			return;
 		}
 		
 		
-		int yMax = yMin + ySize;
 		
-		int adjIndex;
-		boolean firstFace = true;
-		boolean inputAboveAdjLods = true;
-		short previousAdjDepth = -1;
-		byte nextTopSkyLight = skyLightTop;
-		boolean inputTransparent = ColorUtil.getAlpha(color) < 255 && LodRenderer.transparencyEnabled;
-		boolean lastAdjWasTransparent = false;
+		//===========================//
+		// Determine face visibility //
+		// based on it's neighbors   //
+		//===========================//
 		
+		short yMax = (short) (yMin + ySize); // min is inclusive, max is exclusive
+		byte[] skyLightAtInputPos = THREAD_LOCAL_SKY_LIGHT_ARRAY.get();
 		
-		
-		if (!RenderDataPointUtil.doesDataPointExist(bottomData))
+		try
 		{
-			// there isn't anything under this LOD,
-			// to prevent seeing through the world, make it opaque
-			color = ColorUtil.setAlpha(color, 255);
-		}
-		
-		
-		// Add adjacent faces if this LOD is surrounded by transparent LODs
-		// (prevents invisible sides underwater)
-		int adjCount = adjColumnView.size();
-		for (adjIndex = 0; // iterates top down
-				adjIndex < adjCount
-						&& RenderDataPointUtil.doesDataPointExist(adjColumnView.get(adjIndex))
-						&& !RenderDataPointUtil.isVoid(adjColumnView.get(adjIndex));
-				adjIndex++)
-		{
-			long adjPoint = adjColumnView.get(adjIndex);
+			// set the initial sky-lights for this face,
+			// if nothing overlaps or overhangs the face should have max sky light
+			Arrays.fill(skyLightAtInputPos, yMin, yMax, LodUtil.MAX_MC_LIGHT);
 			
-			// if the adjacent data point is over the void
-			// don't consider it as transparent
-			// FIXME this transparency change should be applied before this point since this could affect other areas
-			boolean adjOverVoid = false;
-			if (adjIndex > 0)
+			// iterate top down
+			int adjCount = adjColumnView.size();
+			for (int adjIndex = 0; adjIndex < adjCount; adjIndex++)
 			{
-				long adjBellowPoint = adjColumnView.get(adjIndex-1);
-				adjOverVoid = !RenderDataPointUtil.doesDataPointExist(adjBellowPoint);	
-			}
-			boolean adjTransparent = !adjOverVoid && RenderDataPointUtil.getAlpha(adjPoint) < 255 && LodRenderer.transparencyEnabled;
-			
-			
-			// continue if this data point is transparent or the adjacent point is not 
-			if (inputTransparent || !adjTransparent) // TODO inputIsTransparent may be unnecessary
-			{
-				short adjYMin = RenderDataPointUtil.getYMin(adjPoint);
-				short adjYMax = RenderDataPointUtil.getYMax(adjPoint);
+				long adjPoint = adjColumnView.get(adjIndex);
+				short adjMinY = RenderDataPointUtil.getYMin(adjPoint);
+				short adjMaxY = RenderDataPointUtil.getYMax(adjPoint);
 				
-				
-				// if fake transparency is enabled, allow for 1 block of transparency,
-				// everything under that should be opaque
-				if (LodRenderer.transparencyEnabled && LodRenderer.fakeOceanFloor)
+				// skip empty adjacent datapoints
+				if (!RenderDataPointUtil.doesDataPointExist(adjPoint)
+						|| RenderDataPointUtil.isVoid(adjPoint))
 				{
-					if (lastAdjWasTransparent && !adjTransparent)
-					{
-						adjYMax = (short) (RenderDataPointUtil.getYMax(adjColumnView.get(adjIndex - 1)) - 1);
-					}
-					else if (adjTransparent && (adjIndex + 1) < adjCount)
-					{
-						if (RenderDataPointUtil.getAlpha(adjColumnView.get(adjIndex + 1)) == 255)
-						{
-							adjYMin = (short) (adjYMax - 1);
-						}
-					}
-				}
-				
-				
-				if (yMax <= adjYMin)
-				{
-					// the adjacent LOD is above the input LOD and won't affect its rendering,
-					// skip to the next adjacent
 					continue;
 				}
-				inputAboveAdjLods = false;
 				
-				
-				if (adjYMax < yMin)
+				// skip this adjacent datapoint if it's above the input datapoint (since it can't affect the input data point)
+				if (yMax <= adjMinY)
 				{
-					// the adjacent LOD is below the input LOD
-					
-					// getting the skylight is more complicated
-					// since LODs can be adjacent to water, which changes how skylight works
-					byte skyLight;
-					if (adjIndex == 0)
-					{
-						// this adj LOD is at the highest position,
-						// its sky lighting won't be affected by anything above it
-						skyLight = RenderDataPointUtil.getLightSky(adjPoint);
-					}
-					else
-					{
-						// TODO improve the comments here, this is a bit confusing
-						long aboveAdjPoint = adjColumnView.get(adjIndex - 1);
-						if (RenderDataPointUtil.getAlpha(aboveAdjPoint) != 255)
-						{
-							// above adjacent LOD is transparent...
-							
-							boolean inputMaxHigherThanAboveAdj = yMax > RenderDataPointUtil.getYMax(aboveAdjPoint);
-							if (inputMaxHigherThanAboveAdj)
-							{
-								// ...and higher than the input yMax,
-								// use its sky light
-								skyLight = RenderDataPointUtil.getLightSky(aboveAdjPoint);
-							}
-							else
-							{
-								// ...and at or below the input yMax,
-								skyLight = RenderDataPointUtil.getLightSky(adjPoint);
-							}
-						}
-						else
-						{
-							// LOD above adjacent is opaque, use the adj LOD's skylight
-							skyLight = RenderDataPointUtil.getLightSky(adjPoint);
-						}
-					}
-					
-					
-					if (firstFace)
-					{
-						builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, ySize, color, irisBlockMaterialId, skyLight, blockLight);
-					}
-					else
-					{
-						// Now: adjMaxHeight < y < previousAdjDepth < yMax
-						if (previousAdjDepth == -1)
-						{
-							// TODO why is this an error?
-							throw new RuntimeException("Loop error");
-						}
-						
-						builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, (short) (previousAdjDepth - yMin), color, irisBlockMaterialId, skyLight, blockLight);
-						
-						previousAdjDepth = -1;
-					}
-					
-					
-					// TODO why break here?
-					break;
+					continue;
 				}
 				
 				
-				if (adjYMin <= yMin)
+				long adjAbovePoint = (adjIndex != 0) ? adjColumnView.get(adjIndex - 1) : RenderDataPointUtil.EMPTY_DATA;
+				long adjBelowPoint = (adjIndex + 1 < adjCount) ? adjColumnView.get(adjIndex + 1) : RenderDataPointUtil.EMPTY_DATA;
+				
+				// if the adjacent data point is over the void
+				// don't consider it as transparent
+				boolean adjOverVoid = !RenderDataPointUtil.doesDataPointExist(adjBelowPoint);
+				boolean adjTransparent = !adjOverVoid && RenderDataPointUtil.getAlpha(adjPoint) < 255 && LodRenderer.transparencyEnabled;
+				
+				
+				
+				//=================================//
+				// set sky light based on adjacent //
+				//=================================//
+				
+				// set light based on overlapping adjacent
+				if (!adjTransparent)
 				{
-					// the adjacent LOD's base is at or below the input's base
-					
-					if (yMax <= adjYMax)
+					// adj opaque
+					// mark positions adjacent is covering
+					byte adjSkyLight = RenderDataPointUtil.getLightSky(adjPoint);
+					for (int i = adjMinY; i < adjMaxY; i++)
 					{
-						// The input face is completely inside the adj's face, don't render it
-						if (debugOverlapColor != 0)
-						{
-							builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, ySize, debugOverlapColor, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, LodUtil.MAX_MC_LIGHT);
-						}
-					}
-					else
-					{
-						// the adj data intersects the lower part of the input data, don't render below the intersection
+						byte skyLightAtPos = skyLightAtInputPos[i];
 						
-						if (adjYMax > yMin && debugOverlapColor != 0)
-						{
-							builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, (short) (adjYMax - yMin), debugOverlapColor, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, LodUtil.MAX_MC_LIGHT);
-						}
+						// if the adjacent is a different detail level, we want to render adjacent opaque
+						// faces to try and reduce the chance of holes on detail level borders
+						boolean adjacentCoversThis = 
+								// if the adjacent is the same detail level, no special handling is necessary
+								!adjacentIsSameDetailLevel
+								// if the adjacent face is underground we probably don't need it
+								&& RenderDataPointUtil.getYMax(adjPoint) >= caveCullingMaxY
+								// check if this face is on a border
+								&& 
+								(
+									(x == 0 && direction == EDhDirection.WEST)
+									|| (z == 0 && direction == EDhDirection.NORTH)
+									// TODO why does 256 represent a border? aren't LODs only 64 datapoints wide?
+									|| (x == 256 && direction == EDhDirection.EAST)
+									|| (z == 256 && direction == EDhDirection.SOUTH)
+								);
 						
-						// if this is the only face, use the yMax and break,
-						// if there was another face finish the last one and then break
-						if (firstFace)
-						{
-							builder.addQuadAdj(direction, x, adjYMax, z, horizontalWidth, (short) (yMax - adjYMax), color, irisBlockMaterialId,
-									RenderDataPointUtil.getLightSky(adjPoint), blockLight);
-						}
-						else
-						{
-							// Now: depth <= y <= height <= previousAdjDepth < yMax
-							if (previousAdjDepth == -1)
-							{
-								// TODO why is this an error?
-								throw new RuntimeException("Loop error");
-							}
-							
-							if (previousAdjDepth > adjYMax)
-							{
-								builder.addQuadAdj(direction, x, adjYMax, z, horizontalWidth, (short) (previousAdjDepth - adjYMax), color, irisBlockMaterialId,
-										RenderDataPointUtil.getLightSky(adjPoint), blockLight);
-							}
-							previousAdjDepth = -1;
-						}
+						byte newSkyLightAtPos = adjacentCoversThis ? adjSkyLight : SKYLIGHT_COVERED;
+						skyLightAtInputPos[i] = (byte) Math.min(newSkyLightAtPos, skyLightAtPos);
 					}
-					
-					
-					// we don't need to check any other adjacent LODs 
-					// since this one completely covers the input
-					break;
-				}
-				
-				
-				
-				// In here always true: y < adjYMin < yMax
-				// _________________&&: y < ________ (height and yMax)
-				
-				if (adjYMax >= yMax)
-				{
-					// Basically: y _______ < yMax <= height
-					// _______&&: y < depth < yMax
-					// the adj data intersects the higher part of the current data
-					if (debugOverlapColor != 0)
-					{
-						builder.addQuadAdj(direction, x, adjYMin, z, horizontalWidth, (short) (yMax - adjYMin), debugOverlapColor, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, LodUtil.MAX_MC_LIGHT);
-					}
-					
-					// we start the creation of a new face
 				}
 				else
 				{
-					// Otherwise: y < _____ height < yMax
-					// _______&&: y < depth ______ < yMax
-					if (debugOverlapColor != 0)
+					// adjacent is transparent,
+					// use datapoint below adjacent for lighting
+					byte belowSkyLight = RenderDataPointUtil.getLightSky(adjBelowPoint);
+					for (int i = adjMinY; i < adjMaxY; i++)
 					{
-						builder.addQuadAdj(direction, x, adjYMin, z, horizontalWidth, (short) (adjYMax - adjYMin), debugOverlapColor, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, LodUtil.MAX_MC_LIGHT);
-					}
-					
-					if (firstFace)
-					{
-						builder.addQuadAdj(direction, x, adjYMax, z, horizontalWidth, (short) (yMax - adjYMax), color, irisBlockMaterialId,
-								RenderDataPointUtil.getLightSky(adjPoint), blockLight);
-					}
-					else
-					{
-						// Now: y < depth < height <= previousAdjDepth < yMax
-						if (previousAdjDepth == -1)
-							throw new RuntimeException("Loop error");
-						if (previousAdjDepth > adjYMax)
-						{
-							if (irisBlockMaterialId == EDhApiBlockMaterial.GRASS.index)
-							{
-								// this LOD is underneath another, grass will never show here
-								irisBlockMaterialId = EDhApiBlockMaterial.DIRT.index;
-							}
-							
-							builder.addQuadAdj(direction, x, adjYMax, z, horizontalWidth, (short) (previousAdjDepth - adjYMax), color, irisBlockMaterialId,
-									RenderDataPointUtil.getLightSky(adjPoint), blockLight);
-						}
-						previousAdjDepth = -1;
+						byte skyLightAtPos = skyLightAtInputPos[i];
+						skyLightAtInputPos[i] = (byte) Math.min(belowSkyLight, skyLightAtPos);
 					}
 				}
 				
 				
-				// set next top as current depth
-				previousAdjDepth = adjYMin;
-				firstFace = false;
-				nextTopSkyLight = skyLightTop;
-				
-				if (adjIndex + 1 < adjColumnView.size() && RenderDataPointUtil.doesDataPointExist(adjColumnView.get(adjIndex + 1)))
+				// fill in sky light up to the next DP,
+				// this is done to handle overhangs
+				byte adjSkyLight = RenderDataPointUtil.getLightSky(adjPoint);
+				int adjAboveMinY = RenderDataPointUtil.getYMin(adjAbovePoint);
+				for (int i = adjMaxY; i < adjAboveMinY; i++)
 				{
-					nextTopSkyLight = RenderDataPointUtil.getLightSky(adjColumnView.get(adjIndex + 1));
+					byte skyLightAtPos = skyLightAtInputPos[i];
+					skyLightAtInputPos[i] = (byte) Math.min(adjSkyLight, skyLightAtPos);
+				}
+			}
+			
+			
+			
+			//=======================//
+			// create vertical faces //
+			//=======================//
+			
+			boolean inputTransparent = ColorUtil.getAlpha(color) < 255 && LodRenderer.transparencyEnabled;
+			byte lastSkyLight = skyLightAtInputPos[yMin];
+			int quadBottomY = yMin;
+			int quadTopY = -1;
+			
+			// walk up the sky lights and create a new face
+			// whenever the light changes to different valid value
+			for (int i = yMin; i < yMax; i++)
+			{
+				byte skyLight = skyLightAtInputPos[i];
+				if (skyLight != lastSkyLight)
+				{
+					// the sky light changed, create the in-progress face
+					tryAddVerticalFaceWithSkyLightToBuilder(
+							builder, direction,
+							x, z, horizontalWidth,
+							color, irisBlockMaterialId, blockLight,
+							lastSkyLight, inputTransparent, quadTopY, quadBottomY
+					);
+					
+					lastSkyLight = skyLight;
+					quadBottomY = i;
 				}
 				
-				lastAdjWasTransparent = adjTransparent;
+				quadTopY = (i + 1);
+			}
+			
+			// add the in-progress face if present
+			if (quadTopY != -1)
+			{
+				tryAddVerticalFaceWithSkyLightToBuilder(
+						builder, direction,
+						x, z, horizontalWidth,
+						color, irisBlockMaterialId, blockLight,
+						lastSkyLight, inputTransparent, quadTopY, quadBottomY
+				);
 			}
 		}
-		
-		
-		
-		if (inputAboveAdjLods)
+		finally
 		{
-			// the input LOD is above all adjacent LODs and won't be affected
-			// by them, add the vertical quad using the input's lighting and height
-			builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, ySize, color, irisBlockMaterialId, skyLightTop, blockLight);
+			// clean up the array before the next thread uses it
+			// (may be unnecessary since we only work between the yMin-yMax anyway, but is helpful for debugging)
+			Arrays.fill(skyLightAtInputPos, yMin, yMax, SKYLIGHT_EMPTY);
 		}
-		else if (previousAdjDepth != -1)
+	}
+	private static void tryAddVerticalFaceWithSkyLightToBuilder(
+			LodQuadBuilder builder, EDhDirection direction,
+			short x, short z, short horizontalWidth,
+			int color, byte irisBlockMaterialId, byte blockLight,
+			byte lastSkyLight, boolean inputTransparent, int quadTopY, int quadBottomY
+			)
+	{
+		// invalid positions will have a negative skylight
+		if (lastSkyLight >= 0)
 		{
-			// We need to finish the last quad.
-			builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, (short) (previousAdjDepth - yMin), color, irisBlockMaterialId, nextTopSkyLight, blockLight);
+			// Don't add transparent vertical faces
+			// unless the adjacent position is empty.
+			// This is done to prevent walls between water blocks in the ocean.
+			if (!inputTransparent
+				|| (lastSkyLight == LodUtil.MAX_MC_LIGHT))
+			{
+				// don't add negative/empty height faces
+				short height = (short) (quadTopY - quadBottomY);
+				if (height > 0)
+				{
+					builder.addQuadAdj(direction, x, (short) quadBottomY, z, horizontalWidth, height, color, irisBlockMaterialId, lastSkyLight, blockLight);
+				}
+			}
 		}
 	}
 	
+	
+	
 }

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/render/bufferBuilding/ColumnRenderBuffer.java

@@ -19,23 +19,23 @@
 
 package com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding;
 
+import com.seibel.distanthorizons.api.DhApi;
 import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
-import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
 import com.seibel.distanthorizons.core.render.glObject.GLProxy;
 import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer;
 import com.seibel.distanthorizons.core.render.renderer.LodRenderer;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.objects.StatsMap;
 import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod;
-import com.seibel.distanthorizons.core.util.*;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import org.apache.logging.log4j.Logger;
+import org.lwjgl.system.MemoryUtil;
 
 import java.nio.ByteBuffer;
-import java.util.Iterator;
+import java.util.ArrayList;
 import java.util.concurrent.*;
 
 /**
@@ -53,7 +53,7 @@ public class ColumnRenderBuffer implements AutoCloseable
 	/** number of bytes a single quad takes */
 	public static final int QUADS_BYTE_SIZE = LodUtil.LOD_VERTEX_FORMAT.getByteSize() * 4;
 	/** how big a single VBO can be in bytes */
-	public static final int MAX_VBO_BYTE_SIZE = 1024 * 1024; // 1 MB
+	public static final int MAX_VBO_BYTE_SIZE = 10 * 1024 * 1024; // 10 MB
 	public static final int MAX_QUADS_PER_BUFFER = MAX_VBO_BYTE_SIZE / QUADS_BYTE_SIZE;
 	public static final int FULL_SIZED_BUFFER = MAX_QUADS_PER_BUFFER * QUADS_BYTE_SIZE;
 	
@@ -91,7 +91,7 @@ public class ColumnRenderBuffer implements AutoCloseable
 	/** Should be run on a DH thread. */
 	public void uploadBuffer(LodQuadBuilder builder, EDhApiGpuUploadMethod gpuUploadMethod) throws InterruptedException
 	{
-		LodUtil.assertTrue(Thread.currentThread().getName().startsWith(ThreadUtil.THREAD_NAME_PREFIX), "Buffer uploading needs to be done on a DH thread to prevent locking up any MC threads.");
+		LodUtil.assertTrue(DhApi.isDhThread(), "Buffer uploading needs to be done on a DH thread to prevent locking up any MC threads.");
 		
 		
 		// upload on MC's render thread
@@ -100,7 +100,7 @@ public class ColumnRenderBuffer implements AutoCloseable
 		{
 			try
 			{
-				this.uploadBuffersUsingUploadMethod(builder, gpuUploadMethod);
+				this.uploadBuffers(builder, gpuUploadMethod);
 				uploadFuture.complete(null);
 			}
 			catch (InterruptedException e)
@@ -126,72 +126,46 @@ public class ColumnRenderBuffer implements AutoCloseable
 			//LOGGER.warn("Error uploading builder ["+builder+"] synchronously. Error: "+e.getMessage(), e);
 		}
 	}
-	private void uploadBuffersUsingUploadMethod(LodQuadBuilder builder, EDhApiGpuUploadMethod gpuUploadMethod) throws InterruptedException
+	private void uploadBuffers(LodQuadBuilder builder, EDhApiGpuUploadMethod method) throws InterruptedException
 	{
-		if (gpuUploadMethod.useEarlyMapping)
-		{
-			this.uploadBuffersMapped(builder, gpuUploadMethod);
-		}
-		else
-		{
-			this.uploadBuffersDirect(builder, gpuUploadMethod);
-		}
+		// uploading mapped buffers used to be done here,
+		// however due to a memory leak and complication with the previous code,
+		// now we only allow direct uploading.
+		// (There's also insufficient data to state whether mapped buffers are necessary
+		// for DH to upload without stuttering the main thread)
+		
+		this.vbos = makeAndUploadBuffers(builder, method, this.vbos, builder.makeOpaqueVertexBuffers());
+		this.vbosTransparent = makeAndUploadBuffers(builder, method, this.vbosTransparent, builder.makeTransparentVertexBuffers());
 		
 		this.buffersUploaded = true;
 	}
-	
-	
-	
-	private void uploadBuffersMapped(LodQuadBuilder builder, EDhApiGpuUploadMethod method)
+	/** This resizes and returns the vbo array if necessary based on the amount of data needed for this area. */
+	private static GLVertexBuffer[] makeAndUploadBuffers(LodQuadBuilder builder, EDhApiGpuUploadMethod method, GLVertexBuffer[] vbos, ArrayList<ByteBuffer> buffers) throws InterruptedException
 	{
-		// opaque vbos //
-		
-		this.vbos = ColumnRenderBufferBuilder.resizeBuffer(this.vbos, builder.getCurrentNeededOpaqueVertexBufferCount());
-		for (int i = 0; i < this.vbos.length; i++)
+		try
 		{
-			if (this.vbos[i] == null)
+			vbos = resizeBuffer(vbos, buffers.size());
+			uploadBuffersDirect(vbos, buffers, method);
+		}
+		finally
+		{
+			// all the buffers must be manually freed to prevent memory leaks
+			if (buffers != null)
 			{
-				this.vbos[i] = new GLVertexBuffer(method.useBufferStorage);
+				for (ByteBuffer buffer : buffers)
+				{
+					MemoryUtil.memFree(buffer);
+				}
 			}
 		}
-		LodQuadBuilder.BufferFiller func = builder.makeOpaqueBufferFiller(method);
-		for (GLVertexBuffer vbo : this.vbos)
-		{
-			func.fill(vbo);
-		}
 		
-		
-		// transparent vbos //
-		
-		this.vbosTransparent = ColumnRenderBufferBuilder.resizeBuffer(this.vbosTransparent, builder.getCurrentNeededTransparentVertexBufferCount());
-		for (int i = 0; i < this.vbosTransparent.length; i++)
-		{
-			if (this.vbosTransparent[i] == null)
-			{
-				this.vbosTransparent[i] = new GLVertexBuffer(method.useBufferStorage);
-			}
-		}
-		LodQuadBuilder.BufferFiller transparentFillerFunc = builder.makeTransparentBufferFiller(method);
-		for (GLVertexBuffer vbo : this.vbosTransparent)
-		{
-			transparentFillerFunc.fill(vbo);
-		}
+		// return the array in case it was resized
+		return vbos;
 	}
-	
-	private void uploadBuffersDirect(LodQuadBuilder builder, EDhApiGpuUploadMethod method) throws InterruptedException
+	private static void uploadBuffersDirect(GLVertexBuffer[] vbos, ArrayList<ByteBuffer> byteBuffers, EDhApiGpuUploadMethod method) throws InterruptedException
 	{
-		this.vbos = ColumnRenderBufferBuilder.resizeBuffer(this.vbos, builder.getCurrentNeededOpaqueVertexBufferCount());
-		uploadBuffersDirect(this.vbos, builder.makeOpaqueVertexBuffers(), method);
-		
-		this.vbosTransparent = ColumnRenderBufferBuilder.resizeBuffer(this.vbosTransparent, builder.getCurrentNeededTransparentVertexBufferCount());
-		uploadBuffersDirect(this.vbosTransparent, builder.makeTransparentVertexBuffers(), method);
-	}
-	private static void uploadBuffersDirect(GLVertexBuffer[] vbos, Iterator<ByteBuffer> iter, EDhApiGpuUploadMethod method) throws InterruptedException
-	{
-		long remainingMS = 0;
-		long MBPerMS = Config.Client.Advanced.GpuBuffers.gpuUploadPerMegabyteInMilliseconds.get();
 		int vboIndex = 0;
-		while (iter.hasNext())
+		for (int i = 0; i < byteBuffers.size(); i++)
 		{
 			if (vboIndex >= vbos.length)
 			{
@@ -207,13 +181,13 @@ public class ColumnRenderBuffer implements AutoCloseable
 			GLVertexBuffer vbo = vbos[vboIndex];
 			
 			
-			ByteBuffer bb = iter.next();
-			int size = bb.limit() - bb.position();
+			ByteBuffer buffer = byteBuffers.get(i);
+			int size = buffer.limit() - buffer.position();
 			
 			try
 			{
 				vbo.bind();
-				vbo.uploadBuffer(bb, size / LodUtil.LOD_VERTEX_FORMAT.getByteSize(), method, FULL_SIZED_BUFFER);
+				vbo.uploadBuffer(buffer, size / LodUtil.LOD_VERTEX_FORMAT.getByteSize(), method, FULL_SIZED_BUFFER);
 			}
 			catch (Exception e)
 			{
@@ -222,24 +196,6 @@ public class ColumnRenderBuffer implements AutoCloseable
 				LOGGER.error("Failed to upload buffer: ", e);
 			}
 			
-			
-			if (MBPerMS > 0)
-			{
-				// upload buffers over an extended period of time
-				// to hopefully prevent stuttering.
-				remainingMS += size * MBPerMS;
-				if (remainingMS >= TimeUnit.NANOSECONDS.convert(1000 / 60, TimeUnit.MILLISECONDS))
-				{
-					if (remainingMS > MAX_BUFFER_UPLOAD_TIMEOUT_NANOSECONDS)
-					{
-						remainingMS = MAX_BUFFER_UPLOAD_TIMEOUT_NANOSECONDS;
-					}
-					
-					Thread.sleep(remainingMS / 1000000, (int) (remainingMS % 1000000));
-					remainingMS = 0;
-				}
-			}
-			
 			vboIndex++;
 		}
 		
@@ -318,9 +274,9 @@ public class ColumnRenderBuffer implements AutoCloseable
 	
 	
 	
-	//==============//
-	// misc methods //
-	//==============//
+	//================//
+	// helper methods //
+	//================//
 	
 	/** can be used when debugging */
 	public boolean hasNonNullVbos() { return this.vbos != null || this.vbosTransparent != null; }
@@ -366,6 +322,35 @@ public class ColumnRenderBuffer implements AutoCloseable
 		}
 	}
 	
+	public static GLVertexBuffer[] resizeBuffer(GLVertexBuffer[] vbos, int newSize)
+	{
+		if (vbos.length == newSize)
+		{
+			return vbos;
+		}
+		
+		GLVertexBuffer[] newVbos = new GLVertexBuffer[newSize];
+		System.arraycopy(vbos, 0, newVbos, 0, Math.min(vbos.length, newSize));
+		if (newSize < vbos.length)
+		{
+			for (int i = newSize; i < vbos.length; i++)
+			{
+				if (vbos[i] != null)
+				{
+					vbos[i].close();
+				}
+			}
+		}
+		return newVbos;
+	}
+	
+	
+	
+	
+	//================//
+	// base overrides //
+	//================//
+	
 	/**
 	 * This method is called when object is no longer in use.
 	 * Called either after uploadBuffers() returned false (On buffer Upload

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/render/bufferBuilding/ColumnRenderBufferBuilder.java

@@ -19,6 +19,7 @@
 
 package com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding;
 
+import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiDebugRendering;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.config.Config;
@@ -26,15 +27,16 @@ import com.seibel.distanthorizons.core.dataObjects.render.ColumnRenderSource;
 import com.seibel.distanthorizons.core.level.IDhClientLevel;
 import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.glObject.GLProxy;
-import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer;
+import com.seibel.distanthorizons.core.util.ColorUtil;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.RenderDataPointUtil;
 import com.seibel.distanthorizons.core.util.objects.UncheckedInterruptedException;
 import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnArrayView;
 import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
+import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -59,21 +61,21 @@ public class ColumnRenderBufferBuilder
 	// vbo building //
 	//==============//
 	
-	public static CompletableFuture<ColumnRenderBuffer> buildAndUploadBuffersAsync(
+	public static CompletableFuture<LodQuadBuilder> buildBuffersAsync(
 			IDhClientLevel clientLevel,
-			ColumnRenderSource renderSource, ColumnRenderSource[] adjData)
+			ColumnRenderSource renderSource, ColumnRenderSource[] adjData, boolean[] isSameDetailLevel
+		)
 	{
 		ThreadPoolExecutor bufferBuilderExecutor = ThreadPoolUtil.getBufferBuilderExecutor();
-		ThreadPoolExecutor bufferUploaderExecutor = ThreadPoolUtil.getBufferUploaderExecutor();
-		if ((bufferBuilderExecutor == null || bufferBuilderExecutor.isTerminated()) ||
-			(bufferUploaderExecutor == null || bufferUploaderExecutor.isTerminated()))
+		if (bufferBuilderExecutor == null || bufferBuilderExecutor.isTerminated())
 		{
 			// one or more of the thread pools has been shut down
-			CompletableFuture<ColumnRenderBuffer> future = new CompletableFuture<>();
+			CompletableFuture<LodQuadBuilder> future = new CompletableFuture<>();
 			future.cancel(true);
 			return future;
 		}
 		
+		
 		try
 		{
 			return CompletableFuture.supplyAsync(() ->
@@ -81,35 +83,8 @@ public class ColumnRenderBufferBuilder
 					try
 					{
 						boolean enableTransparency = Config.Client.Advanced.Graphics.Quality.transparency.get().transparencyEnabled;
-						
-						//EVENT_LOGGER.trace("RenderRegion start QuadBuild @ " + renderSource.sectionPos);
-						boolean enableSkyLightCulling =
-								Config.Client.Advanced.Graphics.AdvancedGraphics.enableCaveCulling.get()
-								&& (
-									// dimensions with a ceiling will be all caves so we don't want cave culling
-									!clientLevel.getLevelWrapper().hasCeiling()
-									// the end has a lot of overhangs with 0 lighting above the void, which look broken with
-									// the current cave culling logic (this could probably be improved, but just skipping it works best for now)
-									&& !clientLevel.getLevelWrapper().getDimensionType().isTheEnd()
-									// FIXME temporary fix
-									//  Cave culling is currently broken for any detail level above 0
-									&& DhSectionPos.getDetailLevel(renderSource.pos) == DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL
-								);
-						
-						int skyLightCullingBelow = Config.Client.Advanced.Graphics.AdvancedGraphics.caveCullingHeight.get();
-						// FIXME: Clamp also to the max world height.
-						skyLightCullingBelow = Math.max(skyLightCullingBelow, clientLevel.getMinY());
-						
-						
-						long builderStartTime = System.currentTimeMillis();
-						
-						LodQuadBuilder builder = new LodQuadBuilder(enableSkyLightCulling, (short) (skyLightCullingBelow - clientLevel.getMinY()), enableTransparency, clientLevel.getClientLevelWrapper());
-						makeLodRenderData(builder, renderSource, adjData);
-						
-						long builderEndTime = System.currentTimeMillis();
-						long buildMs = builderEndTime - builderStartTime;
-						LOGGER.debug("RenderRegion end QuadBuild @ " + renderSource.pos + " took: " + buildMs);
-						
+						LodQuadBuilder builder = new LodQuadBuilder(enableTransparency, clientLevel.getClientLevelWrapper());
+						makeLodRenderData(builder, renderSource, clientLevel, adjData, isSameDetailLevel);
 						return builder;
 					}
 					catch (UncheckedInterruptedException e)
@@ -118,20 +93,58 @@ public class ColumnRenderBufferBuilder
 					}
 					catch (Throwable e3)
 					{
-						LOGGER.error("\"LodNodeBufferBuilder\" was unable to build quads: ", e3);
+						LOGGER.error("LodNodeBufferBuilder was unable to build quads for pos ["+DhSectionPos.toString(renderSource.pos)+"], error: ["+ e3.getMessage()+"].", e3);
 						throw e3;
 					}
-				}, bufferBuilderExecutor)
-				.thenApplyAsync((quadBuilder) ->
+				}, bufferBuilderExecutor);
+		}
+		catch (RejectedExecutionException ignore)
+		{
+			// the thread pool was probably shut down because it's size is being changed, just wait a sec and it should be back
+			
+			CompletableFuture<LodQuadBuilder> future = new CompletableFuture<>();
+			future.cancel(true);
+			return future;
+		}
+	}
+	
+	/** @link adjData should be null for adjacent sections that cross detail level boundaries */
+	public static CompletableFuture<ColumnRenderBuffer> uploadBuffersAsync(
+			IDhClientLevel clientLevel,
+			long pos,
+			LodQuadBuilder quadBuilder
+		)
+	{
+		// TODO put into a single future/thread so it can be easily canceled
+		ThreadPoolExecutor bufferUploaderExecutor = ThreadPoolUtil.getBufferUploaderExecutor();
+		if (bufferUploaderExecutor == null || bufferUploaderExecutor.isTerminated())
+		{
+			// one or more of the thread pools has been shut down
+			CompletableFuture<ColumnRenderBuffer> future = new CompletableFuture<>();
+			future.cancel(true);
+			return future;
+		}
+		
+		
+		try
+		{
+			return CompletableFuture.supplyAsync(() ->
 				{
 					try
 					{
-						ColumnRenderBuffer buffer = new ColumnRenderBuffer(new DhBlockPos(DhSectionPos.getMinCornerBlockX(renderSource.pos), clientLevel.getMinY(), DhSectionPos.getMinCornerBlockZ(renderSource.pos)));
+						ColumnRenderBuffer buffer = new ColumnRenderBuffer(new DhBlockPos(DhSectionPos.getMinCornerBlockX(pos), clientLevel.getMinY(), DhSectionPos.getMinCornerBlockZ(pos)));
 						try
 						{
 							buffer.uploadBuffer(quadBuilder, GLProxy.getInstance().getGpuUploadMethod());
-							LodUtil.assertTrue(buffer.buffersUploaded);
-							return buffer;
+							if (buffer.buffersUploaded)
+							{
+								return buffer;	
+							}
+							else
+							{
+								buffer.close();
+								return null;
+							}
 						}
 						catch (Exception e)
 						{
@@ -145,35 +158,38 @@ public class ColumnRenderBufferBuilder
 					}
 					catch (Throwable e3)
 					{
-						LOGGER.error("LodNodeBufferBuilder was unable to upload buffer: " + e3.getMessage(), e3);
+						LOGGER.error("LodNodeBufferBuilder was unable to upload buffer for pos ["+DhSectionPos.toString(pos)+"], error: [" + e3.getMessage() + "].", e3);
 						throw e3;
 					}
 				}, bufferUploaderExecutor);
 		}
 		catch (RejectedExecutionException ignore) 
 		{
-			// the thread pool was probably shut down because it's size is being changed, just wait a sec and it should be back
+			// shouldn't happen, but just in case
 			
 			CompletableFuture<ColumnRenderBuffer> future = new CompletableFuture<>();
 			future.cancel(true);
 			return future;
 		}
 	}
-	private static void makeLodRenderData(LodQuadBuilder quadBuilder, ColumnRenderSource renderSource, ColumnRenderSource[] adjRegions)
+	private static void makeLodRenderData(
+			LodQuadBuilder quadBuilder, ColumnRenderSource renderSource, IDhClientLevel clientLevel,
+			ColumnRenderSource[] adjRegions, boolean[] isSameDetailLevel)
 	{
-		// Variable initialization
-		EDhApiDebugRendering debugMode = Config.Client.Advanced.Debugging.debugRendering.get();
+		//=============//
+		// debug check //
+		//=============//
 		
 		// can be used to limit which section positions are build and thus, rendered
 		// useful when debugging a specific section
-		boolean enableColumnBufferLimit = Config.Client.Advanced.Debugging.columnBuilderDebugEnable.get();
-		if (enableColumnBufferLimit)
+		boolean columnBuilderDebugEnabled = Config.Client.Advanced.Debugging.columnBuilderDebugEnable.get();
+		if (columnBuilderDebugEnabled)
 		{
 			if (DhSectionPos.getDetailLevel(renderSource.pos) == Config.Client.Advanced.Debugging.columnBuilderDebugDetailLevel.get()
 				&& DhSectionPos.getX(renderSource.pos) == Config.Client.Advanced.Debugging.columnBuilderDebugXPos.get()
 				&& DhSectionPos.getZ(renderSource.pos) == Config.Client.Advanced.Debugging.columnBuilderDebugZPos.get())
 			{
-				int test = 0;
+				int breakpoint = 0;
 			}
 			else
 			{
@@ -181,24 +197,22 @@ public class ColumnRenderBufferBuilder
 			}
 		}
 		
-		byte detailLevel = renderSource.getDataDetailLevel();
-		for (int x = 0; x < ColumnRenderSource.SECTION_SIZE; x++)
+		
+		
+		//===================//
+		// build each column //
+		//===================//
+		
+		byte thisDetailLevel = renderSource.getDataDetailLevel();
+		for (int relX = 0; relX < ColumnRenderSource.SECTION_SIZE; relX++)
 		{
-			for (int z = 0; z < ColumnRenderSource.SECTION_SIZE; z++)
+			for (int relZ = 0; relZ < ColumnRenderSource.SECTION_SIZE; relZ++)
 			{
-				// TODO make a config for this
-				// can be uncommented to limit the buffer building to a specific
-				// relative position in this section.
-				// useful for debugging a single column's rendering
-//				if (x != 0 || (z != 0 && z != 1))
-//				{
-//					continue;
-//				}
-				
-				
+				// stop the builder if requested
 				UncheckedInterruptedException.throwIfInterrupted();
 				
-				ColumnArrayView columnRenderData = renderSource.getVerticalDataPointView(x, z);
+				// ignore empty/null columns
+				ColumnArrayView columnRenderData = renderSource.getVerticalDataPointView(relX, relZ);
 				if (columnRenderData.size() == 0
 						|| !RenderDataPointUtil.doesDataPointExist(columnRenderData.get(0))
 						|| RenderDataPointUtil.isVoid(columnRenderData.get(0)))
@@ -206,43 +220,66 @@ public class ColumnRenderBufferBuilder
 					continue;
 				}
 				
-				ColumnRenderSource.DebugSourceFlag debugSourceFlag = renderSource.debugGetFlag(x, z);
-				
-				ColumnArrayView[][] adjColumnViews = new ColumnArrayView[4][];
-				// We extract the adj data in the four cardinal direction
-				
-				// we first reset the adjShadeDisabled. This is used to disable the shade on the
-				// border when we have transparent block like water or glass
-				// to avoid having a "darker border" underground
-				// Arrays.fill(adjShadeDisabled, false);
 				
 				
-				// We check every adj block in each direction
+				//=============//
+				// debug limit //
+				//=============//
 				
-				// If the adj block is rendered in the same region and with same detail
-				// and is positioned in a place that is not going to be rendered by vanilla game
-				// then we can set this position as adj
-				// We avoid cases where the adjPosition is in player chunk while the position is
-				// not
-				// to always have a wall underwater
+				// can be used to limit the buffer building to a specific relative position.
+				// useful for debugging a single column
+				if (columnBuilderDebugEnabled)
+				{
+					int wantedX = Config.Client.Advanced.Debugging.columnBuilderDebugXRow.get();
+					if (wantedX >= 0 && relX != wantedX)
+					{
+						continue;
+					}
+					int wantedZ = Config.Client.Advanced.Debugging.columnBuilderDebugZRow.get();
+					if (wantedZ >= 0 && relZ != wantedZ)
+					{
+						continue;
+					}
+				}
+				
+				
+				
+				//==================================//
+				// get adjacent render data columns //
+				//==================================//
+				
+				ColumnArrayView[] adjColumnViews = new ColumnArrayView[EDhDirection.ADJ_DIRECTIONS.length];
 				for (EDhDirection lodDirection : EDhDirection.ADJ_DIRECTIONS)
 				{
 					try
 					{
-						int xAdj = x + lodDirection.getNormal().x;
-						int zAdj = z + lodDirection.getNormal().z;
-						boolean isCrossRegionBoundary =
+						int xAdj = relX + lodDirection.getNormal().x;
+						int zAdj = relZ + lodDirection.getNormal().z;
+						boolean isCrossRenderSourceBoundary =
 								(xAdj < 0 || xAdj >= ColumnRenderSource.SECTION_SIZE) ||
-										(zAdj < 0 || zAdj >= ColumnRenderSource.SECTION_SIZE);
+								(zAdj < 0 || zAdj >= ColumnRenderSource.SECTION_SIZE);
 						
 						ColumnRenderSource adjRenderSource;
 						byte adjDetailLevel;
 						
-						//we check if the detail of the adjPos is equal to the correct one (region border fix)
-						//or if the detail is wrong by 1 value (region+circle border fix)
-						if (isCrossRegionBoundary)
+						
+						
+						//=========================//
+						// get the adjacent render //
+						// source if present       //
+						//=========================//
+						
+						if (!isCrossRenderSourceBoundary)
 						{
-							//we compute at which detail that position should be rendered
+							// the adjacent position is inside this same render source
+							adjRenderSource = renderSource;
+							adjDetailLevel = thisDetailLevel;
+						}
+						else
+						{
+							// the adjacent position is outside this render source
+							
+							// skip empty sections
 							adjRenderSource = adjRegions[lodDirection.ordinal() - 2];
 							if (adjRenderSource == null)
 							{
@@ -250,67 +287,70 @@ public class ColumnRenderBufferBuilder
 							}
 							
 							adjDetailLevel = adjRenderSource.getDataDetailLevel();
-							if (adjDetailLevel != detailLevel)
-							{
-								//TODO: Implement this
-							}
-							else
+							if (adjDetailLevel == thisDetailLevel)
 							{
+								// if the adjacent position is outside this render source,
+								// wrap the position around so it's inside the adjacent source
+								
 								if (xAdj < 0)
+								{
 									xAdj += ColumnRenderSource.SECTION_SIZE;
+								}
+								if (xAdj >= ColumnRenderSource.SECTION_SIZE)
+								{
+									xAdj -= ColumnRenderSource.SECTION_SIZE;
+								}
 								
 								if (zAdj < 0)
+								{
 									zAdj += ColumnRenderSource.SECTION_SIZE;
-								
-								if (xAdj >= ColumnRenderSource.SECTION_SIZE)
-									xAdj -= ColumnRenderSource.SECTION_SIZE;
-								
+								}
 								if (zAdj >= ColumnRenderSource.SECTION_SIZE)
+								{
 									zAdj -= ColumnRenderSource.SECTION_SIZE;
+								}
 							}
 						}
-						else
-						{
-							adjRenderSource = renderSource;
-							adjDetailLevel = detailLevel;
-						}
 						
-						if (adjDetailLevel < detailLevel - 1 || adjDetailLevel > detailLevel + 1)
-						{
-							continue;
-						}
 						
-						if (adjDetailLevel == detailLevel || adjDetailLevel > detailLevel)
-						{
-							adjColumnViews[lodDirection.ordinal() - 2] = new ColumnArrayView[1];
-							adjColumnViews[lodDirection.ordinal() - 2][0] = adjRenderSource.getVerticalDataPointView(xAdj, zAdj);
-						}
-						else
-						{
-							adjColumnViews[lodDirection.ordinal() - 2] = new ColumnArrayView[2];
-							adjColumnViews[lodDirection.ordinal() - 2][0] = adjRenderSource.getVerticalDataPointView(xAdj, zAdj);
-							adjColumnViews[lodDirection.ordinal() - 2][1] = adjRenderSource.getVerticalDataPointView(
-									xAdj + (lodDirection.getAxis() == EDhDirection.Axis.X ? 0 : 1),
-									zAdj + (lodDirection.getAxis() == EDhDirection.Axis.Z ? 0 : 1));
-						}
+						
+						//========================//
+						// get the adjacent views //
+						//========================//
+						
+						// the old logic handled additional cases, but they never appeared to fire,
+						// so just these two cases should be fine
+						LodUtil.assertTrue(adjDetailLevel == thisDetailLevel || adjDetailLevel > thisDetailLevel);
+						
+						adjColumnViews[lodDirection.ordinal() - 2] = adjRenderSource.getVerticalDataPointView(xAdj, zAdj);
 					}
 					catch (RuntimeException e)
 					{
-						EVENT_LOGGER.warn("Failed to get adj data for [" + detailLevel + ":" + x + "," + z + "] at [" + lodDirection + "], Error: "+e.getMessage(), e);
+						EVENT_LOGGER.warn("Failed to get adj data for relative pos: [" + thisDetailLevel + ":" + relX + "," + relZ + "] at [" + lodDirection + "], Error: "+e.getMessage(), e);
 					}
 				} // for adjacent directions
 				
 				
+				
+				//==========================//
+				// build this render column //
+				//==========================//
+				
+				ColumnRenderSource.DebugSourceFlag debugSourceFlag = renderSource.debugGetFlag(relX, relZ);
+				
 				// We render every vertical lod present in this position
 				// We only stop when we find a block that is void or non-existing block
 				for (int i = 0; i < columnRenderData.size(); i++)
 				{
-					// TODO make a config for this
 					// can be uncommented to limit which vertical LOD is generated
-//					if (i != 0)
-//					{
-//						continue;
-//					}
+					if (Config.Client.Advanced.Debugging.columnBuilderDebugEnable.get())
+					{
+						int wantedColumnIndex = Config.Client.Advanced.Debugging.columnBuilderDebugColumnIndex.get();
+						if (wantedColumnIndex >= 0 && i != wantedColumnIndex)
+						{
+							continue;
+						}
+					}
 					
 					long data = columnRenderData.get(i);
 					// If the data is not render-able (Void or non-existing) we stop since there is
@@ -323,8 +363,12 @@ public class ColumnRenderBufferBuilder
 					long topDataPoint = (i - 1) >= 0 ? columnRenderData.get(i - 1) : RenderDataPointUtil.EMPTY_DATA;
 					long bottomDataPoint = (i + 1) < columnRenderData.size() ? columnRenderData.get(i + 1) : RenderDataPointUtil.EMPTY_DATA;
 					
-					CubicLodTemplate.addLodToBuffer(data, topDataPoint, bottomDataPoint, adjColumnViews, detailLevel,
-							x, z, quadBuilder, debugMode, debugSourceFlag);
+					addLodToBuffer(
+							clientLevel,
+							data, topDataPoint, bottomDataPoint, 
+							adjColumnViews, isSameDetailLevel,
+							thisDetailLevel, relX, relZ, 
+							quadBuilder, debugSourceFlag);
 				}
 				
 			}// for z
@@ -332,33 +376,147 @@ public class ColumnRenderBufferBuilder
 		
 		quadBuilder.finalizeData();
 	}
-	
-	
-	
-	//=================//
-	// vbo interaction //
-	//=================//
-	
-	public static GLVertexBuffer[] resizeBuffer(GLVertexBuffer[] vbos, int newSize)
+	private static void addLodToBuffer(
+			IDhClientLevel clientLevel,
+			long data, long topData, long bottomData, 
+			ColumnArrayView[] adjColumnViews, boolean[] isSameDetailLevel,
+			byte detailLevel, int renderSourceOffsetPosX, int renderSourceOffsetPosZ, 
+			LodQuadBuilder quadBuilder, ColumnRenderSource.DebugSourceFlag debugSource)
 	{
-		if (vbos.length == newSize)
+		long sectionPos = DhSectionPos.encode(detailLevel, renderSourceOffsetPosX, renderSourceOffsetPosZ);
+		
+		short width = (short) BitShiftUtil.powerOfTwo(detailLevel);
+		short x = (short) DhSectionPos.getMinCornerBlockX(sectionPos);
+		short yMin = RenderDataPointUtil.getYMin(data);
+		short z = (short) DhSectionPos.getMinCornerBlockZ(sectionPos);
+		short ySize = (short) (RenderDataPointUtil.getYMax(data) - yMin);
+		
+		if (ySize == 0)
 		{
-			return vbos;
+			return;
+		}
+		else if (ySize < 0)
+		{
+			throw new IllegalArgumentException("Negative y size for the data! Data: [" + RenderDataPointUtil.toString(data) + "].");
 		}
 		
-		GLVertexBuffer[] newVbos = new GLVertexBuffer[newSize];
-		System.arraycopy(vbos, 0, newVbos, 0, Math.min(vbos.length, newSize));
-		if (newSize < vbos.length)
+		byte blockMaterialId = RenderDataPointUtil.getBlockMaterialId(data);
+		
+		
+		
+		int color;
+		boolean fullBright = false;
+		EDhApiDebugRendering debugging = Config.Client.Advanced.Debugging.debugRendering.get();
+		switch (debugging)
 		{
-			for (int i = newSize; i < vbos.length; i++)
+			case OFF:
 			{
-				if (vbos[i] != null)
+				float saturationMultiplier = Config.Client.Advanced.Graphics.AdvancedGraphics.saturationMultiplier.get().floatValue();
+				float brightnessMultiplier = Config.Client.Advanced.Graphics.AdvancedGraphics.brightnessMultiplier.get().floatValue();
+				if (saturationMultiplier == 1.0 && brightnessMultiplier == 1.0)
 				{
-					vbos[i].close();
+					color = RenderDataPointUtil.getColor(data);
 				}
+				else
+				{
+					float[] ahsv = ColorUtil.argbToAhsv(RenderDataPointUtil.getColor(data));
+					color = ColorUtil.ahsvToArgb(ahsv[0], ahsv[1], ahsv[2] * saturationMultiplier, ahsv[3] * brightnessMultiplier);
+				}
+				break;
 			}
+			case SHOW_DETAIL:
+			{
+				color = LodUtil.DEBUG_DETAIL_LEVEL_COLORS[detailLevel];
+				fullBright = true;
+				break;
+			}
+			case SHOW_BLOCK_MATERIAL:
+			{
+				
+				switch (EDhApiBlockMaterial.getFromIndex(blockMaterialId))
+				{
+					case UNKNOWN:
+					case AIR: // shouldn't normally be rendered, but just in case
+						color = ColorUtil.HOT_PINK;
+						break;
+					
+					case LEAVES:
+						color = ColorUtil.DARK_GREEN;
+						break;
+					case STONE:
+						color = ColorUtil.GRAY;
+						break;
+					case WOOD:
+						color = ColorUtil.BROWN;
+						break;
+					case METAL:
+						color = ColorUtil.DARK_GRAY;
+						break;
+					case DIRT:
+						color = ColorUtil.LIGHT_BROWN;
+						break;
+					case LAVA:
+						color = ColorUtil.ORANGE;
+						break;
+					case DEEPSLATE:
+						color = ColorUtil.BLACK;
+						break;
+					case SNOW:
+						color = ColorUtil.WHITE;
+						break;
+					case SAND:
+						color = ColorUtil.TAN;
+						break;
+					case TERRACOTTA:
+						color = ColorUtil.DARK_ORANGE;
+						break;
+					case NETHER_STONE:
+						color = ColorUtil.DARK_RED;
+						break;
+					case WATER:
+						color = ColorUtil.BLUE;
+						break;
+					case GRASS:
+						color = ColorUtil.GREEN;
+						break;
+					case ILLUMINATED:
+						color = ColorUtil.YELLOW;
+						break;
+					
+					default:
+						// undefined color
+						color = ColorUtil.CYAN;
+						break;
+				}
+				
+				fullBright = true;
+				break;
+			}
+			case SHOW_OVERLAPPING_QUADS:
+			{
+				color = ColorUtil.WHITE;
+				fullBright = true;
+				break;
+			}
+			case SHOW_RENDER_SOURCE_FLAG:
+			{
+				color = debugSource == null ? ColorUtil.RED : debugSource.color;
+				fullBright = true;
+				break;
+			}
+			default:
+				throw new IllegalArgumentException("Unknown debug mode: " + debugging);
 		}
-		return newVbos;
+		
+		ColumnBox.addBoxQuadsToBuilder(
+				quadBuilder, clientLevel,
+				width, ySize, width,
+				x, yMin, z,
+				color,
+				blockMaterialId,
+				RenderDataPointUtil.getLightSky(data),
+				fullBright ? 15 : RenderDataPointUtil.getLightBlock(data),
+				topData, bottomData, adjColumnViews, isSameDetailLevel);
 	}
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/render/bufferBuilding/CubicLodTemplate.java

@@ -1,186 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding;
-
-import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
-import com.seibel.distanthorizons.core.config.Config;
-import com.seibel.distanthorizons.core.dataObjects.render.ColumnRenderSource;
-import com.seibel.distanthorizons.core.pos.DhLodPos;
-import com.seibel.distanthorizons.core.util.ColorUtil;
-import com.seibel.distanthorizons.core.util.LodUtil;
-import com.seibel.distanthorizons.core.util.RenderDataPointUtil;
-import com.seibel.distanthorizons.api.enums.rendering.EDhApiDebugRendering;
-import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnArrayView;
-import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
-import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
-
-/**
- * Builds LODs as rectangular prisms.
- *
- * @author James Seibel
- * @version 2022-1-2
- */
-public class CubicLodTemplate
-{
-	
-	public static void addLodToBuffer(
-			long data, long topData, long bottomData, ColumnArrayView[][] adjColumnViews,
-			byte detailLevel, int offsetPosX, int offsetOosZ, LodQuadBuilder quadBuilder,
-			EDhApiDebugRendering debugging, ColumnRenderSource.DebugSourceFlag debugSource)
-	{
-		DhLodPos blockOffsetPos = new DhLodPos(detailLevel, offsetPosX, offsetOosZ).convertToDetailLevel(LodUtil.BLOCK_DETAIL_LEVEL);
-		
-		short width = (short) BitShiftUtil.powerOfTwo(detailLevel);
-		short x = (short) blockOffsetPos.x;
-		short yMin = RenderDataPointUtil.getYMin(data);
-		short z = (short) (short) blockOffsetPos.z;
-		short ySize = (short) (RenderDataPointUtil.getYMax(data) - yMin);
-		
-		if (ySize == 0)
-		{
-			return;
-		}
-		else if (ySize < 0)
-		{
-			throw new IllegalArgumentException("Negative y size for the data! Data: " + RenderDataPointUtil.toString(data));
-		}
-		
-		byte blockMaterialId = RenderDataPointUtil.getBlockMaterialId(data);
-		
-		
-		
-		int color;
-		boolean fullBright = false;
-		switch (debugging)
-		{
-			case OFF:
-			{
-				float saturationMultiplier = Config.Client.Advanced.Graphics.AdvancedGraphics.saturationMultiplier.get().floatValue();
-				float brightnessMultiplier = Config.Client.Advanced.Graphics.AdvancedGraphics.brightnessMultiplier.get().floatValue();
-				if (saturationMultiplier == 1.0 && brightnessMultiplier == 1.0)
-				{
-					color = RenderDataPointUtil.getColor(data);
-				}
-				else
-				{
-					float[] ahsv = ColorUtil.argbToAhsv(RenderDataPointUtil.getColor(data));
-					color = ColorUtil.ahsvToArgb(ahsv[0], ahsv[1], ahsv[2] * saturationMultiplier, ahsv[3] * brightnessMultiplier);
-					//ApiShared.LOGGER.info("Raw color:[{}], AHSV:{}, Out color:[{}]",
-					//		ColorUtil.toString(DataPointUtil.getColor(data)),
-					//		ahsv, ColorUtil.toString(color));
-				}
-				break;
-			}
-			case SHOW_DETAIL:
-			{
-				color = LodUtil.DEBUG_DETAIL_LEVEL_COLORS[detailLevel];
-				fullBright = true;
-				break;
-			}
-			case SHOW_BLOCK_MATERIAL:
-			{
-				
-				switch (EDhApiBlockMaterial.getFromIndex(blockMaterialId))
-				{
-					case UNKNOWN:
-					case AIR: // shouldn't normally be rendered, but just in case
-						color = ColorUtil.HOT_PINK;
-						break;
-						
-					case LEAVES:
-						color = ColorUtil.DARK_GREEN;
-						break;
-					case STONE:
-						color = ColorUtil.GRAY;
-						break;
-					case WOOD:
-						color = ColorUtil.BROWN;
-						break;
-					case METAL:
-						color = ColorUtil.DARK_GRAY;
-						break;
-					case DIRT:
-						color = ColorUtil.LIGHT_BROWN;
-						break;
-					case LAVA:
-						color = ColorUtil.ORANGE;
-						break;
-					case DEEPSLATE:
-						color = ColorUtil.BLACK;
-						break;
-					case SNOW:
-						color = ColorUtil.WHITE;
-						break;
-					case SAND:
-						color = ColorUtil.TAN;
-						break;
-					case TERRACOTTA:
-						color = ColorUtil.DARK_ORANGE;
-						break;
-					case NETHER_STONE:
-						color = ColorUtil.DARK_RED;
-						break;
-					case WATER:
-						color = ColorUtil.BLUE;
-						break;
-					case GRASS:
-						color = ColorUtil.GREEN;
-						break;
-					case ILLUMINATED:
-						color = ColorUtil.YELLOW;
-						break;
-					
-					default:
-						// undefined color
-						color = ColorUtil.CYAN;
-						break;
-				}
-				
-				fullBright = true;
-				break;
-			}
-			case SHOW_OVERLAPPING_QUADS:
-			{
-				color = ColorUtil.WHITE;
-				fullBright = true;
-				break;
-			}
-			case SHOW_RENDER_SOURCE_FLAG:
-			{
-				color = debugSource == null ? ColorUtil.RED : debugSource.color;
-				fullBright = true;
-				break;
-			}
-			default:
-				throw new IllegalArgumentException("Unknown debug mode: " + debugging);
-		}
-		
-		ColumnBox.addBoxQuadsToBuilder(
-				quadBuilder, // buffer
-				width, ySize, width, // setWidth
-				x, yMin, z, // setOffset
-				color, // setColor
-				blockMaterialId, // irisBlockMaterialId
-				RenderDataPointUtil.getLightSky(data), // setSkyLights
-				fullBright ? 15 : RenderDataPointUtil.getLightBlock(data), // setBlockLights
-				topData, bottomData, adjColumnViews); // setAdjData
-	}
-	
-}

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/render/bufferBuilding/LodQuadBuilder.java

@@ -38,8 +38,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftCli
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.coreapi.util.MathUtil;
 import org.apache.logging.log4j.Logger;
-
-//TODO: Recheck this class for refactoring
+import org.lwjgl.system.MemoryUtil;
 
 /**
  * Used to create the quads before they are converted to render-able buffers. <br><br>
@@ -51,9 +50,6 @@ public class LodQuadBuilder
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	
-	public final boolean skipQuadsWithZeroSkylight;
-	public final short skyLightCullingBelow;
-	
 	@SuppressWarnings("unchecked")
 	private final ArrayList<BufferQuad>[] opaqueQuads = (ArrayList<BufferQuad>[]) new ArrayList[6];
 	@SuppressWarnings("unchecked")
@@ -123,7 +119,7 @@ public class LodQuadBuilder
 	// constructor //
 	//=============//
 	
-	public LodQuadBuilder(boolean enableSkylightCulling, short skyLightCullingBelow, boolean doTransparency, IClientLevelWrapper clientLevelWrapper)
+	public LodQuadBuilder(boolean doTransparency, IClientLevelWrapper clientLevelWrapper)
 	{
 		this.doTransparency = doTransparency;
 		for (int i = 0; i < 6; i++)
@@ -132,8 +128,6 @@ public class LodQuadBuilder
 			this.transparentQuads[i] = new ArrayList<>();
 		}
 		
-		this.skipQuadsWithZeroSkylight = enableSkylightCulling;
-		this.skyLightCullingBelow = skyLightCullingBelow;
 		this.clientLevelWrapper = clientLevelWrapper;
 		
 		this.debugRenderingMode = Config.Client.Advanced.Debugging.debugRendering.get();
@@ -157,11 +151,6 @@ public class LodQuadBuilder
 			throw new IllegalArgumentException("addQuadAdj() is only for adj direction! Not UP or Down!");
 		}
 		
-		if (this.skipQuadsWithZeroSkylight && skyLight == 0 && y + widthNorthSouthOrUpDown < this.skyLightCullingBelow)
-		{
-			return;
-		}
-		
 		BufferQuad quad = new BufferQuad(x, y, z, widthEastWest, widthNorthSouthOrUpDown, color, irisBlockMaterialId, skyLight, blockLight, dir);
 		ArrayList<BufferQuad> quadList = (this.doTransparency && ColorUtil.getAlpha(color) < 255) ? this.transparentQuads[dir.ordinal()] : this.opaqueQuads[dir.ordinal()];
 		if (!quadList.isEmpty() &&
@@ -180,12 +169,6 @@ public class LodQuadBuilder
 	// XZ
 	public void addQuadUp(short x, short maxY, short z, short widthEastWest, short widthNorthSouthOrUpDown, int color, byte irisBlockMaterialId, byte skylight, byte blocklight) // TODO argument names are wrong
 	{
-		// cave culling
-		if (this.skipQuadsWithZeroSkylight && skylight == 0 && maxY < this.skyLightCullingBelow)
-		{
-			return;
-		}
-		
 		BufferQuad quad = new BufferQuad(x, maxY, z, widthEastWest, widthNorthSouthOrUpDown, color, irisBlockMaterialId, skylight, blocklight, EDhDirection.UP);
 		boolean isTransparent = (this.doTransparency && ColorUtil.getAlpha(color) < 255);
 		ArrayList<BufferQuad> quadList = isTransparent ? this.transparentQuads[EDhDirection.UP.ordinal()] : this.opaqueQuads[EDhDirection.UP.ordinal()];
@@ -207,17 +190,15 @@ public class LodQuadBuilder
 	
 	public void addQuadDown(short x, short y, short z, short width, short wz, int color, byte irisBlockMaterialId, byte skylight, byte blocklight)
 	{
-		if (skipQuadsWithZeroSkylight && skylight == 0 && y < skyLightCullingBelow)
-			return;
 		BufferQuad quad = new BufferQuad(x, y, z, width, wz, color, irisBlockMaterialId, skylight, blocklight, EDhDirection.DOWN);
-		ArrayList<BufferQuad> qs = (doTransparency && ColorUtil.getAlpha(color) < 255)
-				? transparentQuads[EDhDirection.DOWN.ordinal()] : opaqueQuads[EDhDirection.DOWN.ordinal()];
-		if (!qs.isEmpty() &&
-				(qs.get(qs.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.EastWest)
+		ArrayList<BufferQuad> qs = (this.doTransparency && ColorUtil.getAlpha(color) < 255)
+				? this.transparentQuads[EDhDirection.DOWN.ordinal()] : this.opaqueQuads[EDhDirection.DOWN.ordinal()];
+		if (!qs.isEmpty()
+				&& (qs.get(qs.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.EastWest)
 						|| qs.get(qs.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.NorthSouthOrUpDown))
-		)
+			)
 		{
-			premergeCount++;
+			this.premergeCount++;
 			return;
 		}
 		qs.add(quad);
@@ -225,10 +206,126 @@ public class LodQuadBuilder
 	
 	
 	
+	//=================//
+	// data finalizing //
+	//=================//
+	
+	/** runs any final data cleanup, merging, etc. */
+	public void finalizeData() { this.mergeQuads(); }
+	
+	/** Uses Greedy meshing to merge this builder's Quads. */
+	public void mergeQuads()
+	{
+		long mergeCount = 0; // can be used for debugging
+		long preQuadsCount = this.getCurrentOpaqueQuadsCount() + this.getCurrentTransparentQuadsCount();
+		if (preQuadsCount <= 1)
+		{
+			return;
+		}
+		
+		for (int directionIndex = 0; directionIndex < 6; directionIndex++)
+		{
+			mergeCount += mergeQuadsInternal(this.opaqueQuads, directionIndex, BufferMergeDirectionEnum.EastWest);
+			if (this.doTransparency)
+			{
+				mergeCount += mergeQuadsInternal(this.transparentQuads, directionIndex, BufferMergeDirectionEnum.EastWest);
+			}
+			
+			
+			// only run the second merge if the face is the top or bottom
+			if (directionIndex == EDhDirection.UP.ordinal() || directionIndex == EDhDirection.DOWN.ordinal())
+			{
+				mergeCount += mergeQuadsInternal(this.opaqueQuads, directionIndex, BufferMergeDirectionEnum.NorthSouthOrUpDown);
+				if (this.doTransparency)
+				{
+					mergeCount += mergeQuadsInternal(this.transparentQuads, directionIndex, BufferMergeDirectionEnum.NorthSouthOrUpDown);
+				}
+			}
+		}
+		
+		//long postQuadsCount = this.getCurrentOpaqueQuadsCount() + this.getCurrentTransparentQuadsCount();
+		//LOGGER.trace("Merged "+mergeCount+"/"+preQuadsCount+"("+(mergeCount / (double) preQuadsCount)+") quads");
+	}
+	
+	/** Merges all of this builder's quads for the given directionIndex (up, down, left, etc.) in the given direction */
+	private static long mergeQuadsInternal(ArrayList<BufferQuad>[] list, int directionIndex, BufferMergeDirectionEnum mergeDirection)
+	{
+		if (list[directionIndex].size() <= 1)
+		{
+			return 0;
+		}
+		
+		list[directionIndex].sort((objOne, objTwo) -> objOne.compare(objTwo, mergeDirection));
+		
+		long mergeCount = 0;
+		ListIterator<BufferQuad> iter = list[directionIndex].listIterator();
+		BufferQuad currentQuad = iter.next();
+		while (iter.hasNext())
+		{
+			BufferQuad nextQuad = iter.next();
+			
+			if (currentQuad.tryMerge(nextQuad, mergeDirection))
+			{
+				// merge successful, attempt to merge the next quad
+				mergeCount++;
+				iter.set(null);
+			}
+			else
+			{
+				// merge fail, move on to the next quad
+				currentQuad = nextQuad;
+			}
+		}
+		list[directionIndex].removeIf(Objects::isNull);
+		return mergeCount;
+	}
+	
+	
+	
 	//==============//
-	// add vertices //
+	// buffer setup //
 	//==============//
 	
+	public ArrayList<ByteBuffer> makeOpaqueVertexBuffers() { return this.makeVertexBuffers(this.opaqueQuads); }
+	public ArrayList<ByteBuffer> makeTransparentVertexBuffers() { return this.makeVertexBuffers(this.transparentQuads); }
+	private ArrayList<ByteBuffer> makeVertexBuffers(ArrayList<BufferQuad>[] quadList)
+	{
+		ArrayList<ByteBuffer> byteBufferList = new ArrayList<>(3);
+		
+		ByteBuffer buffer = null;
+		for (int directionIndex = 0; directionIndex < 6; directionIndex++)
+		{
+			// ignore empty directions
+			if (quadList[directionIndex].isEmpty())
+			{
+				continue;
+			}
+			
+			// put all the quads in this direction into the buffer
+			for (int quadIndex = 0; quadIndex < quadList[directionIndex].size(); quadIndex++)
+			{
+				// if this is the first iteration or the buffer is full, 
+				// create a new buffer
+				if (buffer == null || !buffer.hasRemaining())
+				{
+					buffer = MemoryUtil.memAlloc(ColumnRenderBuffer.FULL_SIZED_BUFFER);
+					byteBufferList.add(buffer);
+				}
+				
+				this.putQuad(buffer, quadList[directionIndex].get(quadIndex));
+			}
+		}
+		
+		// rewind all the buffers so they can be read from
+		for (int i = 0; i < byteBufferList.size(); i++)
+		{
+			buffer = byteBufferList.get(i);
+			buffer.limit(buffer.position());
+			buffer.rewind();
+		}
+		
+		return byteBufferList;
+	}
 	private void putQuad(ByteBuffer bb, BufferQuad quad)
 	{
 		int[][] quadBase = DIRECTION_VERTEX_IBO_QUAD[quad.direction.ordinal()];
@@ -286,10 +383,10 @@ public class LodQuadBuilder
 						if (quad.direction.getAxis().isHorizontal() || quad.direction == EDhDirection.DOWN)
 						{
 							if (this.grassSideRenderingMode == EDhApiGrassSideRendering.AS_DIRT
-								// if we want the color to fade, only apply the dirt color to the bottom vertices
-								|| (this.grassSideRenderingMode == EDhApiGrassSideRendering.FADE_TO_DIRT && quadBase[i][1] == 0)
-								// always render the bottom as dirt
-								|| quad.direction == EDhDirection.DOWN)
+									// if we want the color to fade, only apply the dirt color to the bottom vertices
+									|| (this.grassSideRenderingMode == EDhApiGrassSideRendering.FADE_TO_DIRT && quadBase[i][1] == 0)
+									// always render the bottom as dirt
+									|| quad.direction == EDhDirection.DOWN)
 							{
 								// for horizontal and bottom faces of grass blocks, use the  dirt color to
 								// prevent green cliff walls
@@ -297,7 +394,7 @@ public class LodQuadBuilder
 								color = ColorUtil.applyShade(color, MC.getShade(quad.direction));
 							}
 						}
-					}   
+					}
 				}
 			}
 			
@@ -311,7 +408,6 @@ public class LodQuadBuilder
 					mx, my, mz);
 		}
 	}
-	
 	private void putVertex(ByteBuffer bb, short x, short y, short z, int color, byte normalIndex, byte irisBlockMaterialId, byte skylight, byte blocklight, int mx, int my, int mz)
 	{
 		skylight %= 16;
@@ -329,9 +425,18 @@ public class LodQuadBuilder
 		// 0b01 = positive offset
 		// 0b11 = negative offset
 		// format is: 0b00zzyyxx
-		if (mx != 0) mirco |= mx > 0 ? 0b01 : 0b11;
-		if (my != 0) mirco |= my > 0 ? 0b0100 : 0b1100;
-		if (mz != 0) mirco |= mz > 0 ? 0b010000 : 0b110000;
+		if (mx != 0)
+		{
+			mirco |= mx > 0 ? 0b01 : 0b11;
+		}
+		if (my != 0)
+		{
+			mirco |= my > 0 ? 0b0100 : 0b1100;
+		}
+		if (mz != 0)
+		{
+			mirco |= mz > 0 ? 0b010000 : 0b110000;
+		}
 		meta |= mirco << 8;
 		
 		bb.putShort(meta);
@@ -352,389 +457,6 @@ public class LodQuadBuilder
 	
 	
 	
-	//=================//
-	// data finalizing //
-	//=================//
-	
-	/** runs any final data cleanup, merging, etc. */
-	public void finalizeData() { this.mergeQuads(); }
-	
-	/** Uses Greedy meshing to merge this builder's Quads. */
-	public void mergeQuads()
-	{
-		long mergeCount = 0;
-		long preQuadsCount = this.getCurrentOpaqueQuadsCount() + this.getCurrentTransparentQuadsCount();
-		if (preQuadsCount <= 1)
-		{
-			return;
-		}
-		
-		for (int directionIndex = 0; directionIndex < 6; directionIndex++)
-		{
-			mergeCount += mergeQuadsInternal(this.opaqueQuads, directionIndex, BufferMergeDirectionEnum.EastWest);
-			if (this.doTransparency)
-			{
-				mergeCount += mergeQuadsInternal(this.transparentQuads, directionIndex, BufferMergeDirectionEnum.EastWest);
-			}
-			
-			
-			// only run the second merge if the face is the top or bottom
-			if (directionIndex == EDhDirection.UP.ordinal() || directionIndex == EDhDirection.DOWN.ordinal())
-			{
-				mergeCount += mergeQuadsInternal(this.opaqueQuads, directionIndex, BufferMergeDirectionEnum.NorthSouthOrUpDown);
-				if (this.doTransparency)
-				{
-					mergeCount += mergeQuadsInternal(this.transparentQuads, directionIndex, BufferMergeDirectionEnum.NorthSouthOrUpDown);
-				}
-			}
-		}
-		
-		long postQuadsCount = this.getCurrentOpaqueQuadsCount() + this.getCurrentTransparentQuadsCount();
-		LOGGER.debug("Merged "+mergeCount+"/"+preQuadsCount+"("+(mergeCount / (double) preQuadsCount)+") quads");
-	}
-	
-	/** Merges all of this builder's quads for the given directionIndex (up, down, left, etc.) in the given direction */
-	private static long mergeQuadsInternal(ArrayList<BufferQuad>[] list, int directionIndex, BufferMergeDirectionEnum mergeDirection)
-	{
-		if (list[directionIndex].size() <= 1)
-			return 0;
-		
-		list[directionIndex].sort((objOne, objTwo) -> objOne.compare(objTwo, mergeDirection));
-		
-		long mergeCount = 0;
-		ListIterator<BufferQuad> iter = list[directionIndex].listIterator();
-		BufferQuad currentQuad = iter.next();
-		while (iter.hasNext())
-		{
-			BufferQuad nextQuad = iter.next();
-			
-			if (currentQuad.tryMerge(nextQuad, mergeDirection))
-			{
-				// merge successful, attempt to merge the next quad
-				mergeCount++;
-				iter.set(null);
-			}
-			else
-			{
-				// merge fail, move on to the next quad
-				currentQuad = nextQuad;
-			}
-		}
-		list[directionIndex].removeIf(Objects::isNull);
-		return mergeCount;
-	}
-	
-	
-	
-	//==============//
-	// buffer setup //
-	//==============//
-	
-	public Iterator<ByteBuffer> makeOpaqueVertexBuffers()
-	{
-		return new Iterator<ByteBuffer>()
-		{
-			final ByteBuffer bb = ByteBuffer.allocateDirect(ColumnRenderBuffer.FULL_SIZED_BUFFER)
-					.order(ByteOrder.nativeOrder());
-			int dir = skipEmpty(0);
-			int quad = 0;
-			
-			private int skipEmpty(int d)
-			{
-				while (d < 6 && opaqueQuads[d].isEmpty())
-				{
-					d++;
-				}
-				return d;
-			}
-			
-			@Override
-			public boolean hasNext()
-			{
-				return dir < 6;
-			}
-			
-			@Override
-			public ByteBuffer next()
-			{
-				if (dir >= 6)
-				{
-					return null;
-				}
-				bb.clear();
-				bb.limit(ColumnRenderBuffer.FULL_SIZED_BUFFER);
-				while (bb.hasRemaining() && dir < 6)
-				{
-					writeData();
-				}
-				bb.limit(bb.position());
-				bb.rewind();
-				return bb;
-			}
-			
-			private void writeData()
-			{
-				int i = quad;
-				for (; i < opaqueQuads[dir].size(); i++)
-				{
-					if (!bb.hasRemaining())
-					{
-						break;
-					}
-					putQuad(bb, opaqueQuads[dir].get(i));
-				}
-				
-				if (i >= opaqueQuads[dir].size())
-				{
-					quad = 0;
-					dir++;
-					dir = skipEmpty(dir);
-				}
-				else
-				{
-					quad = i;
-				}
-			}
-		};
-	}
-	
-	public Iterator<ByteBuffer> makeTransparentVertexBuffers()
-	{
-		return new Iterator<ByteBuffer>()
-		{
-			final ByteBuffer bb = ByteBuffer.allocateDirect(ColumnRenderBuffer.FULL_SIZED_BUFFER)
-					.order(ByteOrder.nativeOrder());
-			int directionIndex = this.skipEmptyDirectionIndices(0);
-			int quad = 0;
-			
-			private int skipEmptyDirectionIndices(int directionIndex)
-			{
-				while (directionIndex < 6 &&
-						(LodQuadBuilder.this.transparentQuads[directionIndex] == null
-								|| LodQuadBuilder.this.transparentQuads[directionIndex].isEmpty()))
-				{
-					directionIndex++;
-				}
-				
-				return directionIndex;
-			}
-			
-			@Override
-			public boolean hasNext() { return this.directionIndex < 6; }
-			
-			@Override
-			public ByteBuffer next()
-			{
-				if (this.directionIndex >= 6)
-				{
-					return null;
-				}
-				
-				this.bb.clear();
-				this.bb.limit(ColumnRenderBuffer.FULL_SIZED_BUFFER);
-				while (this.bb.hasRemaining() && this.directionIndex < 6)
-				{
-					this.writeData();
-				}
-				this.bb.limit(this.bb.position());
-				this.bb.rewind();
-				return this.bb;
-			}
-			
-			private void writeData()
-			{
-				int i = this.quad;
-				for (; i < LodQuadBuilder.this.transparentQuads[this.directionIndex].size(); i++)
-				{
-					if (!this.bb.hasRemaining())
-					{
-						break;
-					}
-					putQuad(this.bb, LodQuadBuilder.this.transparentQuads[this.directionIndex].get(i));
-				}
-				
-				if (i >= LodQuadBuilder.this.transparentQuads[this.directionIndex].size())
-				{
-					this.quad = 0;
-					this.directionIndex++;
-					this.directionIndex = this.skipEmptyDirectionIndices(this.directionIndex);
-				}
-				else
-				{
-					this.quad = i;
-				}
-			}
-		};
-	}
-	public interface BufferFiller
-	{
-		/** If true: more data needs to be filled */
-		boolean fill(GLVertexBuffer vbo);
-		
-	}
-	
-	public BufferFiller makeOpaqueBufferFiller(EDhApiGpuUploadMethod method)
-	{
-		return new BufferFiller()
-		{
-			int dir = 0;
-			int quad = 0;
-			
-			public boolean fill(GLVertexBuffer vbo)
-			{
-				if (dir >= 6)
-				{
-					vbo.setVertexCount(0);
-					return false;
-				}
-				
-				int numOfQuads = _countRemainingQuads();
-				if (numOfQuads > ColumnRenderBuffer.MAX_QUADS_PER_BUFFER)
-					numOfQuads = ColumnRenderBuffer.MAX_QUADS_PER_BUFFER;
-				if (numOfQuads == 0)
-				{
-					vbo.setVertexCount(0);
-					return false;
-				}
-				ByteBuffer bb = vbo.mapBuffer(numOfQuads * ColumnRenderBuffer.QUADS_BYTE_SIZE, method,
-						ColumnRenderBuffer.FULL_SIZED_BUFFER);
-				if (bb == null)
-					throw new NullPointerException("mapBuffer returned null");
-				bb.clear();
-				bb.limit(numOfQuads * ColumnRenderBuffer.QUADS_BYTE_SIZE);
-				while (bb.hasRemaining() && dir < 6)
-				{
-					writeData(bb);
-				}
-				bb.rewind();
-				vbo.unmapBuffer();
-				vbo.setVertexCount(numOfQuads * 4);
-				return dir < 6;
-			}
-			
-			private int _countRemainingQuads()
-			{
-				int a = opaqueQuads[dir].size() - quad;
-				for (int i = dir + 1; i < opaqueQuads.length; i++)
-				{
-					a += opaqueQuads[i].size();
-				}
-				return a;
-			}
-			
-			private void writeData(ByteBuffer bb)
-			{
-				int startQ = quad;
-				
-				int i = startQ;
-				for (i = startQ; i < opaqueQuads[dir].size(); i++)
-				{
-					if (!bb.hasRemaining())
-					{
-						break;
-					}
-					putQuad(bb, opaqueQuads[dir].get(i));
-				}
-				
-				if (i >= opaqueQuads[dir].size())
-				{
-					quad = 0;
-					dir++;
-					while (dir < 6 && opaqueQuads[dir].isEmpty())
-					{
-						dir++;
-					}
-				}
-				else
-				{
-					quad = i;
-				}
-			}
-		};
-	}
-	
-	public BufferFiller makeTransparentBufferFiller(EDhApiGpuUploadMethod method)
-	{
-		return new BufferFiller()
-		{
-			int dir = 0;
-			int quad = 0;
-			
-			public boolean fill(GLVertexBuffer vbo)
-			{
-				if (dir >= 6)
-				{
-					vbo.setVertexCount(0);
-					return false;
-				}
-				
-				int numOfQuads = _countRemainingQuads();
-				if (numOfQuads > ColumnRenderBuffer.MAX_QUADS_PER_BUFFER)
-					numOfQuads = ColumnRenderBuffer.MAX_QUADS_PER_BUFFER;
-				if (numOfQuads == 0)
-				{
-					vbo.setVertexCount(0);
-					return false;
-				}
-				ByteBuffer bb = vbo.mapBuffer(numOfQuads * ColumnRenderBuffer.QUADS_BYTE_SIZE, method,
-						ColumnRenderBuffer.FULL_SIZED_BUFFER);
-				if (bb == null)
-					throw new NullPointerException("mapBuffer returned null");
-				bb.clear();
-				bb.limit(numOfQuads * ColumnRenderBuffer.QUADS_BYTE_SIZE);
-				while (bb.hasRemaining() && dir < 6)
-				{
-					writeData(bb);
-				}
-				bb.rewind();
-				vbo.unmapBuffer();
-				vbo.setVertexCount(numOfQuads * 4);
-				return dir < 6;
-			}
-			
-			private int _countRemainingQuads()
-			{
-				int a = transparentQuads[dir].size() - quad;
-				for (int i = dir + 1; i < transparentQuads.length; i++)
-				{
-					a += transparentQuads[i].size();
-				}
-				return a;
-			}
-			
-			private void writeData(ByteBuffer bb)
-			{
-				int startQ = quad;
-				
-				int i = startQ;
-				for (i = startQ; i < transparentQuads[dir].size(); i++)
-				{
-					if (!bb.hasRemaining())
-					{
-						break;
-					}
-					putQuad(bb, transparentQuads[dir].get(i));
-				}
-				
-				if (i >= transparentQuads[dir].size())
-				{
-					quad = 0;
-					dir++;
-					while (dir < 6 && transparentQuads[dir].isEmpty())
-					{
-						dir++;
-					}
-				}
-				else
-				{
-					quad = i;
-				}
-			}
-		};
-	}
-	
-	
-	
 	//=========//
 	// getters //
 	//=========//

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/render/columnViews/ColumnArrayView.java

@@ -20,6 +20,7 @@
 package com.seibel.distanthorizons.core.dataObjects.render.columnViews;
 
 
+import com.seibel.distanthorizons.core.dataObjects.render.ColumnRenderSource;
 import com.seibel.distanthorizons.core.util.RenderDataPointUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 
@@ -28,41 +29,60 @@ import java.util.Arrays;
 public final class ColumnArrayView implements IColumnDataView
 {
 	public final LongArrayList data;
+	
+	/** 
+	 * How many data points are currently being represented by this view. <br>
+	 * Will be equal to or less than {@link ColumnArrayView#verticalSize}.
+	 */
 	public final int size;
-	public final int offset; // offset in longs
-	/** can be 0 if this column was created for an empty data source */
-	public final int vertSize; // vertical size in longs
+	/** 
+	 * Vertical size in data points. <Br>
+	 * Can be 0 if this column was created for an empty data source.
+	 */
+	public final int verticalSize;
+	
+	/**
+	 * Where the relative starting index is in the {@link ColumnArrayView#data} array
+	 * if this view is representing part of a {@link ColumnRenderSource}.
+	 */
+	public final int offset;
 	
 	
 	
-	public ColumnArrayView(LongArrayList data, int size, int offset, int vertSize)
+	//=============//
+	// constructor //
+	//=============//
+	
+	public ColumnArrayView(LongArrayList data, int size, int offset, int verticalSize)
 	{
 		this.data = data;
 		this.size = size;
 		this.offset = offset;
-		this.vertSize = vertSize;
+		this.verticalSize = verticalSize;
 	}
 	
 	
 	
+	//=====================//
+	// getters and setters //
+	//=====================//
+	
 	@Override
 	public long get(int index) { return data.getLong(index + offset); }
-	
 	public void set(int index, long value) { data.set(index + offset, value); }
 	
 	@Override
 	public int size() { return size; }
+	@Override
+	public int verticalSize() { return verticalSize; }
 	
 	@Override
-	public int verticalSize() { return vertSize; }
-	
-	@Override
-	public int dataCount() { return (this.vertSize != 0) ? (this.size / this.vertSize) : 0; }
+	public int dataCount() { return (this.verticalSize != 0) ? (this.size / this.verticalSize) : 0; } // TODO what does the divide by mean?
 	
 	@Override
 	public ColumnArrayView subView(int dataIndexStart, int dataCount)
 	{
-		return new ColumnArrayView(data, dataCount * vertSize, offset + dataIndexStart * vertSize, vertSize);
+		return new ColumnArrayView(data, dataCount * verticalSize, offset + dataIndexStart * verticalSize, verticalSize);
 	}
 	
 	public void fill(long value) { Arrays.fill(data.elements(), offset, offset + size, value); }
@@ -70,7 +90,7 @@ public final class ColumnArrayView implements IColumnDataView
 	public void copyFrom(IColumnDataView source) { copyFrom(source, 0); }
 	public void copyFrom(IColumnDataView source, int outputDataIndexOffset)
 	{
-		if (source.verticalSize() > vertSize)
+		if (source.verticalSize() > verticalSize)
 		{
 			throw new IllegalArgumentException("source verticalSize must be <= self's verticalSize to copy");
 		}
@@ -78,19 +98,19 @@ public final class ColumnArrayView implements IColumnDataView
 		{
 			throw new IllegalArgumentException("dataIndexStart + source.dataCount() must be <= self.dataCount() to copy");
 		}
-		else if (source.verticalSize() != vertSize)
+		else if (source.verticalSize() != verticalSize)
 		{
 			for (int i = 0; i < source.dataCount(); i++)
 			{
-				int outputOffset = offset + outputDataIndexOffset * vertSize + i * vertSize;
+				int outputOffset = offset + outputDataIndexOffset * verticalSize + i * verticalSize;
 				source.subView(i, 1).copyTo(data.elements(), outputOffset, source.verticalSize());
 				Arrays.fill(data.elements(), outputOffset + source.verticalSize(),
-						outputOffset + vertSize, 0);
+						outputOffset + verticalSize, 0);
 			}
 		}
 		else
 		{
-			source.copyTo(data.elements(), offset + outputDataIndexOffset * vertSize, source.size());
+			source.copyTo(data.elements(), offset + outputDataIndexOffset * verticalSize, source.size());
 		}
 	}
 	
@@ -103,19 +123,19 @@ public final class ColumnArrayView implements IColumnDataView
 		{
 			throw new IllegalArgumentException("Cannot merge views of different sizes");
 		}
-		if (vertSize != source.vertSize)
+		if (verticalSize != source.verticalSize)
 		{
 			throw new IllegalArgumentException("Cannot merge views of different vertical sizes");
 		}
 		boolean anyChange = false;
-		for (int o = 0; o < (source.size() * vertSize); o += vertSize)
+		for (int o = 0; o < (source.size() * verticalSize); o += verticalSize)
 		{
 			if (override)
 			{
 				if (RenderDataPointUtil.compareDatapointPriority(source.get(o), get(o)) >= 0)
 				{
 					anyChange = true;
-					System.arraycopy(source.data, source.offset + o, data, offset + o, vertSize);
+					System.arraycopy(source.data, source.offset + o, data, offset + o, verticalSize);
 				}
 			}
 			else
@@ -123,7 +143,7 @@ public final class ColumnArrayView implements IColumnDataView
 				if (RenderDataPointUtil.compareDatapointPriority(source.get(o), get(o)) > 0)
 				{
 					anyChange = true;
-					System.arraycopy(source.data, source.offset + o, data, offset + o, vertSize);
+					System.arraycopy(source.data, source.offset + o, data, offset + o, verticalSize);
 				}
 			}
 		}
@@ -137,7 +157,7 @@ public final class ColumnArrayView implements IColumnDataView
 			throw new IllegalArgumentException("Cannot copy and resize to views with different dataCounts");
 		}
 		
-		if (this.vertSize >= source.verticalSize())
+		if (this.verticalSize >= source.verticalSize())
 		{
 			this.copyFrom(source);
 		}
@@ -160,12 +180,18 @@ public final class ColumnArrayView implements IColumnDataView
 		RenderDataPointUtil.mergeMultiData(source, this);
 	}
 	
+	
+	
+	//================//
+	// base overrides //
+	//================//
+	
 	@Override
 	public String toString()
 	{
 		StringBuilder sb = new StringBuilder();
 		sb.append("S:").append(size);
-		sb.append(" V:").append(vertSize);
+		sb.append(" V:").append(verticalSize);
 		sb.append(" O:").append(offset);
 		
 		sb.append(" [");
@@ -182,6 +208,7 @@ public final class ColumnArrayView implements IColumnDataView
 		return sb.toString();
 	}
 	
+	
 	public int getDataHash()
 	{
 		return arrayHash(data, offset, size);

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/transformers/ChunkToLodBuilder.java

@@ -1,253 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.core.dataObjects.transformers;
-
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import com.seibel.distanthorizons.core.config.Config;
-import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
-import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
-import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
-import com.seibel.distanthorizons.core.pos.DhChunkPos;
-import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
-import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
-import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
-import org.apache.logging.log4j.LogManager;
-
-public class ChunkToLodBuilder implements AutoCloseable
-{
-	public static final ConfigBasedLogger LOGGER = new ConfigBasedLogger(LogManager.getLogger(), () -> Config.Client.Advanced.Logging.logLodBuilderEvent.get());
-	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
-	
-	public static final long MAX_TICK_TIME_NS = 1000000000L / 20L;
-	
-	private final ConcurrentHashMap<DhChunkPos, IChunkWrapper> concurrentChunkToBuildByChunkPos = new ConcurrentHashMap<>();
-	private final ConcurrentLinkedDeque<Task> concurrentTaskToBuildList = new ConcurrentLinkedDeque<>();
-	private final AtomicInteger runningCount = new AtomicInteger(0);
-	
-	
-	
-	//==============//
-	// constructors //
-	//==============//
-	
-	public ChunkToLodBuilder() { }
-	
-	
-	
-	//=================//
-	// data generation //
-	//=================//
-	
-	public CompletableFuture<FullDataSourceV2> tryGenerateData(IChunkWrapper chunkWrapper)
-	{
-		if (chunkWrapper == null)
-		{
-			throw new NullPointerException("ChunkWrapper cannot be null!");
-		}
-		
-		IChunkWrapper oldChunk = this.concurrentChunkToBuildByChunkPos.put(chunkWrapper.getChunkPos(), chunkWrapper); // an Exchange operation
-		// If there's old chunk, that means we just replaced an unprocessed old request on generating data on this pos.
-		//   if so, we can just return null to signal this, as the old request's future will instead be the proper one
-		//   that will return the latest generated data.
-		if (oldChunk != null)
-		{
-			return null;
-		}
-		
-		// Otherwise, it means we're the first to do so. Let's submit our task to this entry.
-		CompletableFuture<FullDataSourceV2> future = new CompletableFuture<>();
-		this.concurrentTaskToBuildList.addLast(new Task(chunkWrapper.getChunkPos(), future));
-		return future;
-	}
-	
-	// TODO why on tick?
-	public void tick()
-	{
-		int threadCount = ThreadPoolUtil.getWorkerThreadCount();
-		if (this.runningCount.get() >= threadCount)
-		{
-			return;
-		}
-		else if (this.concurrentTaskToBuildList.isEmpty())
-		{
-			return;
-		}
-		else if (MC == null || !MC.playerExists())
-		{
-			// TODO handle server side properly
-			
-			// MC hasn't finished loading (or is currently unloaded)
-			
-			// can be uncommented if tasks aren't being cleared correctly
-			//this.clearCurrentTasks();
-			return;
-		}
-		
-		ThreadPoolExecutor lodBuilderExecutor = ThreadPoolUtil.getChunkToLodBuilderExecutor();
-		if (lodBuilderExecutor == null)
-		{
-			return;
-		}
-		
-		
-		for (int i = 0; i < threadCount; i++)
-		{
-			this.runningCount.incrementAndGet();
-			try
-			{
-				CompletableFuture.runAsync(() ->
-				{
-					try
-					{
-						this.tickThreadTask();
-					}
-					finally
-					{
-						this.runningCount.decrementAndGet();
-					}
-				}, lodBuilderExecutor);
-			}
-			catch (RejectedExecutionException ignore) { /* the thread pool was probably shut down because it's size is being changed, just wait a sec and it should be back */ }
-		}
-	}
-	private void tickThreadTask()
-	{
-		long time = System.nanoTime();
-		int count = 0;
-		boolean allDone = false;
-		while (true)
-		{
-			// run until we either run out of time, or all tasks are complete
-			if (System.nanoTime() - time > MAX_TICK_TIME_NS && !this.concurrentTaskToBuildList.isEmpty())
-			{
-				break;
-			}
-			
-			Task task = this.concurrentTaskToBuildList.pollFirst();
-			if (task == null)
-			{
-				allDone = true;
-				break;
-			}
-			
-			count++;
-			IChunkWrapper latestChunk = this.concurrentChunkToBuildByChunkPos.remove(task.chunkPos); // Basically an Exchange operation
-			if (latestChunk == null)
-			{
-				LOGGER.error("Somehow Task at " + task.chunkPos + " has latestChunk as null. Skipping task.");
-				task.future.complete(null);
-				continue;
-			}
-			
-			try
-			{
-				if (LodDataBuilder.canGenerateLodFromChunk(latestChunk))
-				{
-					FullDataSourceV2 dataSource = LodDataBuilder.createGeneratedDataSource(latestChunk);
-					if (dataSource != null)
-					{
-						task.future.complete(dataSource);
-						continue;
-					}
-				}
-				else if (task.generationAttemptExpirationTimeMs < System.currentTimeMillis())
-				{
-					// this task won't be re-queued
-					//LOGGER.trace("removed chunk "+task.chunkPos);
-					continue;
-				}
-			}
-			catch (Exception ex)
-			{
-				LOGGER.error("Error while processing Task at " + task.chunkPos, ex);
-			}
-			
-			// Failed to build due to chunk not meeting requirement,
-			// re-add it to the queue so it can be tested next time
-			IChunkWrapper casChunk = this.concurrentChunkToBuildByChunkPos.putIfAbsent(task.chunkPos, latestChunk); // CAS operation with expected=null
-			if (casChunk == null || latestChunk.isStillValid()) // That means CAS have been successful
-			{
-				this.concurrentTaskToBuildList.addLast(task); // Then add back the same old task.
-			}
-			else // Else, it means someone managed to sneak in a new gen request in this pos. Then lets drop this old task.
-			{
-				task.future.complete(null);
-			}
-			
-			count--;
-		}
-		
-		long time2 = System.nanoTime();
-		if (!allDone)
-		{
-			//LOGGER.info("Completed {} tasks in {} in this tick", count, Duration.ofNanos(time2 - time));
-		}
-		else if (count > 0)
-		{
-			//LOGGER.info("Completed all {} tasks in {}", count, Duration.ofNanos(time2 - time));
-		}
-	}
-	
-	/**
-	 * should be called whenever changing levels/worlds
-	 * to prevent trying to generate LODs for chunk(s) that are no longer loaded
-	 * (which can cause exceptions)
-	 */
-	public void clearCurrentTasks()
-	{
-		this.concurrentTaskToBuildList.clear();
-		this.concurrentChunkToBuildByChunkPos.clear();
-	}
-	
-	
-	
-	
-	//==============//
-	// base methods //
-	//==============//
-	
-	@Override
-	public void close() { this.clearCurrentTasks(); }
-	
-	
-	
-	//================//
-	// helper classes //
-	//================//
-	
-	private static class Task
-	{
-		public final DhChunkPos chunkPos;
-		public final CompletableFuture<FullDataSourceV2> future;
-		/** This is tracked so impossible tasks can be removed from the queue */
-		public long generationAttemptExpirationTimeMs = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(10);
-		
-		Task(DhChunkPos chunkPos, CompletableFuture<FullDataSourceV2> future)
-		{
-			this.chunkPos = chunkPos;
-			this.future = future;
-		}
-		
-	}
-	
-}
-

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/transformers/FullDataToRenderDataTransformer.java

@@ -28,7 +28,7 @@ import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnArra
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.level.IDhClientLevel;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.util.ColorUtil;
 import com.seibel.distanthorizons.core.util.FullDataPointUtil;
@@ -38,6 +38,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
+import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
 import org.apache.logging.log4j.Logger;
@@ -110,33 +111,260 @@ public class FullDataToRenderDataTransformer
 		}
 		
 		columnSource.markNotEmpty();
+		int baseX = DhSectionPos.getMinCornerBlockX(pos);
+		int baseZ = DhSectionPos.getMinCornerBlockZ(pos);
 		
-		if (dataDetail == columnSource.getDataDetailLevel())
+		for (int x = 0; x < DhSectionPos.getWidthCountForLowerDetailedSection(pos, dataDetail); x++)
 		{
-			int baseX = DhSectionPos.getMinCornerBlockX(pos);
-			int baseZ = DhSectionPos.getMinCornerBlockZ(pos);
-			
-			for (int x = 0; x < DhSectionPos.getWidthCountForLowerDetailedSection(pos, dataDetail); x++)
+			for (int z = 0; z < DhSectionPos.getWidthCountForLowerDetailedSection(pos, dataDetail); z++)
 			{
-				for (int z = 0; z < DhSectionPos.getWidthCountForLowerDetailedSection(pos, dataDetail); z++)
-				{
-					throwIfThreadInterrupted();
-					
-					ColumnArrayView columnArrayView = columnSource.getVerticalDataPointView(x, z);
-					LongArrayList dataColumn = fullDataSource.get(x, z);
-					convertColumnData(level, fullDataSource.mapping, baseX + x, baseZ + z, columnArrayView, dataColumn);
-				}
+				throwIfThreadInterrupted();
+				
+				ColumnArrayView columnArrayView = columnSource.getVerticalDataPointView(x, z);
+				LongArrayList dataColumn = fullDataSource.get(x, z);
+				
+				updateOrReplaceRenderDataViewColumnWithFullDataColumn(
+						level, fullDataSource.mapping, 
+						// bitshift is to account for LODs with a detail level greater than 0 so the block pos is correct
+						baseX + BitShiftUtil.pow(x,dataDetail), baseZ + BitShiftUtil.pow(z,dataDetail), 
+						columnArrayView, dataColumn);
 			}
+		}
+		
+		columnSource.fillDebugFlag(0, 0, ColumnRenderSource.SECTION_SIZE, ColumnRenderSource.SECTION_SIZE, ColumnRenderSource.DebugSourceFlag.FULL);
 			
-			columnSource.fillDebugFlag(0, 0, ColumnRenderSource.SECTION_SIZE, ColumnRenderSource.SECTION_SIZE, ColumnRenderSource.DebugSourceFlag.FULL);
-			
+		return columnSource;
+	}
+	
+	/** Updates the given {@link ColumnArrayView} to match the incoming Full data {@link LongArrayList} */
+	public static void updateOrReplaceRenderDataViewColumnWithFullDataColumn(
+			IDhClientLevel level, 
+			FullDataPointIdMap fullDataMapping, int blockX, int blockZ, 
+			ColumnArrayView columnArrayView, 
+			LongArrayList fullDataColumn)
+	{
+		// we can't do anything if the full data is missing or empty
+		if (fullDataColumn == null || fullDataColumn.size() == 0)
+		{
+			return;
+		}
+		
+		int fullDataLength = fullDataColumn.size();
+		if (fullDataLength <= columnArrayView.verticalSize())
+		{
+			// Directly use the arrayView since it fits.
+			setRenderColumnView(level, fullDataMapping, blockX, blockZ, columnArrayView, fullDataColumn);
 		}
 		else
 		{
-			throw new UnsupportedOperationException("To be implemented");
-			//FIXME: Implement different size creation of renderData
+			// expand the ColumnArrayView to fit the new larger max vertical size
+			ColumnArrayView newColumnArrayView = new ColumnArrayView(new LongArrayList(new long[fullDataLength]), fullDataLength, 0, fullDataLength);
+			setRenderColumnView(level, fullDataMapping, blockX, blockZ, newColumnArrayView, fullDataColumn);
+			columnArrayView.changeVerticalSizeFrom(newColumnArrayView);
+		}
+	}
+	private static void setRenderColumnView(
+			IDhClientLevel level, FullDataPointIdMap fullDataMapping,
+			int blockX, int blockZ,
+			ColumnArrayView renderColumnData, LongArrayList fullColumnData)
+	{
+		//===============//
+		// config values //
+		//===============//
+		
+		boolean ignoreNonCollidingBlocks = (Config.Client.Advanced.Graphics.Quality.blocksToIgnore.get() == EDhApiBlocksToAvoid.NON_COLLIDING);
+		boolean colorBelowWithAvoidedBlocks = Config.Client.Advanced.Graphics.Quality.tintWithAvoidedBlocks.get();
+		
+		HashSet<IBlockStateWrapper> blockStatesToIgnore = WRAPPER_FACTORY.getRendererIgnoredBlocks(level.getLevelWrapper());
+		HashSet<IBlockStateWrapper> caveBlockStatesToIgnore = WRAPPER_FACTORY.getRendererIgnoredCaveBlocks(level.getLevelWrapper());
+		
+		int caveCullingMaxY = Config.Client.Advanced.Graphics.AdvancedGraphics.caveCullingHeight.get() - level.getMinY();
+		boolean caveCullingEnabled = 
+			Config.Client.Advanced.Graphics.AdvancedGraphics.enableCaveCulling.get()
+			&& (
+				// dimensions with a ceiling will be all caves so we don't want cave culling
+				!level.getLevelWrapper().hasCeiling()
+				// the end has a lot of overhangs with 0 lighting above the void, which look broken with
+				// the current cave culling logic (this could probably be improved, but just skipping it works best for now)
+				&& !level.getLevelWrapper().getDimensionType().isTheEnd()
+			);
+		
+		boolean isColumnVoid = true;
+		
+		int colorToApplyToNextBlock = -1;
+		int lastColor = 0;
+		int lastBottom = -10_000;
+		
+		int skylightToApplyToNextBlock = -1;
+		int blocklightToApplyToNextBlock = -1;
+		int renderDataIndex = 0;
+		
+		
+		
+		//==================================//
+		// convert full data to render data //
+		//==================================//
+		
+		// goes from the top down
+		for (int fullDataIndex = 0; fullDataIndex < fullColumnData.size(); fullDataIndex++)
+		{
+			long fullData = fullColumnData.getLong(fullDataIndex);
+			
+			int bottomY = FullDataPointUtil.getBottomY(fullData);
+			int blockHeight = FullDataPointUtil.getHeight(fullData);
+			int topY = bottomY + blockHeight;
+			int id = FullDataPointUtil.getId(fullData);
+			int blockLight = FullDataPointUtil.getBlockLight(fullData);
+			int skyLight = FullDataPointUtil.getSkyLight(fullData);
+			
+			IBiomeWrapper biome;
+			IBlockStateWrapper block;
+			try
+			{
+				biome = fullDataMapping.getBiomeWrapper(id);
+				block = fullDataMapping.getBlockStateWrapper(id);
+			}
+			catch (IndexOutOfBoundsException e)
+			{
+				if (!brokenPos.contains(fullDataMapping.getPos()))
+				{
+					brokenPos.add(fullDataMapping.getPos());
+					String dimName = level.getLevelWrapper().getDimensionName();
+					LOGGER.warn("Unable to get data point with id ["+id+"] " +
+							"(Max possible ID: ["+fullDataMapping.getMaxValidId()+"]) " +
+							"for pos ["+fullDataMapping.getPos()+"] in dimension ["+dimName+"]. " +
+							"Error: ["+e.getMessage()+"]. " +
+							"Further errors for this position won't be logged.");
+				}
+				
+				// don't render broken data
+				continue;
+			}
+			
+			
+			
+			//====================//
+			// ignored block and  //
+			// cave culling check //
+			//====================//
+			
+			boolean ignoreBlock = blockStatesToIgnore.contains(block);
+			boolean caveBlock = caveBlockStatesToIgnore.contains(block);
+			if (caveBlock)
+			{
+				if (caveCullingEnabled
+					// assume this data point is underground if it has no sky-light
+					&& skyLight == LodUtil.MIN_MC_LIGHT	
+					// ignore caves above a certain height to prevent floating islands from having walls underneath them
+					&& topY < caveCullingMaxY
+					// cave culling shouldn't happen when at the top of the world
+					&& renderDataIndex != 0 && fullDataIndex != 0
+					// cave culling can't happen when at the bottom of the world
+					&& (fullDataIndex+1) < fullColumnData.size())
+				{
+					// we need to get the next sky/block lights because
+					// the air block here will always have a light of 0/0 due to only the top of the LOD's light being saved.
+					long nextFullData = fullColumnData.getLong(fullDataIndex+1);
+					int nextSkyLight = FullDataPointUtil.getSkyLight(nextFullData);
+					
+					if (nextSkyLight == LodUtil.MIN_MC_LIGHT
+							&& ColorUtil.getAlpha(lastColor) == 255)
+					{
+						// replace the previous block with new bottom
+						long columnData = renderColumnData.get(renderDataIndex - 1);
+						columnData = RenderDataPointUtil.setYMin(columnData, bottomY);
+						renderColumnData.set(renderDataIndex - 1, columnData);
+					}
+					
+					continue;
+				}
+				
+				
+				if (ignoreBlock)
+				{
+					// this is a merged block and a cave block, so it should never be rendered
+					continue;
+				}
+			}
+			else if (ignoreBlock)
+			{
+				// this is an ignored block, but shouldn't be merged like a cave block
+				continue;
+			}
+			
+			
+			
+			//=======================//
+			// non-solid block check //
+			//=======================//
+			
+			if (ignoreNonCollidingBlocks 
+				&& !block.isSolid() && !block.isLiquid() && block.getOpacity() != LodUtil.BLOCK_FULLY_OPAQUE)
+			{
+				if (colorBelowWithAvoidedBlocks)
+				{
+					int tempColor = level.computeBaseColor(new DhBlockPos(blockX, bottomY + level.getMinY(), blockZ), biome, block);
+					// don't transfer the color when alpha is 0
+					// this prevents issues if grass is transparent
+					if (ColorUtil.getAlpha(tempColor) != 0)
+					{
+						colorToApplyToNextBlock = ColorUtil.setAlpha(tempColor,255);
+						skylightToApplyToNextBlock = skyLight;
+						blocklightToApplyToNextBlock = blockLight;
+					}
+				}
+				
+				// skip this non-colliding block
+				continue;
+			}
+			
+			
+			int color;
+			if (colorToApplyToNextBlock == -1)
+			{
+				// use this block's color
+				color = level.computeBaseColor(new DhBlockPos(blockX, bottomY + level.getMinY(), blockZ), biome, block);
+			}
+			else
+			{
+				// use the previous block's color
+				color = colorToApplyToNextBlock;
+				colorToApplyToNextBlock = -1;
+				skyLight = skylightToApplyToNextBlock;
+				blockLight = blocklightToApplyToNextBlock;
+			}
+			
+			
+			
+			//=============================//
+			// merge same-colored adjacent //
+			//=============================//
+			
+			// check if they share a top-bottom face and if they have same color
+			if (color == lastColor && bottomY + blockHeight == lastBottom  && renderDataIndex > 0)
+			{
+				//replace the previous block with new bottom
+				long columnData = renderColumnData.get(renderDataIndex - 1);
+				columnData = RenderDataPointUtil.setYMin(columnData, bottomY);
+				renderColumnData.set(renderDataIndex - 1, columnData);
+			}
+			else
+			{
+				// add the block
+				isColumnVoid = false;
+				long columnData = RenderDataPointUtil.createDataPoint(bottomY + blockHeight, bottomY, color, skyLight, blockLight, block.getMaterialId());
+				renderColumnData.set(renderDataIndex, columnData);
+				renderDataIndex++;
+			}
+			lastBottom = bottomY;
+			lastColor = color;
+		}
+		
+		
+		if (isColumnVoid)
+		{
+			renderColumnData.set(0, RenderDataPointUtil.EMPTY_DATA);
 		}
-		return columnSource;
 	}
 	
 	
@@ -158,168 +386,4 @@ public class FullDataToRenderDataTransformer
 		}
 	}
 	
-	
-	// TODO what does this mean?
-	private static void iterateAndConvert(
-			IDhClientLevel level, FullDataPointIdMap fullDataMapping, 
-			int blockX, int blockZ, 
-			ColumnArrayView renderColumnData, LongArrayList fullColumnData)
-	{
-		boolean avoidSolidBlocks = (Config.Client.Advanced.Graphics.Quality.blocksToIgnore.get() == EDhApiBlocksToAvoid.NON_COLLIDING);
-		boolean colorBelowWithAvoidedBlocks = Config.Client.Advanced.Graphics.Quality.tintWithAvoidedBlocks.get();
-		
-		HashSet<IBlockStateWrapper> blockStatesToIgnore = WRAPPER_FACTORY.getRendererIgnoredBlocks(level.getLevelWrapper());
-		
-		boolean isVoid = true;
-		int colorToApplyToNextBlock = -1;
-		int lastColor = 0;
-		int lastBottom = -10000;
-		int skylightToApplyToNextBlock = -1;
-		int blocklightToApplyToNextBlock = -1;
-		int columnOffset = 0;
-		
-		// goes from the top down
-		for (int i = 0; i < fullColumnData.size(); i++)
-		{
-			long fullData = fullColumnData.getLong(i);
-			int bottomY = FullDataPointUtil.getBottomY(fullData);
-			int blockHeight = FullDataPointUtil.getHeight(fullData);
-			int id = FullDataPointUtil.getId(fullData);
-			int blockLight = FullDataPointUtil.getBlockLight(fullData);
-			int skyLight = FullDataPointUtil.getSkyLight(fullData);
-			
-			// TODO how should corrupted data be handled?
-			// TODO why is the full data corrupted in the first place? FullDataPointUtil hasn't been changed in a long time, could one of the full data point objects be corrupted?
-			// TODO if either of these happen the ID might also be invalid
-			//if (bottomY + blockHeight > 300)
-			//{
-			//  // this data point is too tall, it's probably a monolith
-			//	int k = 0;
-			//	throw new RuntimeException();
-			//}
-			//if (light > 16 || light < 0)
-			//{
-			//  // light is out of range
-			//	throw new RuntimeException();
-			//}
-			
-			IBiomeWrapper biome;
-			IBlockStateWrapper block;
-			try
-			{
-				biome = fullDataMapping.getBiomeWrapper(id);
-				block = fullDataMapping.getBlockStateWrapper(id);
-			}
-			catch (IndexOutOfBoundsException e)
-			{
-				// FIXME sometimes the data map has a length of 0
-				if (!brokenPos.contains(fullDataMapping.getPos()))
-				{
-					brokenPos.add(fullDataMapping.getPos());
-					String dimName = level.getLevelWrapper().getDimensionType().getDimensionName();
-					LOGGER.warn("Unable to get data point with id ["+id+"] " +
-							"(Max possible ID: ["+fullDataMapping.getMaxValidId()+"]) " +
-							"for pos ["+fullDataMapping.getPos()+"] in dimension ["+dimName+"]. " +
-							"Error: ["+e.getMessage()+"]. " +
-							"Further errors for this position won't be logged.");
-				}
-				
-				// skip rendering broken data
-				continue;
-			}
-			
-			
-			if (blockStatesToIgnore.contains(block))
-			{
-				// Don't render: air, barriers, light blocks, etc.
-				continue;
-			}
-			
-			
-			// solid block check
-			if (avoidSolidBlocks && !block.isSolid() && !block.isLiquid() && block.getOpacity() != LodUtil.BLOCK_FULLY_OPAQUE)
-			{
-				if (colorBelowWithAvoidedBlocks)
-				{
-					int tempColor = level.computeBaseColor(new DhBlockPos(blockX, bottomY + level.getMinY(), blockZ), biome, block);
-					if (ColorUtil.getAlpha(tempColor) == 0)
-					{
-						//make sure to not transfer the color when alpha is 0
-						continue;
-					}
-					//mare sure to not trnasfer alpha if for some reason grass is semi transparent
-					colorToApplyToNextBlock = ColorUtil.setAlpha(tempColor,255);
-					skylightToApplyToNextBlock = skyLight;
-					blocklightToApplyToNextBlock = blockLight;
-				}
-				
-				// don't add this block
-				continue;
-			}
-			
-			
-			int color;
-			if (colorToApplyToNextBlock == -1)
-			{
-				// use this block's color
-				color = level.computeBaseColor(new DhBlockPos(blockX, bottomY + level.getMinY(), blockZ), biome, block);
-			}
-			else
-			{
-				// use the previous block's color
-				color = colorToApplyToNextBlock;
-				colorToApplyToNextBlock = -1;
-				skyLight = skylightToApplyToNextBlock;
-				blockLight = blocklightToApplyToNextBlock;
-			}
-
-			//check if they share a top-bottom face and if they have same collor
-			if (color == lastColor && bottomY + blockHeight == lastBottom  && columnOffset > 0)
-			{
-				//replace the previus block with new bottom
-				long columnData = renderColumnData.get(columnOffset - 1);
-				columnData = RenderDataPointUtil.setYMin(columnData, bottomY);
-				renderColumnData.set(columnOffset - 1, columnData);
-			}
-			else
-			{
-				// add the block
-				isVoid = false;
-				long columnData = RenderDataPointUtil.createDataPoint(bottomY + blockHeight, bottomY, color, skyLight, blockLight, block.getMaterialId());
-				renderColumnData.set(columnOffset, columnData);
-				columnOffset++;
-			}
-			lastBottom = bottomY;
-			lastColor = color;
-
-		}
-		
-		
-		if (isVoid)
-		{
-			renderColumnData.set(0, RenderDataPointUtil.createVoidDataPoint());
-		}
-	}
-	
-	// TODO what does this mean?
-	public static void convertColumnData(IDhClientLevel level, FullDataPointIdMap fullDataMapping, int blockX, int blockZ, ColumnArrayView columnArrayView, LongArrayList fullDataColumn)
-	{
-		if (fullDataColumn == null || fullDataColumn.size() == 0)
-		{
-			return;
-		}
-		
-		int dataTotalLength = fullDataColumn.size();
-		if (dataTotalLength > columnArrayView.verticalSize())
-		{
-			ColumnArrayView totalColumnData = new ColumnArrayView(new LongArrayList(new long[dataTotalLength]), dataTotalLength, 0, dataTotalLength);
-			iterateAndConvert(level, fullDataMapping, blockX, blockZ, totalColumnData, fullDataColumn);
-			columnArrayView.changeVerticalSizeFrom(totalColumnData);
-		}
-		else
-		{
-			iterateAndConvert(level, fullDataMapping, blockX, blockZ, columnArrayView, fullDataColumn); //Directly use the arrayView since it fits.
-		}
-	}
-	
 }

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/transformers/LodDataBuilder.java

@@ -19,6 +19,7 @@
 
 package com.seibel.distanthorizons.core.dataObjects.transformers;
 
+import java.util.Collections;
 import java.util.List;
 
 import com.seibel.distanthorizons.api.enums.config.EDhApiWorldCompressionMode;
@@ -30,14 +31,16 @@ import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSour
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
-import com.seibel.distanthorizons.core.pos.DhChunkPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPosMutable;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.util.FullDataPointUtil;
 import com.seibel.distanthorizons.core.util.LodUtil;
+import com.seibel.distanthorizons.core.util.RenderDataPointUtil;
 import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IMutableBlockPosWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
@@ -47,8 +50,6 @@ public class LodDataBuilder
 {
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	private static final IBlockStateWrapper AIR = SingletonInjector.INSTANCE.get(IWrapperFactory.class).getAirBlockStateWrapper();
-	/** how many chunks wide the {@link FullDataSourceV2} is. */
-	private static final int NUMB_OF_CHUNKS_WIDE = FullDataSourceV2.WIDTH / LodUtil.CHUNK_WIDTH;
 	
 	private static boolean getTopErrorLogged = false;
 	
@@ -58,21 +59,15 @@ public class LodDataBuilder
 	// converters //
 	//============//
 	
-	public static FullDataSourceV2 createGeneratedDataSource(IChunkWrapper chunkWrapper)
+	public static FullDataSourceV2 createFromChunk(IChunkWrapper chunkWrapper)
 	{
-		if (!canGenerateLodFromChunk(chunkWrapper))
-		{
-			return null;
-		}
+		// only block lighting is needed here, sky lighting is populated at the data source stage
+		LodUtil.assertTrue(chunkWrapper.isDhBlockLightingCorrect());
 		
 		
 		
-		// get the section position
-		int sectionPosX = chunkWrapper.getChunkPos().x;
-		// negative positions start at -1 so the logic there is slightly different
-		sectionPosX = (sectionPosX < 0) ? ((sectionPosX + 1) / NUMB_OF_CHUNKS_WIDE) - 1 : (sectionPosX / NUMB_OF_CHUNKS_WIDE);
-		int sectionPosZ = chunkWrapper.getChunkPos().z;
-		sectionPosZ = (sectionPosZ < 0) ? ((sectionPosZ + 1) / NUMB_OF_CHUNKS_WIDE) - 1 : (sectionPosZ / NUMB_OF_CHUNKS_WIDE);
+		int sectionPosX = getXOrZSectionPosFromChunkPos(chunkWrapper.getChunkPos().getX());
+		int sectionPosZ = getXOrZSectionPosFromChunkPos(chunkWrapper.getChunkPos().getZ());
 		long pos = DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, sectionPosX, sectionPosZ);
 		
 		FullDataSourceV2 dataSource = FullDataSourceV2.createEmpty(pos);
@@ -82,8 +77,8 @@ public class LodDataBuilder
 		
 		// compute the chunk dataSource offset
 		// this offset is used to determine where in the dataSource this chunk's data should go
-		int chunkOffsetX = chunkWrapper.getChunkPos().x;
-		if (chunkWrapper.getChunkPos().x < 0)
+		int chunkOffsetX = chunkWrapper.getChunkPos().getX();
+		if (chunkWrapper.getChunkPos().getX() < 0)
 		{
 			// expected offset positions:
 			// chunkPos -> offset
@@ -98,30 +93,30 @@ public class LodDataBuilder
 			// -3 -> 1
 			// -4 -> 0 ---
 			// -5 -> 3
-			chunkOffsetX = ((chunkOffsetX) % NUMB_OF_CHUNKS_WIDE);
+			chunkOffsetX = ((chunkOffsetX) % FullDataSourceV2.NUMB_OF_CHUNKS_WIDE);
 			if (chunkOffsetX != 0)
 			{
-				chunkOffsetX += NUMB_OF_CHUNKS_WIDE;
+				chunkOffsetX += FullDataSourceV2.NUMB_OF_CHUNKS_WIDE;
 			}
 		}
 		else
 		{
-			chunkOffsetX %= NUMB_OF_CHUNKS_WIDE;
+			chunkOffsetX %= FullDataSourceV2.NUMB_OF_CHUNKS_WIDE;
 		}
 		chunkOffsetX *= LodUtil.CHUNK_WIDTH;
 		
-		int chunkOffsetZ = chunkWrapper.getChunkPos().z;
-		if (chunkWrapper.getChunkPos().z < 0)
+		int chunkOffsetZ = chunkWrapper.getChunkPos().getZ();
+		if (chunkWrapper.getChunkPos().getZ() < 0)
 		{
-			chunkOffsetZ = ((chunkOffsetZ) % NUMB_OF_CHUNKS_WIDE);
+			chunkOffsetZ = ((chunkOffsetZ) % FullDataSourceV2.NUMB_OF_CHUNKS_WIDE);
 			if (chunkOffsetZ != 0)
 			{
-				chunkOffsetZ += NUMB_OF_CHUNKS_WIDE;
+				chunkOffsetZ += FullDataSourceV2.NUMB_OF_CHUNKS_WIDE;
 			}
 		}
 		else
 		{
-			chunkOffsetZ %= NUMB_OF_CHUNKS_WIDE;
+			chunkOffsetZ %= FullDataSourceV2.NUMB_OF_CHUNKS_WIDE;
 		}
 		chunkOffsetZ *= LodUtil.CHUNK_WIDTH;
 		
@@ -136,6 +131,9 @@ public class LodDataBuilder
 		
 		try
 		{
+			IMutableBlockPosWrapper mcBlockPos = chunkWrapper.getMutableBlockPosWrapper();
+			IBlockStateWrapper previousBlockState = null;
+			
 			int minBuildHeight = chunkWrapper.getMinNonEmptyHeight();
 			for (int relBlockX = 0; relBlockX < LodUtil.CHUNK_WIDTH; relBlockX++)
 			{
@@ -153,21 +151,21 @@ public class LodDataBuilder
 					if (lastY < chunkWrapper.getMaxBuildHeight())
 					{
 						// FIXME: The lastY +1 offset is to reproduce the old behavior. Remove this when we get per-face lighting
-						blockLight = (byte) chunkWrapper.getBlockLight(relBlockX, lastY + 1, relBlockZ);
-						skyLight = (byte) chunkWrapper.getSkyLight(relBlockX, lastY + 1, relBlockZ);
+						blockLight = (byte) chunkWrapper.getDhBlockLight(relBlockX, lastY + 1, relBlockZ);
+						skyLight = (byte) chunkWrapper.getDhSkyLight(relBlockX, lastY + 1, relBlockZ);
 					}
 					else
 					{
 						//we are at the height limit. There are no torches here, and sky is not obscured.
-						blockLight = 0;
-						skyLight = 15;
+						blockLight = LodUtil.MIN_MC_LIGHT;
+						skyLight = LodUtil.MAX_MC_LIGHT;
 					}
 					
 					
 					// determine the starting Y Pos
 					int y = chunkWrapper.getLightBlockingHeightMapValue(relBlockX, relBlockZ);
 					// go up until we reach open air or the world limit
-					IBlockStateWrapper topBlockState = chunkWrapper.getBlockState(relBlockX, y, relBlockZ);
+					IBlockStateWrapper topBlockState = previousBlockState = chunkWrapper.getBlockState(relBlockX, y, relBlockZ, mcBlockPos, previousBlockState);
 					while (!topBlockState.isAir() && y < chunkWrapper.getMaxBuildHeight())
 					{
 						try
@@ -175,7 +173,7 @@ public class LodDataBuilder
 							// This is necessary in some edge cases with snow layers and some other blocks that may not appear in the height map but do block light.
 							// Interestingly this doesn't appear to be the case in the DhLightingEngine, if this same logic is added there the lighting breaks for the affected blocks.
 							y++;
-							topBlockState = chunkWrapper.getBlockState(relBlockX, y, relBlockZ);
+							topBlockState = previousBlockState = chunkWrapper.getBlockState(relBlockX, y, relBlockZ, mcBlockPos, previousBlockState);
 						}
 						catch (Exception e)
 						{
@@ -194,9 +192,9 @@ public class LodDataBuilder
 					for (; y >= minBuildHeight; y--)
 					{
 						IBiomeWrapper newBiome = chunkWrapper.getBiome(relBlockX, y, relBlockZ);
-						IBlockStateWrapper newBlockState = chunkWrapper.getBlockState(relBlockX, y, relBlockZ);
-						byte newBlockLight = (byte) chunkWrapper.getBlockLight(relBlockX, y + 1, relBlockZ);
-						byte newSkyLight = (byte) chunkWrapper.getSkyLight(relBlockX, y + 1, relBlockZ);
+						IBlockStateWrapper newBlockState = previousBlockState = chunkWrapper.getBlockState(relBlockX, y, relBlockZ, mcBlockPos, previousBlockState);
+						byte newBlockLight = (byte) chunkWrapper.getDhBlockLight(relBlockX, y + 1, relBlockZ);
+						byte newSkyLight = (byte) chunkWrapper.getDhSkyLight(relBlockX, y + 1, relBlockZ);
 						
 						// save the biome/block change
 						if (!newBiome.equals(biome) || !newBlockState.equals(blockState))
@@ -242,7 +240,7 @@ public class LodDataBuilder
 	private static boolean blockVisible(IChunkWrapper chunkWrapper, int relBlockX, int blockY, int relBlockZ)
 	{
 		DhBlockPos originalBlockPos = new DhBlockPos(relBlockX,blockY,relBlockZ);
-		DhBlockPos testBlockPos = new DhBlockPos(relBlockX,blockY,relBlockZ);
+		final DhBlockPosMutable testBlockPos = new DhBlockPosMutable(relBlockX,blockY,relBlockZ);
 		
 		// up/down
 		if (blockInDirectionVisible(chunkWrapper, EDhDirection.UP, originalBlockPos, testBlockPos))
@@ -277,20 +275,20 @@ public class LodDataBuilder
 		
 		return false;
 	}
-	private static boolean blockInDirectionVisible(IChunkWrapper chunkWrapper, EDhDirection direction, DhBlockPos originalBlockPos, DhBlockPos testBlockPos)
+	private static boolean blockInDirectionVisible(IChunkWrapper chunkWrapper, EDhDirection direction, DhBlockPos originalBlockPos, DhBlockPosMutable testBlockPos)
 	{
 		originalBlockPos.mutateOffset(direction, testBlockPos);
 		
 		// if the block is next to the border of a chunk, assume it's visible
-		if (testBlockPos.x < 0 || testBlockPos.x >= LodUtil.CHUNK_WIDTH)
+		if (testBlockPos.getX() < 0 || testBlockPos.getX() >= LodUtil.CHUNK_WIDTH)
 		{
 			return true;
 		}
-		if (testBlockPos.z < 0 || testBlockPos.z >= LodUtil.CHUNK_WIDTH)
+		if (testBlockPos.getZ() < 0 || testBlockPos.getZ() >= LodUtil.CHUNK_WIDTH)
 		{
 			return true;
 		}
-		if (testBlockPos.y < chunkWrapper.getMinBuildHeight() || testBlockPos.y > chunkWrapper.getMaxBuildHeight())
+		if (testBlockPos.getY() < chunkWrapper.getMinBuildHeight() || testBlockPos.getY() > chunkWrapper.getMaxBuildHeight())
 		{
 			return true;
 		}
@@ -302,14 +300,27 @@ public class LodDataBuilder
 	
 	
 	/** @throws ClassCastException if an API user returns the wrong object type(s) */
-	public static FullDataSourceV2 createFromApiChunkData(DhApiChunk dataPoints) throws ClassCastException, DataCorruptedException
+	public static FullDataSourceV2 createFromApiChunkData(DhApiChunk apiChunk, boolean runAdditionalValidation) throws ClassCastException, DataCorruptedException, IllegalArgumentException
 	{
-		FullDataSourceV2 accessor = FullDataSourceV2.createEmpty(DhSectionPos.encode(new DhChunkPos(dataPoints.chunkPosX, dataPoints.chunkPosZ)));
-		for (int relZ = 0; relZ < LodUtil.CHUNK_WIDTH; relZ++)
+		// get the section position
+		int sectionPosX = getXOrZSectionPosFromChunkPos(apiChunk.chunkPosX);
+		int sectionPosZ = getXOrZSectionPosFromChunkPos(apiChunk.chunkPosZ);
+		long pos = DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, sectionPosX, sectionPosZ);
+		
+		// chunk relative block position in the data source
+		int relSourceBlockX = Math.floorMod(apiChunk.chunkPosX, 4) * LodUtil.CHUNK_WIDTH;
+		int relSourceBlockZ = Math.floorMod(apiChunk.chunkPosZ, 4) * LodUtil.CHUNK_WIDTH;
+		
+		FullDataSourceV2 dataSource = FullDataSourceV2.createEmpty(pos);
+		for (int relBlockZ = 0; relBlockZ < LodUtil.CHUNK_WIDTH; relBlockZ++)
 		{
-			for (int relX = 0; relX < LodUtil.CHUNK_WIDTH; relX++)
+			for (int relBlockX = 0; relBlockX < LodUtil.CHUNK_WIDTH; relBlockX++)
 			{
-				List<DhApiTerrainDataPoint> columnDataPoints = dataPoints.getDataPoints(relX, relZ);
+				List<DhApiTerrainDataPoint> columnDataPoints = apiChunk.getDataPoints(relBlockX, relBlockZ);
+				if (runAdditionalValidation)
+				{
+					validateOrThrowDataColumn(columnDataPoints);
+				}
 				
 				
 				// this null check does 2 nice things at the same time:
@@ -318,12 +329,14 @@ public class LodDataBuilder
 				// AND the below loop won't run.
 				int size = (columnDataPoints != null) ? columnDataPoints.size() : 0;
 				
+				// TODO make missing air LODs
+				// TODO merge duplicate datapoints
 				LongArrayList packedDataPoints = new LongArrayList(new long[size]);
 				for (int index = 0; index < size; index++)
 				{
 					DhApiTerrainDataPoint dataPoint = columnDataPoints.get(index);
 					
-					int id = accessor.mapping.addIfNotPresentAndGetId(
+					int id = dataSource.mapping.addIfNotPresentAndGetId(
 							(IBiomeWrapper) (dataPoint.biomeWrapper),
 							(IBlockStateWrapper) (dataPoint.blockStateWrapper)
 					);
@@ -331,7 +344,7 @@ public class LodDataBuilder
 					packedDataPoints.set(index, FullDataPointUtil.encode(
 							id,
 							dataPoint.topYBlockPos - dataPoint.bottomYBlockPos,
-							dataPoint.bottomYBlockPos - dataPoints.topYBlockPos,
+							dataPoint.bottomYBlockPos - apiChunk.bottomYBlockPos,
 							(byte) (dataPoint.blockLightLevel),
 							(byte) (dataPoint.skyLightLevel)
 					));
@@ -339,12 +352,84 @@ public class LodDataBuilder
 				
 				// TODO add the ability for API users to define a different compression mode
 				//  or add a "unkown" compression mode
-				accessor.setSingleColumn(packedDataPoints, relX, relZ, EDhApiWorldGenerationStep.LIGHT, EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS);
+				dataSource.setSingleColumn(
+						packedDataPoints, 
+						relBlockX + relSourceBlockX, relBlockZ + relSourceBlockZ, 
+						EDhApiWorldGenerationStep.LIGHT, EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS);
+				dataSource.isEmpty = false;
 			}
 		}
-		
-		return accessor;
+		return dataSource;
 	}
+	private static void validateOrThrowDataColumn(List<DhApiTerrainDataPoint> dataPoints) throws IllegalArgumentException
+	{
+		// order doesn't need to be checked if there is 0 or 1 items
+		if (dataPoints.size() > 1)
+		{
+			// DH expects datapoints to be in a top-down order
+			DhApiTerrainDataPoint first = dataPoints.get(0);
+			DhApiTerrainDataPoint last = dataPoints.get(dataPoints.size() - 1);
+			if (first.bottomYBlockPos < last.bottomYBlockPos)
+			{
+				// flip the array if it's in bottom-up order
+				Collections.reverse(dataPoints);
+			}
+			
+		}
+		
+		
+		
+		// check that each datapoint is valid
+		int lastBottomYPos = Integer.MIN_VALUE;
+		for (int i = 0; i < dataPoints.size(); i++) // standard for-loop used instead of an enhanced for-loop to slightly reduce GC overhead due to iterator allocation
+		{
+			DhApiTerrainDataPoint dataPoint = dataPoints.get(i);
+			
+			if (dataPoint == null)
+			{
+				throw new IllegalArgumentException("Datapoint: ["+i+"] is null DhApiTerrainDataPoints are not allowed. If you want to represent empty terrain, please use AIR.");
+			}
+			
+			if (dataPoint.detailLevel != 0)
+			{
+				throw new IllegalArgumentException("Datapoint: ["+i+"] has the wrong detail level ["+dataPoint.detailLevel+"], all data points must be block sized; IE their detail level must be [0].");
+			}
+			
+			
+			
+			int bottomYPos = dataPoint.bottomYBlockPos;
+			int topYPos = dataPoint.topYBlockPos;
+			int height = (dataPoint.topYBlockPos - dataPoint.bottomYBlockPos);
+			
+			// is the datapoint right side up?
+			if (bottomYPos > topYPos)
+			{
+				throw new IllegalArgumentException("Datapoint: ["+i+"] is upside down. Top Pos: ["+topYPos+"], bottom pos: ["+bottomYPos+"].");
+			}
+			// valid height?
+			if (height <= 0 || height >= RenderDataPointUtil.MAX_WORLD_Y_SIZE)
+			{
+				throw new IllegalArgumentException("Datapoint: ["+i+"] has invalid height. Height must be in the range [1 - "+RenderDataPointUtil.MAX_WORLD_Y_SIZE+"] (inclusive).");
+			}
+			
+			// is this datapoint overlapping the last one?
+			if (lastBottomYPos > topYPos)
+			{
+				throw new IllegalArgumentException("DhApiTerrainDataPoint ["+i+"] is overlapping with the last datapoint, this top Y: ["+topYPos+"], lastBottomYPos: ["+lastBottomYPos+"].");
+			}
+			// is there a gap between the last datapoint?
+			if (topYPos != lastBottomYPos
+				&& lastBottomYPos != Integer.MIN_VALUE)
+			{
+				throw new IllegalArgumentException("DhApiTerrainDataPoint ["+i+"] has a gap between it and index ["+(i-1)+"]. Empty spaces should be filled by air, otherwise DH's downsampling won't calculate lighting correctly.");
+			}
+			
+			
+			lastBottomYPos = bottomYPos; 
+		}
+		
+	}
+	
 	
 	
 	
@@ -352,6 +437,13 @@ public class LodDataBuilder
 	// helper methods //
 	//================//
 	
-	public static boolean canGenerateLodFromChunk(IChunkWrapper chunk) { return chunk != null && chunk.isLightCorrect(); }
+	public static int getXOrZSectionPosFromChunkPos(int chunkXOrZPos)
+	{
+		// get the section position
+		int sectionPos = chunkXOrZPos;
+		// negative positions start at -1 so the logic there is slightly different
+		sectionPos = (sectionPos < 0) ? ((sectionPos + 1) / FullDataSourceV2.NUMB_OF_CHUNKS_WIDE) - 1 : (sectionPos / FullDataSourceV2.NUMB_OF_CHUNKS_WIDE);
+		return sectionPos;
+	}
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/file/AbstractDataSourceHandler.java

@@ -46,7 +46,7 @@ public abstract class AbstractDataSourceHandler
 	 * The lowest numerical detail level possible. 
 	 *
 	 * @see AbstractDataSourceHandler#TOP_SECTION_DETAIL_LEVEL
-	 * */
+	 */
 	public static final byte MIN_SECTION_DETAIL_LEVEL = DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL;
 	
 	
@@ -223,7 +223,8 @@ public abstract class AbstractDataSourceHandler
 	
 	/** 
 	 * After this method returns the inputData will be written to file.
-	 * @param updatePos the position to update 
+	 *
+	 * @param updatePos the position to update
 	 */
 	protected void updateDataSourceAtPos(long updatePos, @NotNull FullDataSourceV2 inputData, boolean lockOnUpdatePos)
 	{

core/src/main/java/com/seibel/distanthorizons/core/file/fullDatafile/FullDataSourceProviderV2.java

@@ -21,6 +21,7 @@ package com.seibel.distanthorizons.core.file.fullDatafile;
 
 import com.seibel.distanthorizons.api.enums.config.EDhApiDataCompressionMode;
 import com.seibel.distanthorizons.core.api.internal.ClientApi;
+import com.seibel.distanthorizons.core.api.internal.SharedApi;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV1;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
@@ -37,6 +38,7 @@ import com.seibel.distanthorizons.core.sql.repo.FullDataSourceV2Repo;
 import com.seibel.distanthorizons.core.util.ThreadUtil;
 import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
 import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
+import com.seibel.distanthorizons.core.world.EWorldEnvironment;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import org.apache.logging.log4j.Logger;
@@ -45,11 +47,14 @@ import org.jetbrains.annotations.Nullable;
 import java.awt.*;
 import java.io.File;
 import java.io.IOException;
+import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.util.*;
+import java.util.List;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.Collectors;
 
 /**
  * Handles reading/writing {@link FullDataSourceV2} 
@@ -102,9 +107,14 @@ public class FullDataSourceProviderV2
 	
 	// TODO only run thread if modifications happened recently
 	/** 
-	 * This isn't in {@link AbstractDataSourceHandler} since we don't need parent updating logic
-	 * for render data, only full data.
+	 * This isn't in {@link AbstractDataSourceHandler} since we only want to update
+	 * the newest version of the full data, so if we have providers for either
+	 * render data or old full data, we don't want to update them. <br><br>
+	 * 
+	 * Will be null on the dedicated server since updates don't need to be propagated,
+	 * only the highest detail level is needed.
 	 */
+	@Nullable
 	private final ThreadPoolExecutor updateQueueProcessor;
 	
 	
@@ -121,14 +131,22 @@ public class FullDataSourceProviderV2
 		
 		DebugRenderer.register(this, Config.Client.Advanced.Debugging.DebugWireframe.showFullDataUpdateStatus);
 		
-		String dimensionName = level.getLevelWrapper().getDimensionType().getDimensionName();
+		String dimensionName = level.getLevelWrapper().getDimensionName();
 		
 		// start migrating any legacy data sources present in the background
-		this.migrationThreadPool = ThreadUtil.makeRateLimitedThreadPool(1, MIGRATION_THREAD_NAME_PREFIX +"["+dimensionName+"]", Config.Client.Advanced.MultiThreading.runTimeRatioForUpdatePropagatorThreads.get(), Thread.MIN_PRIORITY, (Semaphore)null);
-		this.migrationThreadPool.execute(() -> this.convertLegacyDataSources());
+		this.migrationThreadPool = ThreadUtil.makeRateLimitedThreadPool(1, MIGRATION_THREAD_NAME_PREFIX + "["+dimensionName+"]", Config.Client.Advanced.MultiThreading.runTimeRatioForUpdatePropagatorThreads.get(), Thread.MIN_PRIORITY, (Semaphore) null);
+		this.migrationThreadPool.execute(this::convertLegacyDataSources);
 		
-		this.updateQueueProcessor = ThreadUtil.makeSingleThreadPool("Parent Update Queue ["+dimensionName+"]");
-		this.updateQueueProcessor.execute(() -> this.runUpdateQueue());
+		// update propagation doesn't need to be run on the server since only the highest detail level is needed
+		if (SharedApi.getEnvironment() != EWorldEnvironment.Server_Only)
+		{
+			this.updateQueueProcessor = ThreadUtil.makeSingleThreadPool("Parent Update Queue ["+dimensionName+"]");
+			this.updateQueueProcessor.execute(this::runUpdateQueue);
+		}
+		else
+		{
+			this.updateQueueProcessor = null;
+		}
 	}
 	
 	
@@ -289,7 +307,8 @@ public class FullDataSourceProviderV2
 								}
 							});
 						}
-						catch (RejectedExecutionException ignore) { /* the executor was shut down, it should be back up shortly and able to accept new jobs */ }
+						catch (RejectedExecutionException ignore)
+						{ /* the executor was shut down, it should be back up shortly and able to accept new jobs */ }
 						catch (Exception e)
 						{
 							this.parentUpdatingPosSet.remove(parentUpdatePos);
@@ -299,7 +318,10 @@ public class FullDataSourceProviderV2
 				}
 				
 			}
-			catch (InterruptedException ignored) { Thread.currentThread().interrupt(); }
+			catch (InterruptedException ignored)
+			{
+				Thread.currentThread().interrupt();
+			}
 			catch (Exception e)
 			{
 				LOGGER.error("Unexpected error in the parent update queue thread. Error: " + e.getMessage(), e);
@@ -317,7 +339,7 @@ public class FullDataSourceProviderV2
 	
 	private void convertLegacyDataSources()
 	{
-		String dimensionName = this.level.getLevelWrapper().getDimensionType().getDimensionName();
+		String dimensionName = this.level.getLevelWrapper().getDimensionName();
 		LOGGER.info("Attempting to migrate data sources for: ["+dimensionName+"]-["+this.saveDir+"]...");
 		
 		
@@ -339,7 +361,7 @@ public class FullDataSourceProviderV2
 			
 			LOGGER.info("deleting [" + dimensionName + "] - ["+totalDeleteCount+"] unused data sources...");
 			this.legacyDeletionCount = totalDeleteCount;
-
+			
 			ArrayList<String> unusedDataPosList = this.legacyFileHandler.repo.getUnusedDataSourcePositionStringList(50);
 			while (unusedDataPosList.size() != 0)
 			{
@@ -368,8 +390,8 @@ public class FullDataSourceProviderV2
 				}
 				catch (InterruptedException ignore){}
 			}
-
 			LOGGER.info("Done deleting [" + dimensionName + "] - ["+totalDeleteCount+"] unused data sources.");
+			
 		}
 		
 		
@@ -420,9 +442,7 @@ public class FullDataSourceProviderV2
 								{
 									newDataSource.close();
 								}
-								catch (Exception ignore)
-								{
-								}
+								catch (Exception ignore) { }
 							});
 						}
 						catch (Exception e)
@@ -498,7 +518,7 @@ public class FullDataSourceProviderV2
 		}
 		this.migrationStartMessageQueued = true;
 		
-		String dimName = this.level.getLevelWrapper().getDimensionType().getDimensionName();
+		String dimName = this.level.getLevelWrapper().getDimensionName();
 		ClientApi.INSTANCE.showChatMessageNextFrame(
 				"Old Distant Horizons data is being migrated for ["+dimName+"]. \n" +
 				"While migrating LODs may load slowly \n" +
@@ -509,7 +529,7 @@ public class FullDataSourceProviderV2
 	
 	private void showMigrationEndMessage(boolean success)
 	{
-		String dimName = this.level.getLevelWrapper().getDimensionType().getDimensionName();
+		String dimName = this.level.getLevelWrapper().getDimensionName();
 		
 		if (success)
 		{
@@ -553,8 +573,8 @@ public class FullDataSourceProviderV2
 	 *      return false; <br>
 	 * } <br>
 	 * </code>
-	 *  to the beginning of your override.
-	 *  Otherwise, parent retrieval limits will be ignored.
+	 * to the beginning of your override.
+	 * Otherwise, parent retrieval limits will be ignored.
 	 */
 	public boolean canQueueRetrieval()
 	{
@@ -569,13 +589,13 @@ public class FullDataSourceProviderV2
 	 * an empty array if all positions were generated 
 	 */
 	@Nullable
-	public LongArrayList getPositionsToRetrieve(Long pos)  { return null; }
+	public LongArrayList getPositionsToRetrieve(Long pos) { return null; }
 	/**
 	 * Returns how many positions could potentially be generated for this position assuming the position is empty.
 	 * Used when estimating the total number of retrieval requests.
 	 */
-	public int getMaxPossibleRetrievalPositionCountForPos(Long pos)  { return -1; }
-
+	public int getMaxPossibleRetrievalPositionCountForPos(Long pos) { return -1; }
+	
 	/** @return true if the position was queued, false if not */
 	public boolean queuePositionForRetrieval(Long genPos) { return false; }
 	
@@ -585,7 +605,7 @@ public class FullDataSourceProviderV2
 	public void clearRetrievalQueue() { }
 	
 	/** Can be used to display how many total retrieval requests might be available. */
-	public void setTotalRetrievalPositionCount(int newCount) {  }
+	public void setTotalRetrievalPositionCount(int newCount) { }
 	
 	/** 
 	 * Returns how many data sources are currently in memory and haven't
@@ -594,6 +614,20 @@ public class FullDataSourceProviderV2
 	 */
 	public int getUnsavedDataSourceCount() { return -1; }
 	
+	public boolean fileExists(long pos) { return this.repo.getDataSizeInBytes(pos) > 0; }
+	
+	
+	
+	//========================//
+	// multiplayer networking //
+	//========================//
+	
+	@Nullable
+	public Long getTimestampForPos(long pos)
+	{ return this.repo.getTimestampForPos(pos); }
+	public Map<Long, Long> getTimestampsForRange(byte detailLevel, int startPosX, int startPosZ, int endPosX, int endPosZ)
+	{ return this.repo.getTimestampsForRange(detailLevel, startPosX, startPosZ, endPosX, endPosZ); }
+	
 	
 	
 	//===========//
@@ -616,7 +650,10 @@ public class FullDataSourceProviderV2
 	public void close()
 	{
 		super.close();
-		this.updateQueueProcessor.shutdownNow();
+		if (this.updateQueueProcessor != null)
+		{
+			this.updateQueueProcessor.shutdownNow();
+		}
 		
 		this.legacyFileHandler.close();
 		

core/src/main/java/com/seibel/distanthorizons/core/file/fullDatafile/GeneratedFullDataSourceProvider.java

@@ -23,6 +23,7 @@ import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiWorldGeneratio
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.file.structure.AbstractSaveStructure;
+import com.seibel.distanthorizons.core.generation.DhLightingEngine;
 import com.seibel.distanthorizons.core.generation.IFullDataSourceRetrievalQueue;
 import com.seibel.distanthorizons.core.generation.tasks.IWorldGenTaskTracker;
 import com.seibel.distanthorizons.core.generation.tasks.WorldGenResult;
@@ -36,12 +37,15 @@ import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
 import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.Nullable;
 
 import java.awt.*;
+import java.io.File;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
+import java.util.stream.IntStream;
 
 public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 implements IDebugRenderable
 {
@@ -70,6 +74,7 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	//=============//
 	
 	public GeneratedFullDataSourceProvider(IDhLevel level, AbstractSaveStructure saveStructure) { super(level, saveStructure); }
+	public GeneratedFullDataSourceProvider(IDhLevel level, AbstractSaveStructure saveStructure, @Nullable File saveDirOverride) { super(level, saveStructure, saveDirOverride); }
 	
 	
 	
@@ -93,7 +98,7 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 			// don't log shutdown exceptions
 			if (!(exception instanceof CancellationException || exception.getCause() instanceof CancellationException))
 			{
-				LOGGER.error("Uncaught Gen Task Exception at [" + genTaskResult.pos + "], error: ["+ exception.getMessage() + "].", exception);
+				LOGGER.error("Uncaught Gen Task Exception at ["+genTaskResult.pos+"], error: ["+exception.getMessage()+"].", exception);
 			}
 		}
 		else if (genTaskResult.success)
@@ -139,7 +144,7 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	{
 		boolean oldQueueExists = this.worldGenQueueRef.compareAndSet(null, newWorldGenQueue);
 		LodUtil.assertTrue(oldQueueExists, "previous world gen queue is still here!");
-		LOGGER.info("Set world gen queue for level ["+this.level+"].");
+		LOGGER.info("Set world gen queue for level [" + this.level.getLevelWrapper().getDimensionName() + "].");
 	}
 	
 	@Override
@@ -214,7 +219,7 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 		}
 		
 		GenTask genTask = new GenTask(genPos);
-		CompletableFuture<WorldGenResult> worldGenFuture = worldGenQueue.submitGenTask(genPos, (byte) (DhSectionPos.getDetailLevel(genPos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL), genTask);
+		CompletableFuture<WorldGenResult> worldGenFuture = worldGenQueue.submitRetrievalTask(genPos, (byte) (DhSectionPos.getDetailLevel(genPos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL), genTask);
 		worldGenFuture.whenComplete((genTaskResult, ex) -> this.onWorldGenTaskComplete(genTaskResult, ex));
 		
 		return true;
@@ -237,6 +242,12 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	public int getUnsavedDataSourceCount() { return this.delayedFullDataSourceSaveCache.getUnsavedCount(); }
 	
 	
+	public boolean isFullyGenerated(byte[] columnGenerationSteps)
+	{
+		return IntStream.range(0, columnGenerationSteps.length)
+				.noneMatch(i -> columnGenerationSteps[i] == EDhApiWorldGenerationStep.EMPTY.value);
+	}
+	
 	@Override
 	public LongArrayList getPositionsToRetrieve(Long pos)
 	{
@@ -385,16 +396,24 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 		public boolean isMemoryAddressValid() { return true; }
 		
 		@Override
-		public Consumer<FullDataSourceV2> getChunkDataConsumer()
+		public Consumer<FullDataSourceV2> getDataSourceConsumer()
 		{
 			return (chunkSizedFullDataSource) ->
 			{
 				GeneratedFullDataSourceProvider.this.delayedFullDataSourceSaveCache.queueDataSourceForUpdateAndSave(chunkSizedFullDataSource);
 			};
 		}
+		
 	}
 	private void onDataSourceSave(FullDataSourceV2 fullDataSource) 
-	{ GeneratedFullDataSourceProvider.this.updateDataSourceAsync(fullDataSource); }
+	{
+		// block lights should have been populated at the chunkWrapper stage
+		// waiting to populate the data source's skylight at this stage prevents re-lighting and
+		// allows us to reduce cross-chunk lighting issues by lighting the whole 4x4 LOD at once
+		DhLightingEngine.INSTANCE.bakeDataSourceSkyLight(fullDataSource, LodUtil.MAX_MC_LIGHT);
+		
+		GeneratedFullDataSourceProvider.this.updateDataSourceAsync(fullDataSource); 
+	}
 	
 	
 	

core/src/main/java/com/seibel/distanthorizons/core/file/fullDatafile/RemoteFullDataSourceProvider.java

@@ -19,15 +19,119 @@
 
 package com.seibel.distanthorizons.core.file.fullDatafile;
 
+import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.file.structure.AbstractSaveStructure;
+import com.seibel.distanthorizons.core.generation.RemoteWorldRetrievalQueue;
 import com.seibel.distanthorizons.core.level.IDhLevel;
+import com.seibel.distanthorizons.core.level.WorldGenModule;
+import com.seibel.distanthorizons.core.multiplayer.client.SyncOnLoginRequestQueue;
+import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
-public class RemoteFullDataSourceProvider extends FullDataSourceProviderV2
+/**
+ * Only handles {@link SyncOnLoginRequestQueue} requests (IE updating existing LODs based on a timestamp).
+ * Missing data is handled by {@link WorldGenModule} and {@link RemoteWorldRetrievalQueue}.
+ */
+public class RemoteFullDataSourceProvider extends GeneratedFullDataSourceProvider
 {
-	public RemoteFullDataSourceProvider(IDhLevel level, AbstractSaveStructure saveStructure) { super(level, saveStructure); }
-	public RemoteFullDataSourceProvider(IDhLevel level, AbstractSaveStructure saveStructure, @Nullable File saveDirOverride) { super(level, saveStructure, saveDirOverride); }
+	@Nullable
+	private final SyncOnLoginRequestQueue syncOnLoginRequestQueue;
+	private final Set<Long> finishedTaskPositions = ConcurrentHashMap.newKeySet();
 	
-}
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public RemoteFullDataSourceProvider(
+			IDhLevel level, AbstractSaveStructure saveStructure, @Nullable File saveDirOverride, 
+			@Nullable SyncOnLoginRequestQueue syncOnLoginRequestQueue)
+	{
+		super(level, saveStructure, saveDirOverride);
+		this.syncOnLoginRequestQueue = syncOnLoginRequestQueue;
+	}
+	
+	
+	
+	//==================//
+	// override methods //
+	//==================//
+	
+	@Override
+	@Nullable
+	public FullDataSourceV2 get(long pos)
+	{
+		//=======================//
+		// get local data source //
+		//=======================//
+		
+		FullDataSourceV2 fullDataSource = super.get(pos);
+		if (fullDataSource == null)
+		{
+			// we don't have any local data for this position,
+			// we can't queue updates based on a timestamp
+			return null;	
+		}
+		
+		if (this.syncOnLoginRequestQueue == null)
+		{
+			// we have local data, but aren't allowed to
+			// request timestamp updates from the server.
+			return fullDataSource;
+		}
+		
+		
+		
+		//===========================//
+		// request timestamp updates //
+		// from server               //
+		//===========================//
+		
+		// get the timestamp for every maximum detail position in this section
+		int posToMinimumDetailScale = (DhSectionPos.getDetailLevel(pos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL + 1);
+		Map<Long, Long> timestamps = this.getTimestampsForRange(
+				DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL,
+				DhSectionPos.getX(pos) * posToMinimumDetailScale,
+				DhSectionPos.getZ(pos) * posToMinimumDetailScale,
+				(DhSectionPos.getX(pos) + 1) * posToMinimumDetailScale - 1,
+				(DhSectionPos.getZ(pos) + 1) * posToMinimumDetailScale - 1
+		);
+		
+		// check if the server has newer versions of these LODs
+		for (Map.Entry<Long, Long> timestampBySectionPos : timestamps.entrySet())
+		{
+			Long subPos = timestampBySectionPos.getKey();
+			Long subTimestamp = timestampBySectionPos.getValue();
+			
+			if (this.finishedTaskPositions.add(subPos))
+			{
+				this.syncOnLoginRequestQueue.submitRequest(subPos, subTimestamp, this.delayedFullDataSourceSaveCache::queueDataSourceForUpdateAndSave);
+			}
+		}
+		
+		return fullDataSource;
+	}
+	
+	
+	
+	//==========//
+	// shutdown //
+	//==========//
+	
+	@Override
+	public void close()
+	{
+		if (this.syncOnLoginRequestQueue != null)
+		{
+			this.syncOnLoginRequestQueue.close();
+		}
+		super.close();
+	}
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/file/structure/ClientOnlySaveStructure.java

@@ -26,12 +26,11 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.api.enums.config.EDhApiServerFolderNameMode;
 import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel;
 import com.seibel.distanthorizons.core.util.objects.ParsedIp;
-import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
-import com.seibel.distanthorizons.core.wrapperInterfaces.world.IDimensionTypeWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
+import com.seibel.distanthorizons.coreapi.util.StringUtil;
 
 import java.io.File;
 import java.util.*;
@@ -41,13 +40,17 @@ import java.util.*;
  */
 public class ClientOnlySaveStructure extends AbstractSaveStructure
 {
-	final File folder;
-	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
-	private static final IMinecraftSharedWrapper MC_SHARED = SingletonInjector.INSTANCE.get(IMinecraftSharedWrapper.class);
+	public static final String SERVER_DATA_FOLDER_NAME = "Distant_Horizons_server_data";
+	public static final String REPLAY_SERVER_FOLDER_NAME = "REPLAY";
 	public static final String INVALID_FILE_CHARACTERS_REGEX = "[\\\\/:*?\"<>|]";
 	
-	SubDimensionLevelMatcher subDimMatcher = null;
-	final HashMap<ILevelWrapper, File> levelWrapperToFileMap = new HashMap<>();
+	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
+	private static final IMinecraftSharedWrapper MC_SHARED = SingletonInjector.INSTANCE.get(IMinecraftSharedWrapper.class);
+	
+	
+	private SubDimensionLevelMatcher subDimMatcher = null;
+	private final File folder;
+	private final HashMap<ILevelWrapper, File> levelWrapperToFileMap = new HashMap<>();
 	
 	
 	
@@ -84,9 +87,9 @@ public class ClientOnlySaveStructure extends AbstractSaveStructure
 			if (newLevelWrapper instanceof IServerKeyedClientLevel)
 			{
 				IServerKeyedClientLevel keyedClientLevel = (IServerKeyedClientLevel) newLevelWrapper;
-				LOGGER.info("Loading level " + newLevelWrapper.getDimensionType().getDimensionName() + " with key: " + keyedClientLevel.getServerLevelKey());
+				LOGGER.info("Loading level " + newLevelWrapper.getDimensionName() + " with key: " + keyedClientLevel.getServerLevelKey());
 				// This world was identified by the server directly, so we can know for sure which folder to use.
-				return new File(getSaveStructureFolderPath() + File.separatorChar + keyedClientLevel.getServerLevelKey());
+				return new File(getSaveStructureFolderPath() + File.separatorChar + keyedClientLevel.getServerLevelKey().replaceAll(":", "@@"));
 			}
 			
 			
@@ -98,9 +101,9 @@ public class ClientOnlySaveStructure extends AbstractSaveStructure
 				// create the matcher if one doesn't exist
 				if (this.subDimMatcher == null || !this.subDimMatcher.isFindingLevel(newClientLevelWrapper))
 				{
-					LOGGER.info("Loading level " + newClientLevelWrapper.getDimensionType().getDimensionName());
+					LOGGER.info("Loading level " + newClientLevelWrapper.getDimensionName());
 					
-					List<File> levelFolders = this.getDhDataFoldersForDimension(newClientLevelWrapper.getDimensionType());
+					List<File> levelFolders = this.getDhDataFoldersForLevel(newClientLevelWrapper);
 					this.subDimMatcher = new SubDimensionLevelMatcher(newClientLevelWrapper, this.folder, levelFolders);
 				}
 				
@@ -129,23 +132,23 @@ public class ClientOnlySaveStructure extends AbstractSaveStructure
 	
 	private File getLevelFolderWithoutSimilarityMatching(ILevelWrapper level)
 	{
-		List<File> folders = this.getDhDataFoldersForDimension(level.getDimensionType());
+		List<File> folders = this.getDhDataFoldersForLevel(level);
 		if (!folders.isEmpty() && folders.get(0) != null)
 		{
 			// use the first existing sub-dimension
 			String folderName = folders.get(0).getName();
-			LOGGER.info("Default Sub Dimension set to: [" + LodUtil.shortenString(folderName, 8) + "...]");
+			LOGGER.info("Default Sub Dimension set to: [" + StringUtil.shortenString(folderName, 8) + "...]");
 			return folders.get(0);
 		}
 		else
 		{
 			// no valid sub dimension was found, create a new one
-			LOGGER.info("Default Sub Dimension not found. Creating: [" + level.getDimensionType().getDimensionName() + "]");
-			return new File(this.folder, level.getDimensionType().getDimensionName());
+			LOGGER.info("Default Sub Dimension not found. Creating: [" + level.getDimensionName() + "]");
+			return new File(this.folder, level.getDimensionName().replaceAll(":", "@@"));
 		}
 	}
 	
-	public List<File> getDhDataFoldersForDimension(IDimensionTypeWrapper dimensionType)
+	public List<File> getDhDataFoldersForLevel(ILevelWrapper level)
 	{
 		File[] folders = this.folder.listFiles();
 		if (folders == null)
@@ -154,7 +157,7 @@ public class ClientOnlySaveStructure extends AbstractSaveStructure
 		}
 		
 		// filter by dimension name
-		String expectedDimName = dimensionType.getDimensionName();
+		String expectedDimName = level.getDimensionName();
 		ArrayList<File> possibleDimFolders = new ArrayList<>();
 		for (File dimFolder : folders)
 		{
@@ -237,7 +240,7 @@ public class ClientOnlySaveStructure extends AbstractSaveStructure
 	private static String getSaveStructureFolderPath()
 	{
 		String path = MC_SHARED.getInstallationDirectory().getPath() + File.separatorChar
-				+ "Distant_Horizons_server_data" + File.separatorChar
+				+ SERVER_DATA_FOLDER_NAME + File.separatorChar
 				+ getServerFolderName();
 		return path;
 	}
@@ -245,6 +248,14 @@ public class ClientOnlySaveStructure extends AbstractSaveStructure
 	/** Generated from the server the client is currently connected to. */
 	private static String getServerFolderName()
 	{
+		// if connected to a replay we won't have any server info
+		// use the dedicated replay server folder
+		if (MC_CLIENT.connectedToReplay())
+		{
+			return REPLAY_SERVER_FOLDER_NAME;
+		}
+		
+		
 		// parse the current server's IP
 		ParsedIp parsedIp = new ParsedIp(MC_CLIENT.getCurrentServerIp());
 		String serverIpCleaned = parsedIp.ip.replaceAll(INVALID_FILE_CHARACTERS_REGEX, "");

core/src/main/java/com/seibel/distanthorizons/core/file/subDimMatching/SubDimensionLevelMatcher.java

@@ -40,6 +40,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftCli
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
+import com.seibel.distanthorizons.coreapi.util.StringUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import org.apache.logging.log4j.LogManager;
 
@@ -59,6 +60,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
  * @author James Seibel
  * @version 12-17-2022
  */
+@Deprecated
 public class SubDimensionLevelMatcher implements AutoCloseable
 {
 	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
@@ -92,7 +94,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		if (potentialLevelFolders.size() == 0)
 		{
 			String newId = UUID.randomUUID().toString();
-			LOGGER.info("No potential level files found. Creating a new sub dimension with the ID ["+LodUtil.shortenString(newId, 8)+"]...");
+			LOGGER.info("No potential level files found. Creating a new sub dimension with the ID ["+ StringUtil.shortenString(newId, 8)+"]...");
 			this.foundLevelFile = this.CreateSubDimFolder(newId);
 		}
 	}
@@ -183,14 +185,9 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		DhLightingEngine.INSTANCE.lightChunk(newlyLoadedChunk, new ArrayList<>(), MC_CLIENT.getWrappedClientLevel().hasSkyLight() ? 15 : 0);
 		
 		// build the chunk LOD
-		if (!LodDataBuilder.canGenerateLodFromChunk(newlyLoadedChunk))
-		{
-			LOGGER.warn("unable to build lod for chunk:"+newlyLoadedChunk.getChunkPos());
-			return null;
-		}
 		FullDataSourceV2 newChunkSizedFullDataView = FullDataSourceV2.createFromChunk(newlyLoadedChunk);
 		// convert to a data source for easier comparing
-		FullDataSourceV2 newDataSource = FullDataSourceV2.createEmpty(DhSectionPos.encode(this.playerData.playerBlockPos));
+		FullDataSourceV2 newDataSource = FullDataSourceV2.createEmpty(DhSectionPos.encodeContaining(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, this.playerData.playerBlockPos));
 		newDataSource.update(newChunkSizedFullDataView);
 		
 		
@@ -200,22 +197,22 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		//================================//
 		
 		// log the start of this attempt
-		LOGGER.info("Attempting to determine sub-dimension for [" + MC_CLIENT.getWrappedClientLevel().getDimensionType().getDimensionName() + "]");
-		LOGGER.info("Player block pos in dimension: [" + this.playerData.playerBlockPos.x + "," + this.playerData.playerBlockPos.y + "," + this.playerData.playerBlockPos.z + "]");
+		LOGGER.info("Attempting to determine sub-dimension for [" + MC_CLIENT.getWrappedClientLevel().getDimensionName() + "]");
+		LOGGER.info("Player block pos in dimension: [" + this.playerData.playerBlockPos.getX() + "," + this.playerData.playerBlockPos.getY() + "," + this.playerData.playerBlockPos.getZ() + "]");
 		LOGGER.info("Potential Sub Dimension folders: [" + this.potentialLevelFolders.size() + "]");
 		
 		SubDimCompare mostSimilarSubDim = null;
 		for (File testLevelFolder : this.potentialLevelFolders)
 		{
-			LOGGER.info("Testing level folder: [" + LodUtil.shortenString(testLevelFolder.getName(), 8) + "]");
+			LOGGER.info("Testing level folder: [" + StringUtil.shortenString(testLevelFolder.getName(), 8) + "]");
 			
 			FullDataSourceV2 testFullDataSource = null;
 			try
 			{
 				// get the data source to compare against
-				try (IDhLevel tempLevel = new DhClientLevel(new ClientOnlySaveStructure(), this.currentClientLevel, testLevelFolder, false))
+				try (IDhLevel tempLevel = new DhClientLevel(new ClientOnlySaveStructure(), this.currentClientLevel, testLevelFolder, false, null))
 				{
-					testFullDataSource = tempLevel.getFullDataProvider().getAsync(DhSectionPos.encode(this.playerData.playerBlockPos)).join();
+					testFullDataSource = tempLevel.getFullDataProvider().getAsync(DhSectionPos.encodeContaining(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, this.playerData.playerBlockPos)).join();
 					if (testFullDataSource == null)
 					{
 						continue;
@@ -314,7 +311,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 				
 				// get the player data for this dimension folder
 				SubDimensionPlayerData testPlayerData = new SubDimensionPlayerData(testLevelFolder);
-				LOGGER.info("Last known player pos: [" + testPlayerData.playerBlockPos.x + "," + testPlayerData.playerBlockPos.y + "," + testPlayerData.playerBlockPos.z + "]");
+				LOGGER.info("Last known player pos: [" + testPlayerData.playerBlockPos.getX() + "," + testPlayerData.playerBlockPos.getY() + "," + testPlayerData.playerBlockPos.getZ() + "]");
 				
 				// check if the block positions are close
 				int playerBlockDist = testPlayerData.playerBlockPos.getManhattanDistance(this.playerData.playerBlockPos);
@@ -328,8 +325,8 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 				}
 				
 				
-				String subDimShortName = LodUtil.shortenString(testLevelFolder.getName(), 8); // variables are separated out for easier debugging
-				String equalPercent = LodUtil.shortenString(mostSimilarSubDim.getPercentEqual()+"", 5);
+				String subDimShortName = StringUtil.shortenString(testLevelFolder.getName(), 8); // variables are separated out for easier debugging
+				String equalPercent = StringUtil.shortenString(mostSimilarSubDim.getPercentEqual()+"", 5);
 				LOGGER.info("Sub dimension ["+subDimShortName+"...] is current dimension probability: "+equalPercent+" ("+equalDataPoints+"/"+totalDataPointCount+")");
 			}
 			catch (Exception e)
@@ -359,7 +356,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		{
 			// we found a sub dim folder that is similar, use it
 			
-			LOGGER.info("Sub Dimension set to: [" + LodUtil.shortenString(mostSimilarSubDim.folder.getName(), 8) + "...] with an equality of [" + mostSimilarSubDim.getPercentEqual() + "]");
+			LOGGER.info("Sub Dimension set to: [" + StringUtil.shortenString(mostSimilarSubDim.folder.getName(), 8) + "...] with an equality of [" + mostSimilarSubDim.getPercentEqual() + "]");
 			return mostSimilarSubDim.folder;
 		}
 		else
@@ -369,7 +366,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 			String newId = UUID.randomUUID().toString();
 			
 			double highestEqualityPercent = mostSimilarSubDim != null ? mostSimilarSubDim.getPercentEqual() : 0;
-			String message = "No suitable sub dimension found. The highest equality was [" + LodUtil.shortenString(highestEqualityPercent + "", 5) + "]. Creating a new sub dimension with ID: " + LodUtil.shortenString(newId, 8) + "...";
+			String message = "No suitable sub dimension found. The highest equality was [" + StringUtil.shortenString(highestEqualityPercent + "", 5) + "]. Creating a new sub dimension with ID: " + StringUtil.shortenString(newId, 8) + "...";
 			LOGGER.info(message);
 			
 			File folder = this.CreateSubDimFolder(newId);
@@ -379,7 +376,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 	}
 	
 	
-	private File CreateSubDimFolder(String subDimId) { return new File(this.levelsFolder.getPath() + File.separatorChar + this.currentClientLevel.getDimensionType().getDimensionName(), subDimId); }
+	private File CreateSubDimFolder(String subDimId) { return new File(this.levelsFolder.getPath() + File.separatorChar + this.currentClientLevel.getDimensionName(), subDimId); }
 	
 	@Override
 	public void close() { this.matcherThread.shutdownNow(); }

core/src/main/java/com/seibel/distanthorizons/core/file/subDimMatching/SubDimensionPlayerData.java

@@ -22,7 +22,7 @@ package com.seibel.distanthorizons.core.file.subDimMatching;
 
 import com.electronwill.nightconfig.core.file.CommentedFileConfig;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
 import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 
@@ -127,9 +127,9 @@ public class SubDimensionPlayerData
 	public void toTomlFile(CommentedFileConfig toml)
 	{
 		// player block pos
-		toml.add(PLAYER_BLOCK_POS_X_PATH, this.playerBlockPos.x);
-		toml.add(PLAYER_BLOCK_POS_Y_PATH, this.playerBlockPos.y);
-		toml.add(PLAYER_BLOCK_POS_Z_PATH, this.playerBlockPos.z);
+		toml.add(PLAYER_BLOCK_POS_X_PATH, this.playerBlockPos.getX());
+		toml.add(PLAYER_BLOCK_POS_Y_PATH, this.playerBlockPos.getY());
+		toml.add(PLAYER_BLOCK_POS_Z_PATH, this.playerBlockPos.getZ());
 		
 		toml.save();
 	}
@@ -138,7 +138,7 @@ public class SubDimensionPlayerData
 	@Override
 	public String toString()
 	{
-		return "PlayerBlockPos: [" + this.playerBlockPos.x + "," + this.playerBlockPos.y + "," + this.playerBlockPos.z + "]";
+		return "PlayerBlockPos: [" + this.playerBlockPos.getX() + "," + this.playerBlockPos.getY() + "," + this.playerBlockPos.getZ() + "]";
 	}
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/generation/AdjacentChunkHolder.java

@@ -33,7 +33,7 @@ public class AdjacentChunkHolder
 		{
 			for (int zOffset = -1; zOffset <= 1; zOffset++)
 			{
-				DhChunkPos adjacentPos = new DhChunkPos(centerChunkPos.x + xOffset, centerChunkPos.z + zOffset);
+				DhChunkPos adjacentPos = new DhChunkPos(centerChunkPos.getX() + xOffset, centerChunkPos.getZ() + zOffset);
 				requestedAdjacentPositions.add(adjacentPos);
 			}
 		}
@@ -69,13 +69,13 @@ public class AdjacentChunkHolder
 		DhChunkPos centerPos = this.chunkArray[4].getChunkPos();
 		DhChunkPos offsetPos = centerWrapper.getChunkPos();
 		
-		int offsetX = offsetPos.x - centerPos.x;
+		int offsetX = offsetPos.getX() - centerPos.getX();
 		if (offsetX < -1 || offsetX > 1)
 		{
 			return;
 		}
 		
-		int offsetZ = offsetPos.z - centerPos.z;
+		int offsetZ = offsetPos.getZ() - centerPos.getZ();
 		if (offsetZ < -1 || offsetZ > 1)
 		{
 			return;
@@ -91,18 +91,18 @@ public class AdjacentChunkHolder
 		int chunkZ = BitShiftUtil.divideByPowerOfTwo(blockZ, 4);
 		IChunkWrapper centerChunk = this.chunkArray[4];
 		DhChunkPos centerPos = centerChunk.getChunkPos();
-		if (centerPos.x == chunkX && centerPos.z == chunkZ)
+		if (centerPos.getX() == chunkX && centerPos.getZ() == chunkZ)
 		{
 			return centerChunk;
 		}
 		
-		int offsetX = chunkX - centerPos.x;
+		int offsetX = chunkX - centerPos.getX();
 		if (offsetX < -1 || offsetX > 1)
 		{
 			return null;
 		}
 		
-		int offsetZ = chunkZ - centerPos.z;
+		int offsetZ = chunkZ - centerPos.getZ();
 		if (offsetZ < -1 || offsetZ > 1)
 		{
 			return null;

core/src/main/java/com/seibel/distanthorizons/core/generation/BatchGenerator.java

@@ -47,15 +47,6 @@ public class BatchGenerator implements IDhApiWorldGenerator
 	private static final IWrapperFactory FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	
-	/**
-	 * Defines how many tasks can be queued per thread. <br><br>
-	 *
-	 * TODO the multiplier here should change dynamically based on how fast the generator is vs the queuing thread,
-	 *  if this is too high it may cause issues when moving,
-	 *  but if it is too low the generator threads won't have enough tasks to work on
-	 */
-	private static final int MAX_QUEUED_TASKS_PER_THREAD = 3;
-	
 	public AbstractBatchGenerationEnvironmentWrapper generationEnvironment;
 	public IDhLevel targetDhLevel;
 	
@@ -147,14 +138,6 @@ public class BatchGenerator implements IDhApiWorldGenerator
 	@Override
 	public void preGeneratorTaskStart() { this.generationEnvironment.updateAllFutures(); }
 	
-	@Override
-	public boolean isBusy()
-	{
-		int worldGenThreadCount = Math.max(Config.Client.Advanced.MultiThreading.numberOfWorldGenerationThreads.get(), 1);
-		int maxWorldGenTaskCount = worldGenThreadCount * MAX_QUEUED_TASKS_PER_THREAD;
-		return this.generationEnvironment.getEventCount() > maxWorldGenTaskCount;
-	}
-	
 	
 	
 	//=========//

core/src/main/java/com/seibel/distanthorizons/core/generation/DhLightingEngine.java

@@ -19,15 +19,23 @@
 
 package com.seibel.distanthorizons.core.generation;
 
+import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPosMutable;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
+import com.seibel.distanthorizons.core.pos.DhSectionPos;
+import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
+import com.seibel.distanthorizons.core.util.FullDataPointUtil;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IMutableBlockPosWrapper;
+import it.unimi.dsi.fastutil.longs.LongArrayList;
 import org.apache.logging.log4j.Logger;
 
+import java.awt.*;
 import java.util.*;
 import java.util.concurrent.locks.ReentrantLock;
 
@@ -49,15 +57,59 @@ public class DhLightingEngine
 	 * Since these objects are always mutated anyway, using a {@link ThreadLocal} will allow us to
 	 * only create as many of these {@link DhBlockPos} as necessary.
 	 */
-	private static final ThreadLocal<DhBlockPos> PRIMARY_BLOCK_POS_REF = ThreadLocal.withInitial(() -> new DhBlockPos());
-	private static final ThreadLocal<DhBlockPos> SECONDARY_BLOCK_POS_REF = ThreadLocal.withInitial(() -> new DhBlockPos());
+	private static final ThreadLocal<DhBlockPosMutable> PRIMARY_BLOCK_POS_REF = ThreadLocal.withInitial(() -> new DhBlockPosMutable());
+	private static final ThreadLocal<DhBlockPosMutable> SECONDARY_BLOCK_POS_REF = ThreadLocal.withInitial(() -> new DhBlockPosMutable());
+	
+	/** if enabled will render each block light value when the chunk lighting engine is run */
+	private static final boolean RENDER_BLOCK_LIGHT_WIREFRAME = false;
+	/** if enabled will render each sky light value when the chunk lighting engine is run */
+	private static final boolean RENDER_SKY_LIGHT_WIREFRAME = false;
+	
+	/**
+	 * Used for dataSource lighting. <br> 
+	 * Packed as alternating x and z offsets. 
+	 */
+	private static final byte[] ADJACENT_DIRECTION_OFFSETS = new byte[]
+			{
+					-1, 0,
+					+1, 0,
+					0, -1,
+					0, +1
+			};
 	
 	
 	
+	//=============//
+	// constructor //
+	//=============//
+	
 	private DhLightingEngine() { }
 	
 	
 	
+	//================//
+	// chunk lighting //
+	//================//
+	
+	/**
+	 * Populates both block and sky lighting. 
+	 * @see DhLightingEngine#lightChunk(IChunkWrapper, ArrayList, int, boolean, boolean) 
+	 */
+	public void lightChunk(
+			@NotNull IChunkWrapper centerChunk, @NotNull ArrayList<IChunkWrapper> nearbyChunkList,
+			int maxSkyLight)
+	{ this.lightChunk(centerChunk, nearbyChunkList, maxSkyLight, true, true); }
+	
+	/**
+	 * Only populates block lights. 
+	 * @see DhLightingEngine#lightChunk(IChunkWrapper, ArrayList, int, boolean, boolean) 
+	 */
+	public void bakeChunkBlockLighting(
+			@NotNull IChunkWrapper centerChunk, @NotNull ArrayList<IChunkWrapper> nearbyChunkList,
+			int maxSkyLight)
+	{ this.lightChunk(centerChunk, nearbyChunkList, maxSkyLight, true, false); }
+	
+	
 	/**
 	 * Note: depending on the implementation of {@link IChunkWrapper#setDhBlockLight(int, int, int, int)} and {@link IChunkWrapper#setDhSkyLight(int, int, int, int)}
 	 * the light values may be stored in the wrapper itself instead of the wrapped chunk object.
@@ -67,21 +119,21 @@ public class DhLightingEngine
 	 * @param nearbyChunkList should also contain centerChunk
 	 * @param maxSkyLight should be a value between 0 and 15
 	 */
-	public void lightChunk(@NotNull IChunkWrapper centerChunk, @NotNull ArrayList<IChunkWrapper> nearbyChunkList, int maxSkyLight)
+	private void lightChunk(
+			@NotNull IChunkWrapper centerChunk, @NotNull ArrayList<IChunkWrapper> nearbyChunkList, 
+			int maxSkyLight, boolean updateBlockLight, boolean updateSkyLight)
 	{
 		DhChunkPos centerChunkPos = centerChunk.getChunkPos();
 		AdjacentChunkHolder adjacentChunkHolder = new AdjacentChunkHolder(centerChunk);
 		
-		long startTimeNs = System.nanoTime();
-		
 		
 		// try-finally to handle the stableArray resources
-		StableLightPosStack blockLightPosQueue = null;
-		StableLightPosStack skyLightPosQueue = null;
+		StableLightPosStack blockLightWorldPosQueue = null;
+		StableLightPosStack skyLightWorldPosQueue = null;
 		try
 		{
-			blockLightPosQueue = StableLightPosStack.borrowStableLightPosArray();
-			skyLightPosQueue = StableLightPosStack.borrowStableLightPosArray();
+			blockLightWorldPosQueue = StableLightPosStack.borrowStableLightPosArray();
+			skyLightWorldPosQueue = StableLightPosStack.borrowStableLightPosArray();
 			
 			
 			
@@ -92,7 +144,7 @@ public class DhLightingEngine
 			{
 				for (int zOffset = -1; zOffset <= 1; zOffset++)
 				{
-					DhChunkPos adjacentPos = new DhChunkPos(centerChunkPos.x + xOffset, centerChunkPos.z + zOffset);
+					DhChunkPos adjacentPos = new DhChunkPos(centerChunkPos.getX() + xOffset, centerChunkPos.getZ() + zOffset);
 					requestedAdjacentPositions.add(adjacentPos);
 				}
 			}
@@ -100,7 +152,6 @@ public class DhLightingEngine
 			
 			// find all adjacent chunks
 			// and get any necessary info from them
-			boolean warningLogged = false;
 			for (int chunkIndex = 0; chunkIndex < nearbyChunkList.size(); chunkIndex++) // using iterators in high traffic areas can cause GC issues due to allocating a bunch of iterators, use an indexed for-loop instead
 			{
 				IChunkWrapper chunk = nearbyChunkList.get(chunkIndex);
@@ -112,33 +163,46 @@ public class DhLightingEngine
 					// add the adjacent chunk
 					adjacentChunkHolder.add(chunk);
 					
-					
-					
 					// get and set the adjacent chunk's initial block lights
-					final DhBlockPos relLightBlockPos = PRIMARY_BLOCK_POS_REF.get();
-					final DhBlockPos relBlockPos = SECONDARY_BLOCK_POS_REF.get();
+					final DhBlockPosMutable relLightBlockPos = PRIMARY_BLOCK_POS_REF.get();
 					
-					ArrayList<DhBlockPos> blockLightPosList = chunk.getBlockLightPosList();
-					for (int blockLightIndex = 0; blockLightIndex < blockLightPosList.size(); blockLightIndex++) // using iterators in high traffic areas can cause GC issues due to allocating a bunch of iterators, use an indexed for-loop instead
+					
+					
+					//==================//
+					// set block lights //
+					//==================//
+					
+					if (updateBlockLight)
 					{
-						DhBlockPos blockLightPos = blockLightPosList.get(blockLightIndex);
-						blockLightPos.mutateToChunkRelativePos(relLightBlockPos);
-						
-						// get the light
-						IBlockStateWrapper blockState = chunk.getBlockState(relLightBlockPos);
-						int lightValue = blockState.getLightEmission();
-						blockLightPosQueue.push(blockLightPos.x, blockLightPos.y, blockLightPos.z, lightValue);
-						
-						// set the light
-						blockLightPos.mutateToChunkRelativePos(relBlockPos);
-						chunk.setDhBlockLight(relBlockPos.x, relBlockPos.y, relBlockPos.z, lightValue);
+						ArrayList<DhBlockPos> blockLightPosList = chunk.getWorldBlockLightPosList();
+						for (int blockLightIndex = 0; blockLightIndex < blockLightPosList.size(); blockLightIndex++) // using iterators in high traffic areas can cause GC issues due to allocating a bunch of iterators, use an indexed for-loop instead
+						{
+							DhBlockPos blockLightPos = blockLightPosList.get(blockLightIndex);
+							blockLightPos.mutateToChunkRelativePos(relLightBlockPos);
+							
+							// get the light
+							IBlockStateWrapper blockState = chunk.getBlockState(relLightBlockPos);
+							int lightValue = blockState.getLightEmission();
+							blockLightWorldPosQueue.push(blockLightPos.getX(), blockLightPos.getY(), blockLightPos.getZ(), lightValue);
+							
+							// set the light
+							chunk.setDhBlockLight(relLightBlockPos.getX(), relLightBlockPos.getY(), relLightBlockPos.getZ(), lightValue);
+						}
 					}
 					
 					
+					
+					//================//
+					// set sky lights //
+					//================//
+					
 					// get and set the adjacent chunk's initial skylights,
 					// if the dimension has skylights
-					if (maxSkyLight > 0)
+					if (updateSkyLight && maxSkyLight > 0)
 					{
+						IMutableBlockPosWrapper mcBlockPos = chunk.getMutableBlockPosWrapper();
+						IBlockStateWrapper previousBlockState = null;
+						
 						int maxY = chunk.getMaxNonEmptyHeight();
 						int minY = chunk.getMinBuildHeight();
 						
@@ -147,10 +211,10 @@ public class DhLightingEngine
 						{
 							for (int relZ = 0; relZ < LodUtil.CHUNK_WIDTH; relZ++)
 							{
-								// set each pos' sky light all the way down until a opaque block is hit
+								// set each pos' sky light all the way down until an opaque block is hit
 								for (int y = maxY; y >= minY; y--)
 								{
-									IBlockStateWrapper block = chunk.getBlockState(relX, y, relZ);
+									IBlockStateWrapper block = previousBlockState = chunk.getBlockState(relX, y, relZ, mcBlockPos, previousBlockState);
 									if (block != null && block.getOpacity() != LodUtil.BLOCK_FULLY_TRANSPARENT)
 									{
 										// keep moving down until we find a non-transparent block
@@ -160,11 +224,11 @@ public class DhLightingEngine
 									
 									// add sky light to the queue
 									DhBlockPos skyLightPos = new DhBlockPos(chunk.getMinBlockX() + relX, y, chunk.getMinBlockZ() + relZ);
-									skyLightPosQueue.push(skyLightPos.x, skyLightPos.y, skyLightPos.z, maxSkyLight);
+									skyLightWorldPosQueue.push(skyLightPos.getX(), skyLightPos.getY(), skyLightPos.getZ(), maxSkyLight);
 									
 									// set the chunk's sky light
-									skyLightPos.mutateToChunkRelativePos(relBlockPos);
-									chunk.setDhSkyLight(relBlockPos.x, relBlockPos.y, relBlockPos.z, maxSkyLight);
+									skyLightPos.mutateToChunkRelativePos(relLightBlockPos);
+									chunk.setDhSkyLight(relLightBlockPos.getX(), relLightBlockPos.getY(), relLightBlockPos.getZ(), maxSkyLight);
 								}
 							}
 						}
@@ -180,14 +244,22 @@ public class DhLightingEngine
 			}
 			
 			// block light
-			this.propagateLightPosList(blockLightPosQueue, adjacentChunkHolder,
-					(neighbourChunk, relBlockPos) -> neighbourChunk.getDhBlockLight(relBlockPos.x, relBlockPos.y, relBlockPos.z),
-					(neighbourChunk, relBlockPos, newLightValue) -> neighbourChunk.setDhBlockLight(relBlockPos.x, relBlockPos.y, relBlockPos.z, newLightValue));
+			if (updateBlockLight)
+			{
+				this.propagateChunkLightPosList(blockLightWorldPosQueue, adjacentChunkHolder,
+						(neighbourChunk, relBlockPos) -> neighbourChunk.getDhBlockLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ()),
+						(neighbourChunk, relBlockPos, newLightValue) -> neighbourChunk.setDhBlockLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ(), newLightValue),
+						true);
+			}
 			
 			// sky light
-			this.propagateLightPosList(skyLightPosQueue, adjacentChunkHolder,
-					(neighbourChunk, relBlockPos) -> neighbourChunk.getDhSkyLight(relBlockPos.x, relBlockPos.y, relBlockPos.z),
-					(neighbourChunk, relBlockPos, newLightValue) -> neighbourChunk.setDhSkyLight(relBlockPos.x, relBlockPos.y, relBlockPos.z, newLightValue));
+			if (updateSkyLight)
+			{
+				this.propagateChunkLightPosList(skyLightWorldPosQueue, adjacentChunkHolder,
+						(neighbourChunk, relBlockPos) -> neighbourChunk.getDhSkyLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ()),
+						(neighbourChunk, relBlockPos, newLightValue) -> neighbourChunk.setDhSkyLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ(), newLightValue),
+						false);
+			}
 		}
 		catch (Exception e)
 		{
@@ -195,31 +267,35 @@ public class DhLightingEngine
 		}
 		finally
 		{
-			StableLightPosStack.returnStableLightPosArray(blockLightPosQueue);
-			StableLightPosStack.returnStableLightPosArray(skyLightPosQueue);
+			StableLightPosStack.returnStableLightPosArray(blockLightWorldPosQueue);
+			StableLightPosStack.returnStableLightPosArray(skyLightWorldPosQueue);
 		}
 		
 		
-		
-		centerChunk.setIsDhLightCorrect(true);
-		centerChunk.setUseDhLighting(true);
-		
-		long endTimeNs = System.nanoTime();
-		float totalTimeMs = (endTimeNs - startTimeNs) / 1_000_000.0f;
-		//LOGGER.trace("Finished generating lighting for chunk: [" + centerChunkPos + "] in ["+totalTimeMs+"] milliseconds");
+		if (updateBlockLight)
+		{
+			centerChunk.setIsDhBlockLightCorrect(true);
+		}
+		if (updateSkyLight)
+		{
+			centerChunk.setIsDhSkyLightCorrect(true);
+		}
 	}
 	
 	/** Applies each {@link LightPos} from the queue to the given set of {@link IChunkWrapper}'s. */
-	private void propagateLightPosList(
+	private void propagateChunkLightPosList(
 			StableLightPosStack lightPosQueue, AdjacentChunkHolder adjacentChunkHolder,
-			IGetLightFunc getLightFunc, ISetLightFunc setLightFunc)
+			IGetLightFunc getLightFunc, ISetLightFunc setLightFunc,
+			boolean propagatingBlockLights)
 	{
 		// these objects are saved so they can be mutated throughout the method,
 		// this reduces the number of allocations necessary, reducing GC pressure
 		final LightPos lightPos = new LightPos(0, 0, 0, 0);
-		final DhBlockPos neighbourBlockPos = PRIMARY_BLOCK_POS_REF.get();
-		final DhBlockPos relNeighbourBlockPos = SECONDARY_BLOCK_POS_REF.get();
+		final DhBlockPosMutable neighbourBlockPos = PRIMARY_BLOCK_POS_REF.get();
+		final DhBlockPosMutable relNeighbourBlockPos = SECONDARY_BLOCK_POS_REF.get();
 		
+		IMutableBlockPosWrapper mcBlockPos = null;
+		IBlockStateWrapper previousBlockState = null;
 		
 		// update each light position
 		while (!lightPosQueue.isEmpty())
@@ -239,14 +315,14 @@ public class DhLightingEngine
 				
 				
 				// only continue if the light position is inside one of our chunks
-				IChunkWrapper neighbourChunk = adjacentChunkHolder.getByBlockPos(neighbourBlockPos.x, neighbourBlockPos.z);
+				IChunkWrapper neighbourChunk = adjacentChunkHolder.getByBlockPos(neighbourBlockPos.getX(), neighbourBlockPos.getZ());
 				if (neighbourChunk == null)
 				{
 					// the light pos is outside our generator's range, ignore it
 					continue;
 				}
 				
-				if (relNeighbourBlockPos.y < neighbourChunk.getMinNonEmptyHeight() || relNeighbourBlockPos.y > neighbourChunk.getMaxBuildHeight())
+				if (relNeighbourBlockPos.getY() < neighbourChunk.getMinNonEmptyHeight() || relNeighbourBlockPos.getY() > neighbourChunk.getMaxBuildHeight())
 				{
 					// the light pos is outside the chunk's min/max height,
 					// this can happen if given a chunk that hasn't finished generating
@@ -263,7 +339,15 @@ public class DhLightingEngine
 				}
 				
 				
-				IBlockStateWrapper neighbourBlockState = neighbourChunk.getBlockState(relNeighbourBlockPos);
+				if (mcBlockPos == null)
+				{
+					// it doesn't matter what chunk we get the position object from
+					// TODO move this getter logic out of ChunkWrapper
+					mcBlockPos = neighbourChunk.getMutableBlockPosWrapper();
+				}
+				
+				
+				IBlockStateWrapper neighbourBlockState = previousBlockState = neighbourChunk.getBlockState(relNeighbourBlockPos, mcBlockPos, previousBlockState);
 				// Math.max(1, ...) is used so that the propagated light level always drops by at least 1, preventing infinite cycles.
 				int targetLevel = lightValue - Math.max(1, neighbourBlockState.getOpacity());
 				if (targetLevel > currentBlockLight)
@@ -273,16 +357,338 @@ public class DhLightingEngine
 					
 					// now that light has been propagated to this blockPos
 					// we need to queue it up so its neighbours can be propagated as well
-					lightPosQueue.push(neighbourBlockPos.x, neighbourBlockPos.y, neighbourBlockPos.z, targetLevel);
+					lightPosQueue.push(neighbourBlockPos.getX(), neighbourBlockPos.getY(), neighbourBlockPos.getZ(), targetLevel);
 				}
 			}
 		}
 		
+		
+		// can be enable if troubleshooting lighting issues
+		if (RENDER_BLOCK_LIGHT_WIREFRAME && propagatingBlockLights)
+		{
+			RenderDhLightValuesAsWireframe(adjacentChunkHolder, true);
+		}
+		else if (RENDER_SKY_LIGHT_WIREFRAME && !propagatingBlockLights)
+		{
+			RenderDhLightValuesAsWireframe(adjacentChunkHolder, false);
+		}
+		
+		
 		// propagation complete
 	}
 	
 	
 	
+	//======================//
+	// data source lighting //
+	//======================//
+	
+	/** @author BuilderB0y */
+	public void bakeDataSourceSkyLight(FullDataSourceV2 dataSource, int maxSkyLight)
+	{
+		// create a cache of all the IDs which are completely transparent.
+		// FullDataPointIdMap is thread-safe with locks, and is also a map lookup,
+		// and both of these things add a bit of overhead which is not necessary
+		// in this context.
+		// note: since IDs map to both biomes and blocks, there can be more than
+		// one ID which corresponds to air.
+		BitSet airIDs = new BitSet(dataSource.mapping.size());
+		for (int id = 0, size = dataSource.mapping.size(); id < size; id++)
+		{
+			if (dataSource.mapping.getBlockStateWrapper(id).getOpacity() == 0)
+			{
+				airIDs.set(id, true);
+			}
+		}
+		
+		
+		for (int z = 0; z < FullDataSourceV2.WIDTH; z++)
+		{
+			for (int x = 0; x < FullDataSourceV2.WIDTH; x++)
+			{
+				LongArrayList dataPoints = dataSource.get(x, z);
+				if (dataPoints != null && !dataPoints.isEmpty())
+				{
+					// iterate through the data points in this column top-down
+					// until we reach light level 0 in some way. at this point,
+					// no more propagation needs to be performed for this column.
+					int size = dataPoints.size();
+					for (int index = 0; index < size; index++)
+					{
+						long point = dataPoints.getLong(index);
+						// if the data point in the column is transparent,
+						// then fill it with light and then propagate 
+						// that light both horizontally and downwards.
+						if (airIDs.get(FullDataPointUtil.getId(point)))
+						{
+							int skylight;
+							if (index == 0)
+							{
+								// top-most data point in the column.
+								skylight = maxSkyLight;
+							}
+							else
+							{
+								// handle down propagation here. sort of.
+								// down propagation is also handled partially elsewhere.
+								// basically if the data point above is transparent,
+								// we copy its light level.
+								// otherwise, if the data point above is opaque,
+								// then no light can propagate downwards from it.
+								// therefore, this data point should be light level 0*
+								// and no more propagation needs to be performed for this column.
+								//
+								// *unless light propagates into it horizontally,
+								// but that is handled separately.
+								long above = dataPoints.getLong(index - 1);
+								if (airIDs.get(FullDataPointUtil.getId(above)))
+								{
+									skylight = FullDataPointUtil.getSkyLight(above);
+								}
+								else
+								{
+									continue;
+								}
+							}
+							
+							// update the data point to contain the correct starting skylight level.
+							point = FullDataPointUtil.setSkyLight(point, skylight);
+							dataPoints.set(index, point);
+							// now for the propagation.
+							recursivelyLightAdjacentDataPoints(dataSource, airIDs, x, z, point);
+						}
+					}
+				}
+			}
+		}
+		
+		
+		// at this point, all transparent data points have been lit,
+		// but opaque ones still have light level 0.
+		// in this loop we make opaque data points copy the light level
+		// above them if, and only if, the data point above is translucent.
+		// with one exception: if the data point above is only partially translucent,
+		// we use a slightly different way of computing how much light it absorbed.
+		// this is how we handle water and ocean floors.
+		// note that this alternate logic assumes the 
+		// data point above is being lit from the top.
+		// this is a fine assumption for water and oceans.
+		for (LongArrayList list : dataSource.dataPoints)
+		{
+			if (list != null)
+			{
+				for (int index = 0, size = list.size(); index < size; index++)
+				{
+					long dataPoint = list.getLong(index);
+					if (index == 0)
+					{
+						// top data point, assume "above" has the max sky light.
+						dataPoint = FullDataPointUtil.setSkyLight(dataPoint, maxSkyLight);
+						list.set(index, dataPoint);
+					}
+					else
+					{
+						// there is another data point above this one.
+						// check to see how opaque this data point is first.
+						// we will check the above one after that.
+						if (!airIDs.get(FullDataPointUtil.getId(dataPoint)))
+						{
+							// this data point is not transparent.
+							// it should be lit from above.
+							long above = list.getLong(index - 1);
+							int aboveLight = FullDataPointUtil.getSkyLight(above);
+							if (airIDs.get(FullDataPointUtil.getId(above)))
+							{
+								// the above data point is transparent,
+								// and does not absorb any light.
+								// its light level can be copied as-is.
+								dataPoint = FullDataPointUtil.setSkyLight(dataPoint, aboveLight);
+								list.set(index, dataPoint);
+							}
+							else
+							{
+								// determine how much light should be absorbed by this column
+								int absorption = dataSource.mapping.getBlockStateWrapper(FullDataPointUtil.getId(above)).getOpacity() * FullDataPointUtil.getHeight(above);
+								if (absorption < aboveLight)
+								{
+									// the above data point is partially translucent,
+									// and absorbs some light. however, it did not absorb
+									// enough light to bring the light level down to 0.
+									// so, the remaining light can still be copied.
+									dataPoint = FullDataPointUtil.setSkyLight(dataPoint, aboveLight - absorption);
+									list.set(index, dataPoint);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	
+	/** @author BuilderB0y */
+	public void recursivelyLightAdjacentDataPoints(
+			FullDataSourceV2 chunk,
+			BitSet airIDs,
+			int relativeX,
+			int relativeZ,
+			long dataPoint
+		)
+	{
+		int lightLevel = FullDataPointUtil.getSkyLight(dataPoint);
+		// early exit condition:
+		// in this case, propagating light is guaranteed to be 0 at adjacent positions,
+		// and therefore we do not need to waste time propagating it.
+		if (lightLevel <= 1)
+		{
+			return;
+		}
+		
+		
+		
+		int minY = FullDataPointUtil.getBottomY(dataPoint);
+		int maxY = FullDataPointUtil.getHeight(dataPoint) + minY;
+		// try to propagate in all 4 directions.
+		for (int offsetIndex = 0; offsetIndex < ADJACENT_DIRECTION_OFFSETS.length; )
+		{
+			int adjacentX = relativeX + ADJACENT_DIRECTION_OFFSETS[offsetIndex++];
+			int adjacentZ = relativeZ + ADJACENT_DIRECTION_OFFSETS[offsetIndex++];
+			
+			// check if the adjacent position is within the bounds of this data source...
+			if (adjacentX >= 0 && adjacentX < FullDataSourceV2.WIDTH && adjacentZ >= 0 && adjacentZ < FullDataSourceV2.WIDTH)
+			{
+				LongArrayList adjacentDataPoints = chunk.get(adjacentX, adjacentZ);
+				// ...and also check to make sure we have some data points
+				// (potentially transparent ones) to propagate through in the adjacent column.
+				if (adjacentDataPoints != null)
+				{
+					// try to find adjacent data points we can propagate into.
+					// we go top-down for this, which will be important for some
+					// later conditions.
+					int size = adjacentDataPoints.size();
+					for (int adjacentIndex = 0; adjacentIndex < size; adjacentIndex++)
+					{
+						long adjacentDataPoint = adjacentDataPoints.getLong(adjacentIndex);
+						int adjacentMinY = FullDataPointUtil.getBottomY(adjacentDataPoint);
+						int adjacentMaxY = FullDataPointUtil.getHeight(adjacentDataPoint) + adjacentMinY;
+						if (adjacentMinY >= maxY)
+						{
+							// if the adjacent data point is completely above this one,
+							// then there is no overlap between this one and the adjacent one,
+							// and therefore light cannot propagate here.
+							// try to propagate to the next data point down from the adjacent one.
+							continue;
+						}
+						else if (adjacentMaxY <= minY)
+						{
+							// if the adjacent data point is completely below this one,
+							// then it also has no overlap and can't propagate,
+							// but since we're going top-down, neither can any subsequent adjacent data points.
+							break;
+						}
+						else if (!airIDs.get(FullDataPointUtil.getId(adjacentDataPoint)))
+						{
+							// assume for now that we cannot propagate into non-transparent data points.
+							continue; // TODO how does this work with water? Do we care?
+						}
+						else
+						{
+							// now we can try to propagate.
+							int adjacentLightLevel = FullDataPointUtil.getSkyLight(adjacentDataPoint);
+							// if the resulting light level after propagation would INCREASE
+							// the light level of the adjacent data point, then propagate to it.
+							// otherwise, don't do that.
+							if (lightLevel - 1 > adjacentLightLevel)
+							{
+								adjacentDataPoint = FullDataPointUtil.setSkyLight(adjacentDataPoint, lightLevel - 1);
+								adjacentDataPoints.set(adjacentIndex, adjacentDataPoint);
+								// if propagation succeeded, recursively propagate again starting at the adjacent data point.
+								recursivelyLightAdjacentDataPoints(chunk, airIDs, adjacentX, adjacentZ, adjacentDataPoint);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	
+	
+	
+	//===========//
+	// debugging //
+	//===========//
+	
+	/** Draw a wireframe representing each block's light value */
+	private static void RenderDhLightValuesAsWireframe(AdjacentChunkHolder adjacentChunkHolder, boolean renderBlockLights)
+	{
+		for (IChunkWrapper chunk : adjacentChunkHolder.chunkArray)
+		{
+			if (chunk == null)
+			{
+				continue;
+			}
+			
+			
+			
+			int chunkMinX = chunk.getMinBlockX();
+			int chunkMinZ = chunk.getMinBlockZ();
+			
+			int minY = chunk.getMinNonEmptyHeight();
+			int maxY = chunk.getMaxNonEmptyHeight();
+			
+			// check each position's light
+			for (int x = 0; x < LodUtil.CHUNK_WIDTH; x++)
+			{
+				for (int z = 0; z < LodUtil.CHUNK_WIDTH; z++)
+				{
+					for (int y = minY; y < maxY; y++)
+					{
+						int lightValue = renderBlockLights? chunk.getDhBlockLight(x, y, z) : chunk.getDhSkyLight(x, y, z);
+						if (lightValue != LodUtil.MIN_MC_LIGHT)
+						{
+							// hotter colors for more intense light
+							Color color;
+							if (lightValue >= 14)
+							{
+								color = Color.WHITE;
+							}
+							else if (lightValue >= 10)
+							{
+								color = Color.PINK;
+							}
+							else if (lightValue >= 6)
+							{
+								color = Color.YELLOW;
+							}
+							else if (lightValue >= 4)
+							{
+								color = Color.ORANGE;
+							}
+							else
+							{
+								color = Color.RED;
+							}
+							
+							
+							// a color can be set to null if you only want to troubleshoot up to a certain light level
+							if (color != null)
+							{
+								DebugRenderer.makeParticle(
+									new DebugRenderer.BoxParticle(
+										new DebugRenderer.Box(DhSectionPos.encode((byte) 0, chunkMinX + x, chunkMinZ + z), y, y + 1, 0.2f, color),
+										10.0, 0f
+									)
+								);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	
+	
+	
 	//================//
 	// helper classes //
 	//================//
@@ -293,7 +699,7 @@ public class DhLightingEngine
 	@FunctionalInterface
 	interface ISetLightFunc { void setLight(IChunkWrapper chunk, DhBlockPos pos, int lightValue); }
 	
-	private static class LightPos extends DhBlockPos
+	private static class LightPos extends DhBlockPosMutable
 	{
 		public int lightValue;
 		
@@ -303,6 +709,11 @@ public class DhLightingEngine
 			this.lightValue = lightValue;
 		}
 		
+		
+		@Override
+		public String toString() { return this.lightValue+" - ["+ this.x +", "+ this.y +", "+ this.z +"]"; }
+		
+		
 	}
 	
 	/** 
@@ -402,9 +813,9 @@ public class DhLightingEngine
 		{
 			int subIndex = this.index * INTS_PER_LIGHT_POS;
 			
-			pos.x = this.lightPositions.getInt(subIndex);
-			pos.y = this.lightPositions.getInt(subIndex + 1);
-			pos.z = this.lightPositions.getInt(subIndex + 2);
+			pos.setX(this.lightPositions.getInt(subIndex));
+			pos.setY(this.lightPositions.getInt(subIndex + 1));
+			pos.setZ(this.lightPositions.getInt(subIndex + 2));
 			pos.lightValue = this.lightPositions.getInt(subIndex + 3);
 			
 			this.index--;

core/src/main/java/com/seibel/distanthorizons/core/generation/IFullDataSourceRetrievalQueue.java

@@ -21,11 +21,12 @@ package com.seibel.distanthorizons.core.generation;
 
 import com.seibel.distanthorizons.core.generation.tasks.IWorldGenTaskTracker;
 import com.seibel.distanthorizons.core.generation.tasks.WorldGenResult;
-import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.LodQuadTree;
 
 import java.io.Closeable;
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
 /**
@@ -49,9 +50,17 @@ public interface IFullDataSourceRetrievalQueue extends Closeable
 	// getters //
 	//=========//
 	
-	/** the largest numerical detail level */
+	/** 
+	 * The largest numerical detail level. <br>
+	 * Detail level is absolute, not section;
+	 * IE 0 = Block, 1 = 2x2 blocks, etc.
+	 */
 	byte lowestDataDetail();
-	/** the smallest numerical detail level */
+	/** 
+	 * The smallest numerical detail level. <br>
+	 * Detail level is absolute, not section;
+	 * IE 0 = Block, 1 = 2x2 blocks, etc.
+	 */
 	byte highestDataDetail();
 	
 	
@@ -81,7 +90,7 @@ public interface IFullDataSourceRetrievalQueue extends Closeable
 	 */
 	void removeRetrievalRequestIf(DhSectionPos.ICancelablePrimitiveLongConsumer removeIf);
 	
-	CompletableFuture<WorldGenResult> submitGenTask(long pos, byte requiredDataDetail, IWorldGenTaskTracker tracker);
+	CompletableFuture<WorldGenResult> submitRetrievalTask(long pos, byte requiredDataDetail, IWorldGenTaskTracker tracker);
 	
 	
 	
@@ -89,7 +98,10 @@ public interface IFullDataSourceRetrievalQueue extends Closeable
 	// shutdown //
 	//==========//
 	
-	CompletableFuture<Void> startClosing(boolean cancelCurrentGeneration, boolean alsoInterruptRunning);
+	/** Can be used to let any lingering generation requests finish before fully shutting down the system */
+	CompletableFuture<Void> startClosingAsync(boolean cancelCurrentGeneration, boolean alsoInterruptRunning);
+	
+	@Override
 	void close();
 	
 	
@@ -104,6 +116,8 @@ public interface IFullDataSourceRetrievalQueue extends Closeable
 	/** used for rendering to the F3 menu */
 	int getEstimatedTotalTaskCount();
 	void setEstimatedTotalTaskCount(int newEstimate);
+
+	void addDebugMenuStringsToList(List<String> messageList);
 	
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/generation/RemoteWorldRetrievalQueue.java

@@ -0,0 +1,84 @@
+package com.seibel.distanthorizons.core.generation;
+
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.generation.tasks.IWorldGenTaskTracker;
+import com.seibel.distanthorizons.core.generation.tasks.WorldGenResult;
+import com.seibel.distanthorizons.core.level.IDhClientLevel;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.multiplayer.client.AbstractFullDataNetworkRequestQueue;
+import com.seibel.distanthorizons.core.multiplayer.client.ClientNetworkState;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
+import com.seibel.distanthorizons.core.util.LodUtil;
+import org.apache.logging.log4j.Logger;
+
+import java.util.concurrent.*;
+
+public class RemoteWorldRetrievalQueue extends AbstractFullDataNetworkRequestQueue implements IFullDataSourceRetrievalQueue, IDebugRenderable
+{
+	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	
+	private int estimatedTotalTaskCount;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public RemoteWorldRetrievalQueue(ClientNetworkState networkState, IDhClientLevel level)
+	{ super(networkState, level, false, Config.Client.Advanced.Debugging.DebugWireframe.showWorldGenQueue); }
+	
+	
+	
+	//===========================//
+	// retrieval queue overrides //
+	//===========================//
+	
+	@Override
+	public void startAndSetTargetPos(DhBlockPos2D targetPos) { super.tick(targetPos); }
+	
+	@Override
+	public byte lowestDataDetail() { return LodUtil.BLOCK_DETAIL_LEVEL; }
+	@Override
+	public byte highestDataDetail() { return LodUtil.BLOCK_DETAIL_LEVEL; }
+	
+	@Override
+	public CompletableFuture<WorldGenResult> submitRetrievalTask(long sectionPos, byte requiredDataDetail, IWorldGenTaskTracker tracker)
+	{
+		return super.submitRequest(sectionPos, tracker.getDataSourceConsumer())
+				.thenApply(retrievalSuccess -> retrievalSuccess
+						? WorldGenResult.CreateSuccess(sectionPos)
+						: WorldGenResult.CreateFail());
+	}
+	
+	@Override
+	public CompletableFuture<Void> startClosingAsync(boolean cancelCurrentGeneration, boolean alsoInterruptRunning)
+	{ return super.startClosingAsync(alsoInterruptRunning); }
+	
+	
+	
+	//=================================//
+	// network request queue overrides //
+	//=================================//
+	
+	@Override
+	protected int getRequestRateLimit() { return this.networkState.sessionConfig.getGenerationRequestRateLimit(); }
+	
+	@Override
+	protected String getQueueName() { return "World Remote Generation Queue"; }
+	
+	
+	
+	//===============//
+	// debug display //
+	//===============//
+	
+	@Override
+	public int getEstimatedTotalTaskCount() { return this.estimatedTotalTaskCount; }
+	@Override
+	public void setEstimatedTotalTaskCount(int newEstimate) { this.estimatedTotalTaskCount = newEstimate; }
+	
+	
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/generation/WorldGenerationQueue.java

@@ -27,7 +27,7 @@ import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSour
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.generation.tasks.*;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.config.Config;
@@ -47,6 +47,7 @@ import org.apache.logging.log4j.Logger;
 
 import java.awt.*;
 import java.util.*;
+import java.util.List;
 import java.util.concurrent.*;
 import java.util.function.Consumer;
 
@@ -55,6 +56,16 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	private static final IWrapperFactory WRAPPER_FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
 	
+	/**
+	 * Defines how many tasks can be queued per thread. <br><br>
+	 *
+	 * TODO the multiplier here should change dynamically based on how fast the generator is vs the queuing thread,
+	 *  if this is too high it may cause issues when moving,
+	 *  but if it is too low the generator threads won't have enough tasks to work on
+	 */
+	private static final int MAX_QUEUED_TASKS_PER_THREAD = 3;
+	
+	
 	private final IDhApiWorldGenerator generator;
 	
 	/** contains the positions that need to be generated */
@@ -78,7 +89,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 	// TODO this logic isn't great and can cause a limit to how many threads could be used for world generation, 
 	//  however it won't cause duplicate requests or concurrency issues, so it will be good enough for now.
 	//  A good long term fix may be to either:
-	//  1. allow the generator to deal with larger sections (let the generator threads split up larger tasks into smaller one
+	//  1. allow the generator to deal with larger sections (let the generator threads split up larger tasks into smaller ones
 	//  2. batch requests better. instead of sending 4 individual tasks of detail level N, send 1 task of detail level n+1
 	private final ExecutorService queueingThread = ThreadUtil.makeSingleThreadPool("World Gen Queue");
 	private boolean generationQueueRunning = false;
@@ -131,7 +142,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 	//=================//
 	
 	@Override
-	public CompletableFuture<WorldGenResult> submitGenTask(long pos, byte requiredDataDetail, IWorldGenTaskTracker tracker)
+	public CompletableFuture<WorldGenResult> submitRetrievalTask(long pos, byte requiredDataDetail, IWorldGenTaskTracker tracker)
 	{
 		// the generator is shutting down, don't add new tasks
 		if (this.generatorClosingFuture != null)
@@ -206,7 +217,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 					
 					// queue generation tasks until the generator is full, or there are no more tasks to generate
 					boolean taskStarted = true;
-					while (!this.generator.isBusy() && taskStarted)
+					while (!this.isGeneratorBusy() && taskStarted)
 					{
 						taskStarted = this.startNextWorldGenTask(this.generationTargetPos);
 						if (!taskStarted)
@@ -226,10 +237,26 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 			catch (Exception e)
 			{
 				LOGGER.error("queueing exception: " + e.getMessage(), e);
+			}
+			finally
+			{
 				this.generationQueueRunning = false;
 			}
 		});
 	}
+	public boolean isGeneratorBusy()
+	{
+		ThreadPoolExecutor executor = ThreadPoolUtil.getWorldGenExecutor();
+		if (executor == null)
+		{
+			// shouldn't happen, but just in case, don't queue more tasks
+			return true;
+		}
+		
+		int worldGenThreadCount = Math.max(Config.Client.Advanced.MultiThreading.numberOfWorldGenerationThreads.get(), 1);
+		int maxWorldGenTaskCount = worldGenThreadCount * MAX_QUEUED_TASKS_PER_THREAD;
+		return executor.getQueue().size() > maxWorldGenTaskCount;
+	}
 	
 	/**
 	 * @param targetPos the position to center the generation around
@@ -373,7 +400,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 					// don't log the shutdown exceptions
 					if (!LodUtil.isInterruptOrReject(exception))
 					{
-						LOGGER.error("Error generating data for section " + taskPos, exception);
+						LOGGER.error("Error generating data for pos: " + DhSectionPos.toString(taskPos), exception);
 					}
 					
 					newTaskGroup.group.worldGenTasks.forEach(worldGenTask -> worldGenTask.future.complete(WorldGenResult.CreateFail()));
@@ -383,11 +410,11 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 					newTaskGroup.group.worldGenTasks.forEach(worldGenTask -> worldGenTask.future.complete(WorldGenResult.CreateSuccess(DhSectionPos.encode(granularity, DhSectionPos.getX(taskPos), DhSectionPos.getZ(taskPos)))));
 				}
 				boolean worked = this.inProgressGenTasksByLodPos.remove(taskPos, newTaskGroup);
-				LodUtil.assertTrue(worked);
+				LodUtil.assertTrue(worked, "Unable to find in progress generator task with position ["+DhSectionPos.toString(taskPos)+"]");
 			}
 			catch (Exception e)
 			{
-				LOGGER.error("Unexpected error completing world gen task: "+taskPos, e);
+				LOGGER.error("Unexpected error completing world gen task at pos: ["+DhSectionPos.toString(taskPos)+"].", e);
 			}
 		});
 		
@@ -430,8 +457,8 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 			case VANILLA_CHUNKS: 
 			{
 				return this.generator.generateChunks(
-					chunkPosMin.x,
-					chunkPosMin.z,
+					chunkPosMin.getX(),
+					chunkPosMin.getZ(),
 					granularity,
 					targetDataDetail,
 					generatorMode,
@@ -441,7 +468,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 						try
 						{
 							IChunkWrapper chunk = WRAPPER_FACTORY.createChunkWrapper(generatedObjectArray);
-							FullDataSourceV2 dataSource = LodDataBuilder.createGeneratedDataSource(chunk);
+							FullDataSourceV2 dataSource = LodDataBuilder.createFromChunk(chunk);
 							LodUtil.assertTrue(dataSource != null);
 							chunkDataConsumer.accept(dataSource);
 						}
@@ -456,8 +483,8 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 			case API_CHUNKS: 
 			{
 				return this.generator.generateApiChunks(
-					chunkPosMin.x,
-					chunkPosMin.z,
+					chunkPosMin.getX(),
+					chunkPosMin.getZ(),
 					granularity,
 					targetDataDetail,
 					generatorMode,
@@ -466,10 +493,10 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 					{
 						try
 						{
-							FullDataSourceV2 dataSource = LodDataBuilder.createFromApiChunkData(dataPoints);
+							FullDataSourceV2 dataSource = LodDataBuilder.createFromApiChunkData(dataPoints, this.generator.runApiChunkValidation());
 							chunkDataConsumer.accept(dataSource);
 						}
-						catch (DataCorruptedException e)
+						catch (DataCorruptedException | IllegalArgumentException e)
 						{
 							LOGGER.error("World generator returned a corrupt chunk. Error: [" + e.getMessage() + "]. World generator disabled.", e);
 							Config.Client.Advanced.WorldGenerator.enableDistantGeneration.set(false);
@@ -496,8 +523,8 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 	// getters / setters //
 	//===================//
 	
-	public int getWaitingTaskCount() { return this.waitingTasks.size(); }
-	public int getInProgressTaskCount() { return this.inProgressGenTasksByLodPos.size(); }
+	@Override public int getWaitingTaskCount() { return this.waitingTasks.size(); }
+	@Override public int getInProgressTaskCount() { return this.inProgressGenTasksByLodPos.size(); }
 	
 	@Override
 	public byte lowestDataDetail() { return this.lowestDataDetail; }
@@ -509,13 +536,15 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 	@Override
 	public void setEstimatedTotalTaskCount(int newEstimate) { this.estimatedTotalTaskCount = newEstimate; }
 	
+	@Override public void addDebugMenuStringsToList(List<String> messageList) { }
+	
 	
 	
 	//==========//
 	// shutdown //
 	//==========//
 	
-	public CompletableFuture<Void> startClosing(boolean cancelCurrentGeneration, boolean alsoInterruptRunning)
+	@Override public CompletableFuture<Void> startClosingAsync(boolean cancelCurrentGeneration, boolean alsoInterruptRunning)
 	{
 		LOGGER.info("Closing world gen queue");
 		this.queueingThread.shutdownNow();
@@ -566,7 +595,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		
 		if (this.generatorClosingFuture == null)
 		{
-			this.startClosing(true, true);
+			this.startClosingAsync(true, true);
 		}
 		LodUtil.assertTrue(this.generatorClosingFuture != null);
 		
@@ -642,13 +671,17 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		{
 			index = 4 * X * X - X - Y;
 			if (X < Y)
+			{
 				index = index - 2 * (X - Y);
+			}
 		}
 		else
 		{
 			index = 4 * Y * Y - X - Y;
 			if (X < Y)
+			{
 				index = index + 2 * (X - Y);
+			}
 		}
 		
 		return index;

core/src/main/java/com/seibel/distanthorizons/core/generation/tasks/IWorldGenTaskTracker.java

@@ -21,6 +21,7 @@ package com.seibel.distanthorizons.core.generation.tasks;
 
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 
+import javax.annotation.Nullable;
 import java.util.function.Consumer;
 
 /**
@@ -32,6 +33,7 @@ public interface IWorldGenTaskTracker
 	/** Returns true if the task hasn't been garbage collected. */
 	boolean isMemoryAddressValid();
 	
-	Consumer<FullDataSourceV2> getChunkDataConsumer();
+	@Nullable
+	Consumer<FullDataSourceV2> getDataSourceConsumer();
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/generation/tasks/WorldGenTaskGroup.java

@@ -51,7 +51,7 @@ public final class WorldGenTaskGroup
 		while (tasks.hasNext())
 		{
 			WorldGenTask task = tasks.next();
-			Consumer<FullDataSourceV2> chunkDataConsumer = task.taskTracker.getChunkDataConsumer();
+			Consumer<FullDataSourceV2> chunkDataConsumer = task.taskTracker.getDataSourceConsumer();
 			if (chunkDataConsumer == null)
 			{
 				tasks.remove();

core/src/main/java/com/seibel/distanthorizons/core/jar/DarkModeDetector.java

@@ -103,9 +103,13 @@ public class DarkModeDetector
 		{
 //            System.out.println(de);
 			if (de.contains("gnome-session")) // Gnome uses GTK
+			{
 				return GTKChecker();
+			}
 			if (de.contains("plasma_session")) // KDE plasma uses QT
+			{
 				return QTChecker();
+			}
 		}
 		return GTKChecker(); // GTK works best with non plasma desktops (desktops includes window managers)
 	}
@@ -134,7 +138,9 @@ public class DarkModeDetector
 			while (themeLine != null)
 			{ // Go through each line till you find "KWinPalette\activeBackground"
 				if (themeLine.contains("KWinPalette\\activeBackground"))
+				{
 					break;
+				}
 				themeLine = reader.readLine();
 			}
 			reader.close();
@@ -145,9 +151,13 @@ public class DarkModeDetector
 			short g = (short) Integer.parseInt("" + themeLine.charAt(index + 3) + themeLine.charAt(index + 4), 16);
 			short b = (short) Integer.parseInt("" + themeLine.charAt(index + 5) + themeLine.charAt(index + 6), 16);
 			if ((r + g + b) / 2 >= 128)
+			{
 				return false;
+			}
 			else
+			{
 				return true;
+			}
 		}
 		catch (Exception e)
 		{
@@ -170,7 +180,9 @@ public class DarkModeDetector
 				while ((actualReadLine = reader.readLine()) != null)
 				{
 					if (stringBuilder.length() != 0)
+					{
 						stringBuilder.append('\n');
+					}
 					stringBuilder.append(actualReadLine);
 				}
 			}

core/src/main/java/com/seibel/distanthorizons/core/level/AbstractDhLevel.java

@@ -19,23 +19,16 @@
 
 package com.seibel.distanthorizons.core.level;
 
-import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup;
 import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiChunkModifiedEvent;
-import com.seibel.distanthorizons.api.objects.math.DhApiVec3f;
-import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox;
-import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading;
-import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
-import com.seibel.distanthorizons.core.dataObjects.transformers.ChunkToLodBuilder;
 import com.seibel.distanthorizons.core.file.fullDatafile.DelayedFullDataSourceSaveCache;
+import com.seibel.distanthorizons.core.generation.DhLightingEngine;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.renderer.generic.BeaconRenderHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.CloudRenderHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
-import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory;
 import com.seibel.distanthorizons.core.sql.dto.BeaconBeamDTO;
 import com.seibel.distanthorizons.core.sql.dto.ChunkHashDTO;
 import com.seibel.distanthorizons.core.sql.repo.BeaconBeamRepo;
@@ -49,18 +42,14 @@ import org.jetbrains.annotations.Nullable;
 import java.io.File;
 import java.sql.SQLException;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
 
 public abstract class AbstractDhLevel implements IDhLevel
 {
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	
-	public final ChunkToLodBuilder chunkToLodBuilder;
-	
 	/** if this is null then the other handler is probably null too, but just in case */
 	@Nullable
 	public ChunkHashRepo chunkHashRepo;
@@ -68,9 +57,10 @@ public abstract class AbstractDhLevel implements IDhLevel
 	@Nullable
 	public BeaconBeamRepo beaconBeamRepo;
 	
-	protected final DelayedFullDataSourceSaveCache delayedFullDataSourceSaveCache = new DelayedFullDataSourceSaveCache(this::onDataSourceSave, 2_000);
+	protected final DelayedFullDataSourceSaveCache delayedFullDataSourceSaveCache = new DelayedFullDataSourceSaveCache(this::onDataSourceSave, 500);
 	/** contains the {@link DhChunkPos} for each {@link DhSectionPos} that are queued to save via {@link AbstractDhLevel#delayedFullDataSourceSaveCache} */
 	protected final ConcurrentHashMap<Long, HashSet<DhChunkPos>> updatedChunkPosSetBySectionPos = new ConcurrentHashMap<>();
+	protected final ConcurrentHashMap<DhChunkPos, Integer> updatedChunkHashesByChunkPos = new ConcurrentHashMap<>();
 	
 	/** Will be null if clouds shouldn't be rendered for this level. */
 	@Nullable
@@ -83,10 +73,7 @@ public abstract class AbstractDhLevel implements IDhLevel
 	// constructor //
 	//=============//
 	
-	protected AbstractDhLevel() 
-	{ 
-		this.chunkToLodBuilder = new ChunkToLodBuilder();
-	}
+	protected AbstractDhLevel() {  }
 	
 	/** 
 	 * Creating the repos requires access to the level file, which isn't
@@ -126,11 +113,15 @@ public abstract class AbstractDhLevel implements IDhLevel
 		GenericObjectRenderer genericRenderer = this.getGenericRenderer();
 		if (genericRenderer != null)
 		{
-			// only add clouds for certain dimension types
-			if (!this.getLevelWrapper().hasCeiling()
-					&& !this.getLevelWrapper().getDimensionType().isTheEnd())
+			// only client levels can render clouds
+			if (this instanceof IDhClientLevel)
 			{
-				this.cloudRenderHandler = new CloudRenderHandler(this, genericRenderer);
+				// only add clouds for certain dimension types
+				if (!this.getLevelWrapper().hasCeiling()
+						&& !this.getLevelWrapper().getDimensionType().isTheEnd())
+				{
+					this.cloudRenderHandler = new CloudRenderHandler((IDhClientLevel)this, genericRenderer);
+				}
 			}
 			
 			
@@ -152,7 +143,7 @@ public abstract class AbstractDhLevel implements IDhLevel
 	public int getUnsavedDataSourceCount() { return this.delayedFullDataSourceSaveCache.getUnsavedCount(); }
 	
 	@Override
-	public void updateChunkAsync(IChunkWrapper chunkWrapper)
+	public void updateChunkAsync(IChunkWrapper chunkWrapper, int chunkHash)
 	{
 		FullDataSourceV2 dataSource = FullDataSourceV2.createFromChunk(chunkWrapper);
 		if (dataSource == null)
@@ -171,6 +162,7 @@ public abstract class AbstractDhLevel implements IDhLevel
 			chunkPosSet.add(chunkWrapper.getChunkPos());
 			return chunkPosSet;
 		});
+		this.updatedChunkHashesByChunkPos.put(chunkWrapper.getChunkPos(), chunkHash);
 		
 		// batch updates to reduce overhead when flying around or breaking/placing a lot of blocks in an area
 		this.delayedFullDataSourceSaveCache.queueDataSourceForUpdateAndSave(dataSource);
@@ -178,6 +170,12 @@ public abstract class AbstractDhLevel implements IDhLevel
 	
 	private void onDataSourceSave(FullDataSourceV2 fullDataSource)
 	{
+		// block lights should have been populated at the chunkWrapper stage
+		// waiting to populate the data source's skylight at this stage prevents re-lighting and
+		// allows us to reduce cross-chunk lighting issues by lighting the whole 4x4 LOD at once 
+		DhLightingEngine.INSTANCE.bakeDataSourceSkyLight(fullDataSource, this.hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT);
+		
+		
 		this.updateDataSourcesAsync(fullDataSource).thenRun(() -> 
 		{
 			HashSet<DhChunkPos> updatedChunkPosSet = this.updatedChunkPosSetBySectionPos.remove(fullDataSource.getPos());
@@ -185,9 +183,16 @@ public abstract class AbstractDhLevel implements IDhLevel
 			{
 				for (DhChunkPos chunkPos : updatedChunkPosSet)
 				{
+					// save after the data source has been updated to prevent saving the hash without the associated datasource
+					Integer chunkHash = this.updatedChunkHashesByChunkPos.remove(chunkPos);
+					if (this.chunkHashRepo != null && chunkHash != null)
+					{
+						this.chunkHashRepo.save(new ChunkHashDTO(chunkPos, chunkHash));
+					}
+					
 					ApiEventInjector.INSTANCE.fireAllEvents(
 							DhApiChunkModifiedEvent.class,
-							new DhApiChunkModifiedEvent.EventParam(this.getLevelWrapper(), chunkPos.x, chunkPos.z));
+							new DhApiChunkModifiedEvent.EventParam(this.getLevelWrapper(), chunkPos.getX(), chunkPos.getZ()));
 				}
 			}
 		});
@@ -212,14 +217,6 @@ public abstract class AbstractDhLevel implements IDhLevel
 		ChunkHashDTO dto = this.chunkHashRepo.getByKey(pos);
 		return (dto != null) ? dto.chunkHash : 0;
 	}
-	@Override
-	public void setChunkHash(DhChunkPos pos, int chunkHash)
-	{
-		if (this.chunkHashRepo != null)
-		{
-			this.chunkHashRepo.save(new ChunkHashDTO(pos, chunkHash));
-		}
-	}
 	
 	
 	
@@ -228,11 +225,12 @@ public abstract class AbstractDhLevel implements IDhLevel
 	//=================//
 	
 	@Override
-	public void setBeaconBeamsForChunk(DhChunkPos chunkPos, List<BeaconBeamDTO> newBeamList)
+	public void updateBeaconBeamsForChunk(IChunkWrapper chunkToUpdate, ArrayList<IChunkWrapper> nearbyChunkList)
 	{
 		if (this.beaconRenderHandler != null)
 		{
-			this.beaconRenderHandler.setBeaconBeamsForChunk(chunkPos, newBeamList);
+			List<BeaconBeamDTO> activeBeamList = chunkToUpdate.getAllActiveBeacons(nearbyChunkList);
+			this.beaconRenderHandler.setBeaconBeamsForChunk(chunkToUpdate.getChunkPos(), activeBeamList);
 		}
 	}
 	
@@ -262,8 +260,6 @@ public abstract class AbstractDhLevel implements IDhLevel
 	@Override
 	public void close() 
 	{ 
-		this.chunkToLodBuilder.close();
-		
 		if (this.chunkHashRepo != null)
 		{
 			this.chunkHashRepo.close();

core/src/main/java/com/seibel/distanthorizons/core/level/ClientLevelModule.java

@@ -27,7 +27,7 @@ import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.file.AbstractDataSourceHandler;
 import com.seibel.distanthorizons.core.file.fullDatafile.FullDataSourceProviderV2;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.render.LodQuadTree;
 import com.seibel.distanthorizons.core.render.RenderBufferHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
@@ -126,9 +126,9 @@ public class ClientLevelModule implements Closeable, AbstractDataSourceHandler.I
 		
 		boolean isBuffersDirty = false;
 		EDhApiDebugRendering newDebugRendering = Config.Client.Advanced.Debugging.debugRendering.get();
-		if (newDebugRendering != lastDebugRendering)
+		if (newDebugRendering != this.lastDebugRendering)
 		{
-			lastDebugRendering = newDebugRendering;
+			this.lastDebugRendering = newDebugRendering;
 			isBuffersDirty = true;
 		}
 		if (isBuffersDirty)
@@ -225,7 +225,7 @@ public class ClientLevelModule implements Closeable, AbstractDataSourceHandler.I
 		}
 	}
 	
-	public void close()
+	@Override public void close()
 	{
 		// shutdown the renderer
 		ClientRenderState ClientRenderState = this.ClientRenderStateRef.get();
@@ -258,6 +258,8 @@ public class ClientLevelModule implements Closeable, AbstractDataSourceHandler.I
 	
 	public void clearRenderCache()
 	{
+		this.clientLevel.getClientLevelWrapper().clearBlockColorCache();
+		
 		ClientRenderState ClientRenderState = this.ClientRenderStateRef.get();
 		if (ClientRenderState != null && ClientRenderState.quadtree != null)
 		{

core/src/main/java/com/seibel/distanthorizons/core/level/DhClientLevel.java

@@ -20,15 +20,27 @@
 package com.seibel.distanthorizons.core.level;
 
 import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
+import com.seibel.distanthorizons.core.config.AppliedConfigState;
+import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.file.fullDatafile.FullDataSourceProviderV2;
 import com.seibel.distanthorizons.core.file.fullDatafile.RemoteFullDataSourceProvider;
 import com.seibel.distanthorizons.core.file.structure.AbstractSaveStructure;
+import com.seibel.distanthorizons.core.generation.RemoteWorldRetrievalQueue;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
+import com.seibel.distanthorizons.core.multiplayer.client.ClientNetworkState;
+import com.seibel.distanthorizons.core.multiplayer.client.SyncOnLoginRequestQueue;
+import com.seibel.distanthorizons.core.network.event.ScopedNetworkEventSource;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataPartialUpdateMessage;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
 import com.seibel.distanthorizons.core.render.RenderBufferHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
+import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV2DTO;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
@@ -36,6 +48,8 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.Nullable;
 
+import javax.annotation.CheckForNull;
+import java.awt.*;
 import java.io.File;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -44,25 +58,58 @@ import java.util.concurrent.CompletableFuture;
 public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 {
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	
 	public final ClientLevelModule clientside;
 	public final IClientLevelWrapper levelWrapper;
 	public final AbstractSaveStructure saveStructure;
 	public final RemoteFullDataSourceProvider dataFileHandler;
 	
+	@CheckForNull
+	private final ClientNetworkState networkState;
+	@Nullable
+	private final ScopedNetworkEventSource networkEventSource;
+	
+	public final WorldGenModule worldGenModule;
+	public final AppliedConfigState<Boolean> worldGeneratorEnabledConfig;
+	
+	@Nullable
+	private final SyncOnLoginRequestQueue syncOnLoginRequestQueue;
+	
 	
 	
 	//=============//
 	// constructor //
 	//=============//
 	
-	public DhClientLevel(AbstractSaveStructure saveStructure, IClientLevelWrapper clientLevelWrapper) { this(saveStructure, clientLevelWrapper, null, true); }
-	public DhClientLevel(AbstractSaveStructure saveStructure, IClientLevelWrapper clientLevelWrapper, @Nullable File fullDataSaveDirOverride, boolean enableRendering)
+	public DhClientLevel(AbstractSaveStructure saveStructure, IClientLevelWrapper clientLevelWrapper, @Nullable ClientNetworkState networkState) { this(saveStructure, clientLevelWrapper, null, true, networkState); }
+	public DhClientLevel(AbstractSaveStructure saveStructure, IClientLevelWrapper clientLevelWrapper, @Nullable File fullDataSaveDirOverride, boolean enableRendering, @Nullable ClientNetworkState networkState)
 	{
+		if (saveStructure.getFullDataFolder(clientLevelWrapper).mkdirs())
+		{
+			LOGGER.warn("unable to create data folder.");
+		}
 		this.levelWrapper = clientLevelWrapper;
 		this.levelWrapper.setParentLevel(this);
 		this.saveStructure = saveStructure;
-		this.dataFileHandler = new RemoteFullDataSourceProvider(this, saveStructure, fullDataSaveDirOverride);
+		
+		this.networkState = networkState;
+		if (this.networkState != null)
+		{
+			this.networkEventSource = new ScopedNetworkEventSource(this.networkState.getSession());
+			this.syncOnLoginRequestQueue = new SyncOnLoginRequestQueue(this, this.networkState);
+			this.registerNetworkHandlers();
+		}
+		else
+		{
+			this.networkEventSource = null;
+			this.syncOnLoginRequestQueue = null;
+		}
+		
+		this.dataFileHandler = new RemoteFullDataSourceProvider(this, saveStructure, fullDataSaveDirOverride, this.syncOnLoginRequestQueue);
+		this.worldGeneratorEnabledConfig = new AppliedConfigState<>(Config.Client.Advanced.WorldGenerator.enableDistantGeneration);
+		this.worldGenModule = new WorldGenModule(this);
+		
 		this.clientside = new ClientLevelModule(this);
 		
 		this.createAndSetSupportingRepos(this.dataFileHandler.repo.databaseFile);
@@ -74,6 +121,30 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 			LOGGER.info("Started DHLevel for " + this.levelWrapper + " with saves at " + this.saveStructure);
 		}
 	}
+	private void registerNetworkHandlers()
+	{
+		assert this.networkEventSource != null;
+		assert this.networkState != null;
+		
+		this.networkEventSource.registerHandler(FullDataPartialUpdateMessage.class, message ->
+		{
+			try
+			{
+				FullDataSourceV2DTO dataSourceDto = this.networkState.decodeDataSourceAndReleaseBuffer(message.payload);
+				
+				if (!message.isSameLevelAs(this.levelWrapper))
+				{
+					return;
+				}
+				
+				this.updateDataSourcesAsync(dataSourceDto.createPooledDataSource(this.levelWrapper));
+			}
+			catch (Exception e)
+			{
+				LOGGER.error("Error while updating full data source", e);
+			}
+		});
+	}
 	
 	
 	
@@ -86,8 +157,12 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	{
 		try
 		{
-			this.chunkToLodBuilder.tick();
 			this.clientside.clientTick();
+			
+			if (this.syncOnLoginRequestQueue != null)
+			{
+				this.syncOnLoginRequestQueue.tick(new DhBlockPos2D(MC_CLIENT.getPlayerBlockPos()));
+			}
 		}
 		catch (Exception e)
 		{
@@ -95,6 +170,53 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 		}
 	}
 	
+	@Override
+	public void worldGenTick()
+	{
+		ClientNetworkState networkState = this.networkState;
+		
+		boolean isClientUsable = false, isAllowedDimension = false;
+		if (networkState != null)
+		{
+			isClientUsable = networkState.isReady();
+			isAllowedDimension = MC_CLIENT.getWrappedClientLevel() == this.levelWrapper;
+		}
+		
+		boolean shouldDoWorldGen = isClientUsable
+				&& networkState.sessionConfig.isDistantGenerationEnabled()
+				&& isAllowedDimension
+				&& this.clientside.isRendering();
+		
+		boolean isWorldGenRunning = this.worldGenModule.isWorldGenRunning();
+		if (shouldDoWorldGen && !isWorldGenRunning)
+		{
+			// start world gen
+			this.worldGenModule.startWorldGen(this.dataFileHandler, new WorldGenState(this, networkState));
+			
+			// populate the queue based on the current rendering tree
+			ClientLevelModule.ClientRenderState renderState = this.clientside.ClientRenderStateRef.get();
+			renderState.quadtree.leafNodeIterator().forEachRemaining(node -> {
+				this.dataFileHandler.getAsync(node.sectionPos);
+			});
+		}
+		else if (!shouldDoWorldGen && isWorldGenRunning)
+		{
+			// stop world gen
+			this.worldGenModule.stopWorldGen(this.dataFileHandler);
+		}
+		
+		if (this.worldGenModule.isWorldGenRunning())
+		{
+			this.worldGenModule.worldGenTick(new DhBlockPos2D(MC_CLIENT.getPlayerBlockPos()));
+		}
+	}
+	
+	
+	
+	//===========//
+	// rendering //
+	//===========//
+	
 	@Override
 	public void render(DhApiRenderParam renderEventParam, IProfilerWrapper profiler)
 	{ this.clientside.render(renderEventParam, profiler); }
@@ -105,12 +227,31 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	
 	
 	
-	//================//
-	// level handling //
-	//================//
+	//===========//
+	// world gen //
+	//===========//
 	
 	@Override
-	public int computeBaseColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper block) { return this.levelWrapper.computeBaseColor(pos, biome, block); }
+	public void onWorldGenTaskComplete(long pos)
+	{
+		DebugRenderer.makeParticle(
+				new DebugRenderer.BoxParticle(
+						new DebugRenderer.Box(pos, 128f, 156f, 0.09f, Color.red.darker()),
+						0.2, 32f
+				)
+		);
+		
+		this.clientside.reloadPos(pos);
+	}
+	
+	
+	
+	//=========//
+	// getters //
+	//=========//
+	
+	@Override
+	public int computeBaseColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper block) { return this.levelWrapper.getBlockColor(pos, biome, block); }
 	
 	@Override
 	public IClientLevelWrapper getClientLevelWrapper() { return this.levelWrapper; }
@@ -127,10 +268,34 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	@Override
 	public int getMinY() { return this.levelWrapper.getMinHeight(); }
 	
+	@Override
+	public FullDataSourceProviderV2 getFullDataProvider() { return this.dataFileHandler; }
+	
+	@Override
+	public AbstractSaveStructure getSaveStructure() { return this.saveStructure; }
+	
+	@Override
+	public boolean hasSkyLight() { return this.levelWrapper.hasSkyLight(); }
+	
+	@Override
+	public GenericObjectRenderer getGenericRenderer() { return this.clientside.genericRenderer; }
+	@Override
+	public RenderBufferHandler getRenderBufferHandler()
+	{
+		ClientLevelModule.ClientRenderState renderState = this.clientside.ClientRenderStateRef.get();
+		return (renderState != null) ? renderState.renderBufferHandler : null;
+	}
+	
+	
+	
+	//===========//
+	// debugging //
+	//===========//
+	
 	@Override
 	public void addDebugMenuStringsToList(List<String> messageList)
 	{
-		String dimName = this.levelWrapper.getDimensionType().getDimensionName();
+		String dimName = this.levelWrapper.getDimensionName();
 		boolean rendering = this.clientside.isRendering();
 		messageList.add("["+dimName+"] rendering: "+(rendering ? "yes" : "no"));
 		
@@ -153,11 +318,39 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 		{
 			messageList.add("  Migration Failed");
 		}
+		
+		
+		// world gen
+		this.worldGenModule.addDebugMenuStringsToList(messageList);
+		if (this.syncOnLoginRequestQueue != null)
+		{
+			assert this.networkState != null;
+			if (this.networkState.sessionConfig.getSynchronizeOnLogin())
+			{
+				this.syncOnLoginRequestQueue.addDebugMenuStringsToList(messageList);
+			}
+		}
 	}
 	
+	
+	
+	//==========//
+	// shutdown //
+	//==========//
+	
 	@Override
 	public void close()
 	{
+		if (this.worldGenModule != null)
+		{
+			this.worldGenModule.close();
+		}
+		
+		if (this.networkEventSource != null)
+		{
+			this.networkEventSource.close();
+		}
+		
 		this.levelWrapper.setParentLevel(null);
 		this.clientside.close();
 		super.close();
@@ -165,23 +358,18 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 		LOGGER.info("Closed [" + DhClientLevel.class.getSimpleName() + "] for [" + this.levelWrapper + "]");
 	}
 	
-	@Override
-	public FullDataSourceProviderV2 getFullDataProvider() { return this.dataFileHandler; }
-	
-	@Override
-	public AbstractSaveStructure getSaveStructure() { return this.saveStructure; }
-	
-	@Override
-	public boolean hasSkyLight() { return this.levelWrapper.hasSkyLight(); }
 	
 	
-	@Override
-	public GenericObjectRenderer getGenericRenderer() { return this.clientside.genericRenderer; }
-	@Override
-	public RenderBufferHandler getRenderBufferHandler()
+	//================//
+	// helper classes //
+	//================//
+	
+	private static class WorldGenState extends WorldGenModule.AbstractWorldGenState
 	{
-		ClientLevelModule.ClientRenderState renderState = this.clientside.ClientRenderStateRef.get();
-		return (renderState != null) ? renderState.renderBufferHandler : null;
+		WorldGenState(IDhClientLevel level, ClientNetworkState networkState)
+		{
+			this.worldGenerationQueue = new RemoteWorldRetrievalQueue(networkState, level);
+		}
 	}
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/level/DhClientServerLevel.java

@@ -28,8 +28,8 @@ import com.seibel.distanthorizons.core.render.RenderBufferHandler;
 import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
 import com.seibel.distanthorizons.core.file.structure.AbstractSaveStructure;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
-import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper;
@@ -95,10 +95,10 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 	{ this.clientside.renderDeferred(renderEventParam, profiler); }
 	
 	@Override
-	public void serverTick() { this.chunkToLodBuilder.tick(); }
+	public void serverTick() {  }
 	
 	@Override
-	public void doWorldGen()
+	public void worldGenTick()
 	{
 		this.serverside.worldGeneratorEnabledConfig.pollNewValue(); // if not called the get() line below may not 
 		boolean shouldDoWorldGen = this.serverside.worldGeneratorEnabledConfig.get() && this.clientside.isRendering();
@@ -146,7 +146,7 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 		}
 		else
 		{
-			return clientLevel.computeBaseColor(pos, biome, block);
+			return clientLevel.getBlockColor(pos, biome, block);
 		}
 	}
 	
@@ -154,15 +154,12 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 	public IClientLevelWrapper getClientLevelWrapper() { return MC_CLIENT.getWrappedClientLevel(); }
 	
 	@Override
-	public void clearRenderCache()
-	{
-		clientside.clearRenderCache();
-	}
+	public void clearRenderCache() { this.clientside.clearRenderCache(); }
 	
 	@Override
-	public IServerLevelWrapper getServerLevelWrapper() { return serverLevelWrapper; }
+	public IServerLevelWrapper getServerLevelWrapper() { return this.serverLevelWrapper; }
 	@Override
-	public ILevelWrapper getLevelWrapper() { return getServerLevelWrapper(); }
+	public ILevelWrapper getLevelWrapper() { return this.getServerLevelWrapper(); }
 	
 	@Override
 	public FullDataSourceProviderV2 getFullDataProvider() { return this.serverside.fullDataFileHandler; }
@@ -170,7 +167,7 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 	@Override
 	public AbstractSaveStructure getSaveStructure()
 	{
-		return serverside.saveStructure;
+		return this.serverside.saveStructure;
 	}
 	
 	@Override
@@ -192,7 +189,7 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 	public void addDebugMenuStringsToList(List<String> messageList)
 	{
 		// header
-		String dimName = this.serverLevelWrapper.getDimensionType().getDimensionName();
+		String dimName = this.serverLevelWrapper.getDimensionName();
 		boolean rendering = this.clientside.isRendering();
 		messageList.add("["+dimName+"] rendering: "+(rendering ? "yes" : "no"));
 		
@@ -219,12 +216,7 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 		
 		
 		// world gen
-		WorldGenModule worldGenState = this.serverside.worldGenModule;
-		String worldGenDisplayString = worldGenState.getDebugMenuString();
-		if (worldGenDisplayString != null)
-		{
-			messageList.add(worldGenDisplayString);
-		}
+		this.serverside.worldGenModule.addDebugMenuStringsToList(messageList);
 	}
 	
 	

core/src/main/java/com/seibel/distanthorizons/core/level/DhServerLevel.java

@@ -19,33 +19,73 @@
 
 package com.seibel.distanthorizons.core.level;
 
+import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.file.fullDatafile.FullDataSourceProviderV2;
 import com.seibel.distanthorizons.core.file.structure.AbstractSaveStructure;
-import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.multiplayer.server.RemotePlayerConnectionHandler;
+import com.seibel.distanthorizons.core.multiplayer.server.ServerPlayerState;
+import com.seibel.distanthorizons.core.network.exceptions.InvalidLevelException;
+import com.seibel.distanthorizons.core.network.exceptions.RequestRejectedException;
+import com.seibel.distanthorizons.core.network.messages.ILevelRelatedMessage;
+import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
+import com.seibel.distanthorizons.core.network.messages.AbstractTrackableMessage;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataPartialUpdateMessage;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataPayload;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataSourceRequestMessage;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataSourceResponseMessage;
+import com.seibel.distanthorizons.core.network.messages.requests.CancelMessage;
+import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.RenderBufferHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
+import com.seibel.distanthorizons.core.util.LodUtil;
+import com.seibel.distanthorizons.core.util.math.Vec3d;
+import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
+import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IServerPlayerWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
+import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import javax.annotation.CheckForNull;
 import java.util.List;
-import java.util.concurrent.CompletableFuture;
+import java.util.Map;
+import java.util.concurrent.*;
 
 public class DhServerLevel extends AbstractDhLevel implements IDhServerLevel
 {
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final ConfigBasedLogger NETWORK_LOGGER = new ConfigBasedLogger(LogManager.getLogger(),
+			() -> Config.Client.Advanced.Logging.logNetworkEvent.get());
+	
+	/** 1 Mebibyte minus 576 bytes for other info */
+	public static final int FULL_DATA_SPLIT_SIZE_IN_BYTES = 1_048_000;
+	
 	public final ServerLevelModule serverside;
 	private final IServerLevelWrapper serverLevelWrapper;
 	
+	private final RemotePlayerConnectionHandler remotePlayerConnectionHandler;
+	
+	/**
+	 * This queue is used for ensuring fair generation speed for each player. <br>
+	 * Every tick the first player gets used for centering generation, and then is immediately moved into the back of the queue. <br>
+	 * TODO only add players that actually have something to generate
+	 */
+	private final ConcurrentLinkedQueue<IServerPlayerWrapper> worldGenPlayerCenteringQueue = new ConcurrentLinkedQueue<>();
+	
+	private final ConcurrentMap<Long, DataSourceRequestGroup> requestGroupByPos = new ConcurrentHashMap<>();
+	private final ConcurrentMap<Long, DataSourceRequestGroup> requestGroupByFutureId = new ConcurrentHashMap<>();
+	
 	
 	
 	//=============//
 	// constructor //
 	//=============//
 	
-	public DhServerLevel(AbstractSaveStructure saveStructure, IServerLevelWrapper serverLevelWrapper)
+	public DhServerLevel(AbstractSaveStructure saveStructure, IServerLevelWrapper serverLevelWrapper, RemotePlayerConnectionHandler remotePlayerConnectionHandler)
 	{
 		if (saveStructure.getFullDataFolder(serverLevelWrapper).mkdirs())
 		{
@@ -56,77 +96,393 @@ public class DhServerLevel extends AbstractDhLevel implements IDhServerLevel
 		this.createAndSetSupportingRepos(this.serverside.fullDataFileHandler.repo.databaseFile);
 		this.runRepoReliantSetup();
 		
-		LOGGER.info("Started DHLevel for {} with saves at {}", serverLevelWrapper, saveStructure);
+		LOGGER.info("Started DHLevel for ["+serverLevelWrapper+"] at ["+saveStructure+"].");
+	
+		this.remotePlayerConnectionHandler = remotePlayerConnectionHandler;
 	}
 	
 	
 	
-	//=========//
-	// methods //
-	//=========//
-	
-	public void serverTick() { this.chunkToLodBuilder.tick(); }
+	//=======//
+	// ticks //
+	//=======//
 	
 	@Override
-	public CompletableFuture<Void> updateDataSourcesAsync(FullDataSourceV2 data) { return this.getFullDataProvider().updateDataSourceAsync(data); }
-	
-	@Override
-	public int getMinY() { return getLevelWrapper().getMinHeight(); }
-	
-	@Override
-	public void close()
+	public void serverTick()
 	{
-		super.close();
-		serverside.close();
-		LOGGER.info("Closed DHLevel for {}", getLevelWrapper());
+		// Send finished data source requests
+		for (Map.Entry<Long, DataSourceRequestGroup> entry : this.requestGroupByPos.entrySet())
+		{
+			DataSourceRequestGroup requestGroup = entry.getValue();
+			
+			if (requestGroup.fullDataSource == null)
+			{
+				continue;
+			}
+			
+			NETWORK_LOGGER.debug("["+this.serverLevelWrapper.getDimensionName()+"] Fulfilled request group ["+entry.getKey()+"]");
+			
+			// Make this group unavailable for adding into
+			this.requestGroupByPos.remove(entry.getKey());
+			requestGroup.requestRemoveSemaphore.acquireUninterruptibly(Short.MAX_VALUE);
+			requestGroup.requestAddSemaphore.acquireUninterruptibly(Short.MAX_VALUE);
+			
+			ThreadPoolExecutor executor = ThreadPoolUtil.getNetworkCompressionExecutor();
+			if (executor == null)
+			{
+				LOGGER.warn("Unable to send FullDataSourceResponseMessage - getNetworkCompressionExecutor() is null");
+				continue;
+			}
+			CompletableFuture.runAsync(() ->
+			{
+				FullDataPayload payload = new FullDataPayload(requestGroup.fullDataSource);
+				for (FullDataSourceRequestMessage msg : requestGroup.requestMessages.values())
+				{
+					this.requestGroupByFutureId.remove(msg.futureId);
+					
+					ServerPlayerState serverPlayerState = this.remotePlayerConnectionHandler.getConnectedPlayer(msg.serverPlayer());
+					if (serverPlayerState == null)
+					{
+						continue;
+					}
+					
+					serverPlayerState.getRateLimiterSet(this).generationRequestRateLimiter.release();
+					payload.splitAndSend(FULL_DATA_SPLIT_SIZE_IN_BYTES, msg.getSession()::sendMessage);
+					msg.sendResponse(new FullDataSourceResponseMessage(payload));
+				}
+			}, executor);
+		}
 	}
 	
 	@Override
-	public void doWorldGen()
+	public void worldGenTick()
 	{
 		boolean shouldDoWorldGen = true; //todo;
-		boolean isWorldGenRunning = serverside.worldGenModule.isWorldGenRunning();
+		boolean isWorldGenRunning = this.serverside.worldGenModule.isWorldGenRunning();
 		if (shouldDoWorldGen && !isWorldGenRunning)
 		{
 			// start world gen
-			serverside.worldGenModule.startWorldGen(serverside.fullDataFileHandler, new ServerLevelModule.WorldGenState(this));
+			this.serverside.worldGenModule.startWorldGen(this.serverside.fullDataFileHandler, new ServerLevelModule.WorldGenState(this));
 		}
 		else if (!shouldDoWorldGen && isWorldGenRunning)
 		{
 			// stop world gen
-			serverside.worldGenModule.stopWorldGen(serverside.fullDataFileHandler);
+			this.serverside.worldGenModule.stopWorldGen(this.serverside.fullDataFileHandler);
 		}
 		
-		if (serverside.worldGenModule.isWorldGenRunning())
+		if (this.serverside.worldGenModule.isWorldGenRunning())
 		{
-			serverside.worldGenModule.worldGenTick(new DhBlockPos2D(0, 0)); // todo;
+			IServerPlayerWrapper firstPlayer = this.worldGenPlayerCenteringQueue.peek();
+			if (firstPlayer == null)
+			{
+				return;
+			}
+			
+			// Put first player in back before removing from front, so it can be removed by other thread without blocking
+			// - if it gets removed, remove() below will remove the item we just put instead
+			this.worldGenPlayerCenteringQueue.add(firstPlayer);
+			this.worldGenPlayerCenteringQueue.remove(firstPlayer);
+			
+			Vec3d position = firstPlayer.getPosition();
+			this.serverside.worldGenModule.worldGenTick(new DhBlockPos2D((int) position.x, (int) position.z));
 		}
 	}
 	
-	@Override
-	public IServerLevelWrapper getServerLevelWrapper() { return serverLevelWrapper; }
+	
+	
+	//==================//
+	// network handling //
+	//==================//
+	
+	public void registerNetworkHandlers(ServerPlayerState serverPlayerState)
+	{
+		serverPlayerState.networkSession.registerHandler(FullDataSourceRequestMessage.class, (message) ->
+		{
+			if (!this.messagePlayerInThisLevel(message))
+			{
+				// we can't handle players in other levels, don't continue
+				return;
+			}
+			
+			
+			ServerPlayerState.RateLimiterSet rateLimiterSet = serverPlayerState.getRateLimiterSet(this);
+			
+			if (message.clientTimestamp == null)
+			{
+				this.queueWorldGenForRequestMessage(serverPlayerState, message, rateLimiterSet);
+			}
+			else
+			{
+				this.queueLodSyncForRequestMessage(serverPlayerState, message, rateLimiterSet);
+			}
+		});
+		
+		
+		serverPlayerState.networkSession.registerHandler(CancelMessage.class, msg ->
+		{
+			DataSourceRequestGroup requestGroup = this.requestGroupByFutureId.remove(msg.futureId);
+			if (requestGroup == null)
+			{
+				return;
+			}
+			
+			// If this fails, the group is being removed and completing cancellation is not necessary
+			if (requestGroup.requestRemoveSemaphore.tryAcquire())
+			{
+				// Prevent adding requests in case the group will be removed by this cancellation
+				requestGroup.requestAddSemaphore.acquireUninterruptibly(Short.MAX_VALUE);
+				requestGroup.requestRemoveSemaphore.release();
+				
+				serverPlayerState.getRateLimiterSet(this).generationRequestRateLimiter.release();
+				
+				FullDataSourceRequestMessage requestMessage = requestGroup.requestMessages.remove(msg.futureId);
+				if (requestGroup.requestMessages.isEmpty())
+				{
+					NETWORK_LOGGER.debug("["+this.serverLevelWrapper.getDimensionName()+"] Cancelled request group ["+DhSectionPos.toString(requestMessage.sectionPos)+"].");
+					this.requestGroupByPos.remove(requestMessage.sectionPos);
+					this.serverside.fullDataFileHandler.removeRetrievalRequestIf(pos -> pos == requestMessage.sectionPos);
+				}
+				else
+				{
+					requestGroup.requestAddSemaphore.release(Short.MAX_VALUE);
+				}
+			}
+		});
+	}
+	private void queueLodSyncForRequestMessage(ServerPlayerState serverPlayerState, FullDataSourceRequestMessage message, ServerPlayerState.RateLimiterSet rateLimiterSet)
+	{
+		if (!serverPlayerState.sessionConfig.getSynchronizeOnLogin())
+		{
+			message.sendResponse(new RequestRejectedException("Operation is disabled in config."));
+			return;
+		}
+		
+		if (!rateLimiterSet.syncOnLoginRateLimiter.tryAcquire(message))
+		{
+			return;
+		}
+		
+		
+		// the client timestamp will be null if we want to retrieve the LOD regardless of when it was last updated
+		long clientTimestamp = (message.clientTimestamp != null) ? message.clientTimestamp : -1;
+		// the server timestamp will be null if no LOD data exists for this position
+		Long serverTimestamp = this.serverside.fullDataFileHandler.getTimestampForPos(message.sectionPos);
+		if (serverTimestamp == null 
+			|| serverTimestamp <= clientTimestamp)
+		{
+			// either no data exists to sync, or the client is already up to date
+			rateLimiterSet.syncOnLoginRateLimiter.release();
+			message.sendResponse(new FullDataSourceResponseMessage(null));
+			return;
+		}
+		
+		
+		
+		ThreadPoolExecutor executor = ThreadPoolUtil.getNetworkCompressionExecutor();
+		if (executor == null)
+		{
+			// shouldn't normally happen, but just in case
+			LOGGER.warn("Unable to send FullDataSourceResponseMessage - getNetworkCompressionExecutor() is null");
+			return;
+		}
+		
+		this.serverside.fullDataFileHandler.getAsync(message.sectionPos).thenAcceptAsync(fullDataSource ->
+		{
+			rateLimiterSet.syncOnLoginRateLimiter.release();
+			
+			FullDataPayload payload = new FullDataPayload(fullDataSource);
+			payload.splitAndSend(FULL_DATA_SPLIT_SIZE_IN_BYTES, message.getSession()::sendMessage);
+			message.sendResponse(new FullDataSourceResponseMessage(payload));
+		}, executor);
+	}
+	private void queueWorldGenForRequestMessage(ServerPlayerState serverPlayerState, FullDataSourceRequestMessage message, ServerPlayerState.RateLimiterSet rateLimiterSet)
+	{
+		if (!serverPlayerState.sessionConfig.isDistantGenerationEnabled())
+		{
+			message.sendResponse(new RequestRejectedException("Operation is disabled in config."));
+			return;
+		}
+		
+		if (!rateLimiterSet.generationRequestRateLimiter.tryAcquire(message))
+		{
+			return;
+		}
+		
+		while (true)
+		{
+			DataSourceRequestGroup requestGroup = this.requestGroupByPos.computeIfAbsent(message.sectionPos, pos ->
+			{
+				DataSourceRequestGroup newGroup = new DataSourceRequestGroup();
+				this.tryFulfillDataSourceRequestGroup(newGroup, pos);
+				NETWORK_LOGGER.debug("["+this.serverLevelWrapper.getDimensionName()+"] Created request group for pos ["+DhSectionPos.toString(pos)+"].");
+				return newGroup;
+			});
+			
+			// If this fails, loop until either a permit is acquired or the group is removed to create another one
+			if (!requestGroup.requestAddSemaphore.tryAcquire())
+			{
+				Thread.yield();
+				continue;
+			}
+			
+			this.requestGroupByFutureId.put(message.futureId, requestGroup);
+			requestGroup.requestMessages.put(message.futureId, message);
+			requestGroup.requestAddSemaphore.release();
+			break;
+		}
+	}
+	
+	
+	/** May send an error message in response if the message is a {@link AbstractTrackableMessage} */
+	private <T extends AbstractNetworkMessage> boolean messagePlayerInThisLevel(T message)
+	{
+		if (!(message instanceof ILevelRelatedMessage))
+		{
+			LodUtil.assertNotReach("Received message ["+ILevelRelatedMessage.class.getSimpleName()+"] does not implement ["+message.getClass().getSimpleName()+"]");
+		}
+		
+		// Only handle requests for this level
+		if (!((ILevelRelatedMessage) message).isSameLevelAs(this.getServerLevelWrapper()))
+		{
+			return false;
+		}
+		
+		LodUtil.assertTrue(message.getSession().serverPlayer != null);
+		
+		// Check if the player is in this dimension,
+		// since handling multiple dimensions isn't allowed
+		if (message.getSession().serverPlayer.getLevel() != this.getLevelWrapper())
+		{
+			// If the message can be replied to - reply with an error, otherwise just ignore
+			if (message instanceof AbstractTrackableMessage)
+			{
+				((AbstractTrackableMessage) message).sendResponse(
+					new InvalidLevelException(
+						"Generation not allowed. " +
+						"Requested dimension: ["+((ILevelRelatedMessage) message).getLevelName()+"], " +
+						"player dimension: ["+message.getSession().serverPlayer.getLevel().getDimensionName()+"], " +
+						"handler dimension: ["+this.getLevelWrapper().getDimensionName()+"]"
+					)
+				);
+			}
+			
+			return false;
+		}
+		
+		
+		return true;
+	}
+	
+	
+	
+	//===========//
+	// world gen //
+	//===========//
 	
 	@Override
-	public ILevelWrapper getLevelWrapper() { return getServerLevelWrapper(); }
+	public void onWorldGenTaskComplete(long pos)
+	{
+		DataSourceRequestGroup requestGroup = this.requestGroupByPos.get(pos);
+		if (requestGroup != null)
+		{
+			this.tryFulfillDataSourceRequestGroup(requestGroup, pos);
+		}
+	}
+	
+	private void tryFulfillDataSourceRequestGroup(DataSourceRequestGroup requestGroup, long pos)
+	{
+		this.serverside.fullDataFileHandler.getAsync(pos).thenAccept(fullDataSource -> 
+		{
+			if (this.serverside.fullDataFileHandler.isFullyGenerated(fullDataSource.columnGenerationSteps))
+			{
+				requestGroup.fullDataSource = fullDataSource;
+			}
+			else
+			{
+				this.serverside.fullDataFileHandler.queuePositionForRetrieval(pos);
+			}
+		});
+	}
+	
+	
+	
+	//=================//
+	// player handling //
+	//=================//
+	
+	public void addPlayer(IServerPlayerWrapper serverPlayer) { this.worldGenPlayerCenteringQueue.add(serverPlayer); }
+	public void removePlayer(IServerPlayerWrapper serverPlayer) { this.worldGenPlayerCenteringQueue.remove(serverPlayer); }
+	
+	
+	
+	@Override
+	public CompletableFuture<Void> updateDataSourcesAsync(FullDataSourceV2 data)
+	{
+		if (!Config.Client.Advanced.Multiplayer.ServerNetworking.enableRealTimeUpdates.get())
+		{
+			return this.getFullDataProvider().updateDataSourceAsync(data);
+		}
+		
+		ThreadPoolExecutor executor = ThreadPoolUtil.getNetworkCompressionExecutor();
+		if (executor == null)
+		{
+			LOGGER.warn("Unable to send FullDataPartialUpdateMessage - getNetworkCompressionExecutor() is null");
+			return this.getFullDataProvider().updateDataSourceAsync(data);
+		}
+		CompletableFuture.runAsync(() ->
+		{
+			FullDataPayload payload = new FullDataPayload(data);
+			for (ServerPlayerState serverPlayerState : this.remotePlayerConnectionHandler.getConnectedPlayers())
+			{
+				if (serverPlayerState.getServerPlayer().getLevel() != this.serverLevelWrapper)
+				{
+					continue;
+				}
+				
+				if (!serverPlayerState.sessionConfig.isRealTimeUpdatesEnabled())
+				{
+					continue;
+				}
+				
+				Vec3d playerPosition = serverPlayerState.getServerPlayer().getPosition();
+				int distanceFromPlayer = DhSectionPos.getManhattanBlockDistance(data.getPos(), new DhBlockPos2D((int) playerPosition.x, (int) playerPosition.z)) / 16;
+				if (distanceFromPlayer >= serverPlayerState.getServerPlayer().getViewDistance() 
+					&& distanceFromPlayer <= serverPlayerState.sessionConfig.getRenderDistanceRadius())
+				{
+					payload.splitAndSend(FULL_DATA_SPLIT_SIZE_IN_BYTES, serverPlayerState.networkSession::sendMessage);
+					serverPlayerState.networkSession.sendMessage(new FullDataPartialUpdateMessage(this.serverLevelWrapper, payload));
+				}
+			}
+		}, executor);
+		
+		
+		return this.getFullDataProvider().updateDataSourceAsync(data);
+	}
+	
+	
+	
+	//=========//
+	// getters //
+	//=========//
+	
+	@Override
+	public int getMinY() { return this.getLevelWrapper().getMinHeight(); }
+	
+	@Override
+	public IServerLevelWrapper getServerLevelWrapper() { return this.serverLevelWrapper; }
+	
+	@Override
+	public ILevelWrapper getLevelWrapper() { return this.getServerLevelWrapper(); }
 	
 	@Override
 	public FullDataSourceProviderV2 getFullDataProvider() { return this.serverside.fullDataFileHandler; }
 	
 	@Override
-	public AbstractSaveStructure getSaveStructure()
-	{
-		return serverside.saveStructure;
-	}
+	public AbstractSaveStructure getSaveStructure() { return this.serverside.saveStructure; }
 	
 	@Override
 	public boolean hasSkyLight() { return this.serverLevelWrapper.hasSkyLight(); }
 	
-	@Override
-	public void onWorldGenTaskComplete(long pos)
-	{
-		//TODO: Send packet to client
-	}
-	
 	@Override
 	public GenericObjectRenderer getGenericRenderer() 
 	{ 
@@ -141,6 +497,7 @@ public class DhServerLevel extends AbstractDhLevel implements IDhServerLevel
 	}
 	
 	
+	
 	//===========//
 	// debugging //
 	//===========//
@@ -148,8 +505,48 @@ public class DhServerLevel extends AbstractDhLevel implements IDhServerLevel
 	@Override
 	public void addDebugMenuStringsToList(List<String> messageList)
 	{
-		String dimName = this.serverLevelWrapper.getDimensionType().getDimensionName();
+		String dimName = this.serverLevelWrapper.getDimensionName();
 		messageList.add("["+dimName+"]");
 	}
 	
+	
+	
+	//==========//
+	// shutdown //
+	//==========//
+	
+	@Override
+	public void close()
+	{
+		super.close();
+		this.serverside.close();
+		LOGGER.info("Closed DHLevel for ["+this.getLevelWrapper()+"].");
+	}
+	
+	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	private static class DataSourceRequestGroup
+	{
+		public final ConcurrentMap<Long, FullDataSourceRequestMessage> requestMessages = new ConcurrentHashMap<>();
+
+		@CheckForNull
+		public FullDataSourceV2 fullDataSource;
+		
+		/**
+		 * These semaphores prevent a given thread from accidentally locking on the same group
+		 * multiple times, as the semaphore is tied to the given thread. <br>
+		 * Reentrant Lock isn't used since it would allow the thread to lock on the same group. <br>
+		 * the Short.MAX_VALUE is just a very large number that should be larger than the number of
+		 * threads we'll have.
+		 */
+		public final Semaphore requestAddSemaphore = new Semaphore(Short.MAX_VALUE, true);
+		/** @see DataSourceRequestGroup#requestAddSemaphore */
+		public final Semaphore requestRemoveSemaphore = new Semaphore(Short.MAX_VALUE, true);
+		
+	}
+	
 }

core/src/main/java/com/seibel/distanthorizons/core/level/IDhClientLevel.java

@@ -20,7 +20,7 @@
 package com.seibel.distanthorizons.core.level;
 
 import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;

core/src/main/java/com/seibel/distanthorizons/core/level/IDhLevel.java

@@ -21,20 +21,23 @@ package com.seibel.distanthorizons.core.level;
 
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.file.fullDatafile.FullDataSourceProviderV2;
+import com.seibel.distanthorizons.core.file.fullDatafile.GeneratedFullDataSourceProvider;
 import com.seibel.distanthorizons.core.file.structure.AbstractSaveStructure;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.render.RenderBufferHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
-import com.seibel.distanthorizons.core.sql.dto.BeaconBeamDTO;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
-public interface IDhLevel extends AutoCloseable
+public interface IDhLevel extends AutoCloseable, GeneratedFullDataSourceProvider.IOnWorldGenCompleteListener
 {
+	void worldGenTick();
+	
 	int getMinY();
 	
 	/**
@@ -45,11 +48,10 @@ public interface IDhLevel extends AutoCloseable
 	
 	/** @return 0 if no hash is known */
 	int getChunkHash(DhChunkPos pos);
-	void setChunkHash(DhChunkPos pos, int chunkHash);
-	void updateChunkAsync(IChunkWrapper chunk);
+	void updateChunkAsync(IChunkWrapper chunk, int newChunkHash);
 	
 	void loadBeaconBeamsInPos(long pos);
-	void setBeaconBeamsForChunk(DhChunkPos chunkPos, List<BeaconBeamDTO> beamList);
+	void updateBeaconBeamsForChunk(IChunkWrapper chunkToUpdate, ArrayList<IChunkWrapper> nearbyChunkList);
 	void unloadBeaconBeamsInPos(long pos);
 	
 	FullDataSourceProviderV2 getFullDataProvider();

core/src/main/java/com/seibel/distanthorizons/core/level/IDhServerLevel.java

@@ -21,9 +21,10 @@ package com.seibel.distanthorizons.core.level;
 
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
 
-public interface IDhServerLevel extends IDhWorldGenLevel
+public interface IDhServerLevel extends IDhLevel
 {
     void serverTick();
 	
     IServerLevelWrapper getServerLevelWrapper();
+	
 }

core/src/main/java/com/seibel/distanthorizons/core/level/IKeyedClientLevelManager.java

@@ -19,7 +19,7 @@
 
 package com.seibel.distanthorizons.core.level;
 
-import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.coreapi.interfaces.dependencyInjection.IBindable;
 
 /**
@@ -28,15 +28,11 @@ import com.seibel.distanthorizons.coreapi.interfaces.dependencyInjection.IBindab
  */
 public interface IKeyedClientLevelManager extends IBindable
 {
+	IServerKeyedClientLevel getServerKeyedLevel();
 	/** Called when a client level is wrapped by a ServerEnhancedClientLevel, for integration into mod internals. */
-	void setServerKeyedLevel(IServerKeyedClientLevel clientLevel);
-	IServerKeyedClientLevel getOverrideWrapper();
+	IServerKeyedClientLevel setServerKeyedLevel(IClientLevelWrapper clientLevel, String levelKey);
 	
-	/** Returns a new instance of a ServerEnhancedClientLevel. */
-	IServerKeyedClientLevel getServerKeyedLevel(ILevelWrapper level, String serverLevelKey);
-	
-	/** Sets the LOD engine to use the override wrapper, if the server has communication enabled. */
-	void setUseOverrideWrapper(boolean useOverrideWrapper);
-	boolean getUseOverrideWrapper();
+	void clearKeyedLevel();
+	boolean hasLevelSet();
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/level/WorldGenModule.java

@@ -23,13 +23,18 @@ import com.seibel.distanthorizons.core.file.fullDatafile.GeneratedFullDataSource
 import com.seibel.distanthorizons.core.generation.IFullDataSourceRetrievalQueue;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.logging.f3.F3Screen;
-import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import org.apache.logging.log4j.Logger;
 
 import java.io.Closeable;
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicReference;
 
+/**
+ * Handles both single-player/server-side world gen and client side LOD requests.
+ * TODO rename
+ */
 public class WorldGenModule implements Closeable
 {
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
@@ -137,20 +142,22 @@ public class WorldGenModule implements Closeable
 	
 	public boolean isWorldGenRunning() { return this.worldGenStateRef.get() != null; }
 	
-	public String getDebugMenuString()
+	/** mutates a list so it can be added to an existing {@link IDhLevel}'s debug list  */
+	public void addDebugMenuStringsToList(List<String> messageList)
 	{
 		AbstractWorldGenState worldGenState = this.worldGenStateRef.get();
 		if (worldGenState == null)
 		{
-			return null;
+			return;
 		}
 		
 		
 		String waitingCountStr = F3Screen.NUMBER_FORMAT.format(worldGenState.worldGenerationQueue.getWaitingTaskCount());
 		String inProgressCountStr = F3Screen.NUMBER_FORMAT.format(worldGenState.worldGenerationQueue.getInProgressTaskCount());
 		String totalCountEstimateStr = F3Screen.NUMBER_FORMAT.format(worldGenState.worldGenerationQueue.getEstimatedTotalTaskCount());
-		
-		return "World Gen Tasks: "+waitingCountStr+"/"+totalCountEstimateStr+" (in progress: "+inProgressCountStr+")";
+		messageList.add("World Gen Tasks: "+waitingCountStr+"/"+totalCountEstimateStr+" (in progress: "+inProgressCountStr+")");
+
+		worldGenState.worldGenerationQueue.addDebugMenuStringsToList(messageList);
 	}
 	
 	
@@ -166,18 +173,18 @@ public class WorldGenModule implements Closeable
 		
 		CompletableFuture<Void> closeAsync(boolean doInterrupt)
 		{
-			return this.worldGenerationQueue.startClosing(true, doInterrupt)
-					.exceptionally(ex ->
-							{
-								LOGGER.error("Error closing generation queue", ex);
-								return null;
-							}
-					).thenRun(this.worldGenerationQueue::close)
-					.exceptionally(ex ->
-					{
-						LOGGER.error("Error closing world gen", ex);
-						return null;
-					});
+			return this.worldGenerationQueue.startClosingAsync(true, doInterrupt)
+				.exceptionally(e ->
+				{
+					LOGGER.error("Error during first stage of generation queue shutdown, Error: ["+e.getMessage()+"].", e);
+					return null;
+				}
+				).thenRun(this.worldGenerationQueue::close)
+				.exceptionally(e ->
+				{
+					LOGGER.error("Error during second stage of generation queue shutdown, Error: ["+e.getMessage()+"].", e);
+					return null;
+				});
 		}
 		
 		/** @param targetPosForGeneration the position that world generation should be centered around */

core/src/main/java/com/seibel/distanthorizons/core/logging/ConfigBasedLogger.java

@@ -101,7 +101,8 @@ public class ConfigBasedLogger
 			else
 				logger.log(logLevel, msgStr);
 		}
-		if (mode.levelForChat.isLessSpecificThan(level))
+		
+		if (MC != null && mode.levelForChat.isLessSpecificThan(level))
 		{
 			if (param.length > 0 && param[param.length - 1] instanceof Throwable)
 				MC.logToChat(level, msgStr + "\n" +

core/src/main/java/com/seibel/distanthorizons/core/logging/f3/F3Screen.java

@@ -20,12 +20,14 @@
 package com.seibel.distanthorizons.core.logging.f3;
 
 import com.seibel.distanthorizons.core.api.internal.SharedApi;
+import com.seibel.distanthorizons.core.jar.ModJarInfo;
 import com.seibel.distanthorizons.core.level.IDhLevel;
 import com.seibel.distanthorizons.core.render.RenderBufferHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
 import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
 import com.seibel.distanthorizons.core.world.AbstractDhWorld;
 import com.seibel.distanthorizons.coreapi.ModInfo;
+import com.seibel.distanthorizons.coreapi.util.StringUtil;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -48,7 +50,8 @@ public class F3Screen
 	/**
 	 * F3 menu example: <br>
 	 <code>
-	 Distant Horizons v: 2.1.1-a-dev <br><br>
+	 Distant Horizons v: 2.1.1-a-dev <br> 
+	 Build: 7e163ce6 (main) <br><br>
 	 
 	 Queued chunk updates: 0 / 1000 <br>
 	 World Gen Tasks: 40/5304, (in progress: 7) <br><br>
@@ -60,9 +63,9 @@ public class F3Screen
 	 Parent Update #: 12 <br><br>
 	 
 	 Client_Server World with 3 levels <br>
-	 [overworld] rendering: Active <br>
-	 [the_end] rendering: Inactive <br>
-	 [the_nether] rendering: Inactive <br><br>
+	 [minecraft:overworld] rendering: Active <br>
+	 [minecraft:the_end] rendering: Inactive <br>
+	 [minecraft:the_nether] rendering: Inactive <br><br>
 	 
 	 VBO Render Count: 199/374 <br>
 	 </code>
@@ -72,6 +75,9 @@ public class F3Screen
 		ThreadPoolExecutor worldGenPool = ThreadPoolUtil.getWorldGenExecutor();
 		ThreadPoolExecutor fileHandlerPool = ThreadPoolUtil.getFileHandlerExecutor();
 		ThreadPoolExecutor updatePool = ThreadPoolUtil.getUpdatePropagatorExecutor();
+		ThreadPoolExecutor lodBuilderPool = ThreadPoolUtil.getChunkToLodBuilderExecutor();
+		ThreadPoolExecutor bufferBuilderPool = ThreadPoolUtil.getBufferBuilderExecutor();
+		ThreadPoolExecutor bufferUploaderPool = ThreadPoolUtil.getBufferUploaderExecutor();
 		
 		AbstractDhWorld world = SharedApi.getAbstractDhWorld();
 		Iterable<? extends IDhLevel> levelIterator = world.getAllLoadedLevels();
@@ -79,17 +85,24 @@ public class F3Screen
 		
 		messageList.add("");
 		messageList.add(ModInfo.READABLE_NAME+": "+ModInfo.VERSION);
+		if (ModInfo.IS_DEV_BUILD)
+		{
+			messageList.add("Build: " + StringUtil.shortenString(ModJarInfo.Git_Commit, 8) + " (" + ModJarInfo.Git_Branch + ")");
+		}
 		messageList.add("");
 		// thread pools
 		messageList.add(getThreadPoolStatString("World Gen", worldGenPool));//"World Gen Tasks: 40/5304, (in progress: 7)");
 		messageList.add(getThreadPoolStatString("File Handler", fileHandlerPool));
 		messageList.add(getThreadPoolStatString("Update Propagator", updatePool));
+		messageList.add(getThreadPoolStatString("LOD Builder", lodBuilderPool));
+		messageList.add(getThreadPoolStatString("Buffer Builder", bufferBuilderPool));
+		messageList.add(getThreadPoolStatString("Buffer Uploader", bufferUploaderPool));
 		messageList.add("");
 		// chunk updates
 		messageList.add(SharedApi.INSTANCE.getDebugMenuString());
 		messageList.add("");
 		// world / levels
-		messageList.add(world.GetDebugMenuString());
+		world.addDebugMenuStringsToList(messageList);
 		for (IDhLevel level : levelIterator)
 		{
 			level.addDebugMenuStringsToList(messageList);

core/src/main/java/com/seibel/distanthorizons/core/multiplayer/client/AbstractFullDataNetworkRequestQueue.java

@@ -0,0 +1,415 @@
+package com.seibel.distanthorizons.core.multiplayer.client;
+
+import com.google.common.base.Stopwatch;
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.config.types.ConfigEntry;
+import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
+import com.seibel.distanthorizons.core.level.DhServerLevel;
+import com.seibel.distanthorizons.core.level.IDhClientLevel;
+import com.seibel.distanthorizons.core.logging.ConfigBasedSpamLogger;
+import com.seibel.distanthorizons.core.network.exceptions.InvalidLevelException;
+import com.seibel.distanthorizons.core.network.exceptions.RateLimitedException;
+import com.seibel.distanthorizons.core.network.exceptions.RequestRejectedException;
+import com.seibel.distanthorizons.core.network.session.SessionClosedException;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataSourceRequestMessage;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataSourceResponseMessage;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
+import com.seibel.distanthorizons.core.pos.DhSectionPos;
+import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
+import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
+import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV2DTO;
+import com.seibel.distanthorizons.core.util.LodUtil;
+import com.seibel.distanthorizons.core.util.TimerUtil;
+import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
+import com.seibel.distanthorizons.core.util.ratelimiting.SupplierBasedRateLimiter;
+import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
+import org.apache.logging.log4j.LogManager;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+import java.awt.*;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+
+public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRenderable, AutoCloseable
+{
+	private static final ConfigBasedSpamLogger LOGGER = new ConfigBasedSpamLogger(LogManager.getLogger(),
+			() -> Config.Client.Advanced.Logging.logNetworkEvent.get(), 3);
+	
+	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
+	
+	private static final Timer TASK_FINISH_TIMER = TimerUtil.CreateTimer("RequestTaskFinishTimer");
+	
+	private static final int MAX_RETRY_ATTEMPTS = 3;
+	
+	protected static final long SHUTDOWN_TIMEOUT_SECONDS = 5;
+	
+	
+	
+	public final ClientNetworkState networkState;
+	protected final IDhClientLevel level;
+	private final boolean changedOnly;
+	
+	private volatile CompletableFuture<Void> closingFuture = null;
+	
+	protected final ConcurrentMap<Long, RequestQueueEntry> waitingTasksBySectionPos = new ConcurrentHashMap<>();
+	/**
+	 * This semaphore prevents a given thread from accidentally locking on the same group
+	 * multiple times, as the semaphore is tied to the given thread. <br>
+	 * Reentrant Lock isn't used since it would allow the thread to lock on the same group. <br>
+	 * the Short.MAX_VALUE is just a very large number that should be larger than the number of
+	 * threads we'll have.
+	 */
+	private final Semaphore pendingTasksSemaphore = new Semaphore(Short.MAX_VALUE, true);
+	
+	private final AtomicInteger finishedRequests = new AtomicInteger();
+	private final AtomicInteger failedRequests = new AtomicInteger();
+	private final ConfigEntry<Boolean> showDebugWireframeConfig;
+	
+	private final SupplierBasedRateLimiter<Void> rateLimiter = new SupplierBasedRateLimiter<>(this::getRequestRateLimit);
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public AbstractFullDataNetworkRequestQueue(
+			ClientNetworkState networkState, IDhClientLevel level, 
+			boolean changedOnly, ConfigEntry<Boolean> showDebugWireframeConfig)
+	{
+		this.networkState = networkState;
+		this.level = level;
+		this.changedOnly = changedOnly;
+		this.showDebugWireframeConfig = showDebugWireframeConfig;
+		DebugRenderer.register(this, this.showDebugWireframeConfig);
+	}
+	
+	
+	
+	//==================//
+	// abstract methods //
+	//==================//
+	
+	protected abstract int getRequestRateLimit();
+	
+	protected abstract String getQueueName();
+	
+	
+	
+	//====================//
+	// request submitting //
+	//====================//
+	
+	public CompletableFuture<Boolean> submitRequest(long sectionPos, Consumer<FullDataSourceV2> dataSourceConsumer)
+	{ return this.submitRequest(sectionPos, null, dataSourceConsumer); }
+	public CompletableFuture<Boolean> submitRequest(long sectionPos, @Nullable Long clientTimestamp, Consumer<FullDataSourceV2> dataSourceConsumer)
+	{
+		LodUtil.assertTrue(DhSectionPos.getDetailLevel(sectionPos) == DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL, "Only highest-detail sections are allowed.");
+		
+		RequestQueueEntry entry = new RequestQueueEntry(dataSourceConsumer, clientTimestamp);
+		entry.future.whenComplete((success, throwable) ->
+		{
+			this.waitingTasksBySectionPos.remove(sectionPos);
+			
+			this.finishedRequests.incrementAndGet();
+			if (!success || throwable != null)
+			{
+				this.failedRequests.incrementAndGet();
+			}
+		});
+		
+		this.waitingTasksBySectionPos.put(sectionPos, entry);
+		return entry.future;
+	}
+	
+	public synchronized boolean tick(DhBlockPos2D targetPos)
+	{
+		if (this.closingFuture != null || !this.networkState.isReady())
+		{
+			return false;
+		}
+		
+		// queue requests until the queue is full
+		while (this.getInProgressTaskCount() < this.getWaitingTaskCount()
+				&& this.getInProgressTaskCount() < this.getRequestRateLimit()
+				&& this.pendingTasksSemaphore.tryAcquire())
+		{
+			if (!this.rateLimiter.tryAcquire())
+			{
+				this.pendingTasksSemaphore.release();
+				break;
+			}
+			
+			this.sendNextRequest(targetPos);
+		}
+		
+		return true;
+	}
+	private void sendNextRequest(DhBlockPos2D targetPos)
+	{
+		Map.Entry<Long, RequestQueueEntry> mapEntry = this.waitingTasksBySectionPos.entrySet().stream()
+				.filter(task -> task.getValue().networkDataSourceFuture == null)
+				.min((x, y) -> posDistanceSquared(targetPos, x.getKey()) - posDistanceSquared(targetPos, y.getKey()))
+				.orElse(null);
+		
+		if (mapEntry == null)
+		{
+			this.pendingTasksSemaphore.release();
+			return;
+		}
+		
+		long sectionPos = mapEntry.getKey();
+		RequestQueueEntry entry = mapEntry.getValue();
+		
+		CompletableFuture<FullDataSourceResponseMessage> dataSourceFuture = this.networkState.getSession().sendRequest(
+				new FullDataSourceRequestMessage(this.level.getLevelWrapper(), sectionPos, entry.updateTimestamp),
+				FullDataSourceResponseMessage.class
+			);
+		entry.networkDataSourceFuture = dataSourceFuture;
+		dataSourceFuture.handle((response, throwable) ->
+		{
+			this.pendingTasksSemaphore.release();
+			
+			try
+			{
+				if (throwable != null)
+				{
+					throw throwable;
+				}
+				
+				if (response.payload != null)
+				{
+					FullDataSourceV2DTO dataSourceDto = this.networkState.decodeDataSourceAndReleaseBuffer(response.payload);
+					
+					ThreadPoolExecutor executor = ThreadPoolUtil.getNetworkCompressionExecutor();
+					if (executor == null)
+					{
+						LOGGER.warn("Unable to handle FullDataPayload - getNetworkCompressionExecutor() is null");
+						return null;
+					}
+					CompletableFuture.runAsync(() ->
+					{
+						try
+						{
+							FullDataSourceV2 fullDataSource = dataSourceDto.createPooledDataSource(this.level.getLevelWrapper());
+							entry.dataSourceConsumer.accept(fullDataSource);
+							FullDataSourceV2.DATA_SOURCE_POOL.returnPooledDataSource(fullDataSource);
+						}
+						catch (IOException | DataCorruptedException | InterruptedException e)
+						{
+							throw new RuntimeException(e);
+						}
+					}, executor);
+				}
+				else
+				{
+					LodUtil.assertTrue(this.changedOnly, "Received empty data source response for not changes-only request");
+				}
+			}
+			catch (InvalidLevelException | RequestRejectedException ignored)
+			{
+				// We're too late / some cases might trigger a bunch of expected rejections
+				return entry.future.complete(false);
+			}
+			catch (SessionClosedException | CancellationException ignored)
+			{
+				// Triggered when level is unloaded
+				return entry.future.cancel(false);
+			}
+			catch (RateLimitedException e)
+			{
+				LOGGER.warn("Rate limited by server, re-queueing task [" + DhSectionPos.toString(sectionPos) + "]: " + e.getMessage());
+				
+				// Skip all requests for 1 second
+				this.rateLimiter.acquireAll();
+				
+				entry.networkDataSourceFuture = null;
+				return null;
+			}
+			catch (Throwable e)
+			{
+				entry.retryAttempts--;
+				LOGGER.error("Error while fetching full data source, attempts left: {} / {}", entry.retryAttempts, MAX_RETRY_ATTEMPTS, e);
+				
+				// Retry logic
+				if (entry.retryAttempts > 0)
+				{
+					entry.networkDataSourceFuture = null;
+					return null;
+				}
+				else
+				{
+					return entry.future.complete(false);
+				}
+			}
+			
+			// Hack to work around a race condition
+			// If you finish the request too quickly, the section will never render
+			TASK_FINISH_TIMER.schedule(new TimerTask()
+			{
+				@Override
+				public void run()
+				{
+					entry.future.complete(true);
+				}
+			}, 10000);
+			return null;
+		});
+	}
+	
+	
+	
+	
+	//=========================================//
+	// IFullDataSourceRetrievalQueue overrides //
+	//=========================================//
+	
+	public void removeRetrievalRequestIf(DhSectionPos.ICancelablePrimitiveLongConsumer removeIf)
+	{
+		for (Map.Entry<Long, RequestQueueEntry> mapEntry : this.waitingTasksBySectionPos.entrySet())
+		{
+			long pos = mapEntry.getKey();
+			RequestQueueEntry entry = mapEntry.getValue();
+			
+			if (removeIf.accept(pos))
+			{
+				LOGGER.debug("Removing request  " + mapEntry.getKey() + "...");
+				
+				entry.future.cancel(false);
+				if (entry.networkDataSourceFuture != null)
+				{
+					entry.networkDataSourceFuture.cancel(false);
+				}
+			}
+		}
+	}
+	
+	public void addDebugMenuStringsToList(List<String> messageList)
+	{
+		messageList.add(this.getQueueName() + " [" + this.level.getClientLevelWrapper().getDimensionName() + "]");
+		messageList.add("Requests: " + this.finishedRequests + " / " + (this.getWaitingTaskCount() + this.finishedRequests.get()) + " (failed: " + this.failedRequests + ", rate limit: " + this.getRequestRateLimit() + ")");
+	}
+	
+	public int getWaitingTaskCount() { return this.waitingTasksBySectionPos.size(); }
+	public int getInProgressTaskCount() { return Short.MAX_VALUE - this.pendingTasksSemaphore.availablePermits(); }
+	
+	
+	
+	//==========//
+	// shutdown //
+	//==========//
+	
+	
+	public CompletableFuture<Void> startClosingAsync(boolean alsoInterruptRunning)
+	{
+		return this.closingFuture = CompletableFuture.runAsync(() -> {
+			Stopwatch stopwatch = Stopwatch.createStarted();
+			
+			do
+			{
+				for (RequestQueueEntry entry : this.waitingTasksBySectionPos.values())
+				{
+					entry.future.cancel(alsoInterruptRunning);
+					if (entry.networkDataSourceFuture != null && entry.networkDataSourceFuture.cancel(alsoInterruptRunning))
+					{
+						this.pendingTasksSemaphore.release();
+					}
+				}
+			}
+			while (!this.pendingTasksSemaphore.tryAcquire(Short.MAX_VALUE) && stopwatch.elapsed(TimeUnit.SECONDS) < SHUTDOWN_TIMEOUT_SECONDS);
+			
+			if (stopwatch.elapsed(TimeUnit.SECONDS) >= SHUTDOWN_TIMEOUT_SECONDS)
+			{
+				LOGGER.warn("The request queue [" + this.getQueueName() + "] for level [" + this.level.getLevelWrapper() + "] did not shutdown in [" + SHUTDOWN_TIMEOUT_SECONDS + "] seconds. Some unfinished tasks might be left hanging.");
+			}
+		});
+	}
+	
+	@Override
+	public void close()
+	{
+		DebugRenderer.unregister(this, this.showDebugWireframeConfig);
+	}
+	
+	
+	
+	//===========//
+	// debugging //
+	//===========//
+	
+	@Override
+	public void debugRender(DebugRenderer renderer)
+	{
+		if (MC_CLIENT.getWrappedClientLevel() != this.level.getClientLevelWrapper())
+		{
+			return;
+		}
+		
+		for (Map.Entry<Long, RequestQueueEntry> mapEntry : this.waitingTasksBySectionPos.entrySet())
+		{
+			renderer.renderBox(new DebugRenderer.Box(mapEntry.getKey(), -32f, 64f, 0.05f,
+					mapEntry.getValue().networkDataSourceFuture != null ? Color.red : Color.gray
+			));
+		}
+	}
+	
+	
+	
+	//================//
+	// helper methods //
+	//================//
+	
+	protected static int posDistanceSquared(DhBlockPos2D targetPos, long pos)
+	{ return (int) DhSectionPos.getCenterBlockPos(pos).distSquared(targetPos); }
+	
+	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	protected static class RequestQueueEntry
+	{
+		/** encapsulates the entire request, including client side queuing and the actual server request */
+		public final CompletableFuture<Boolean> future = new CompletableFuture<>();
+		public final Consumer<FullDataSourceV2> dataSourceConsumer;
+		/** will be null if we want to retrieve the LOD regardless of when it was last updated */
+		@Nullable
+		public final Long updateTimestamp;
+		
+		
+		/** Will be null until the request has been sent to the server */
+		@CheckForNull
+		public CompletableFuture<FullDataSourceResponseMessage> networkDataSourceFuture;
+		
+		/** when this reaches zero then the request will be canceled. */
+		public int retryAttempts = MAX_RETRY_ATTEMPTS;
+		
+		
+		
+		//=============//
+		// constructor //
+		//=============//
+		
+		public RequestQueueEntry(
+				Consumer<FullDataSourceV2> dataSourceConsumer,
+				@Nullable Long updateTimestamp)
+		{
+			this.dataSourceConsumer = dataSourceConsumer;
+			this.updateTimestamp = updateTimestamp;
+		}
+		
+	}
+	
+	
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/multiplayer/client/ClientNetworkState.java

@@ -0,0 +1,210 @@
+package com.seibel.distanthorizons.core.multiplayer.client;
+
+import com.google.common.cache.CacheBuilder;
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
+import com.seibel.distanthorizons.core.multiplayer.config.SessionConfig;
+import com.seibel.distanthorizons.core.network.INetworkObject;
+import com.seibel.distanthorizons.core.network.event.ScopedNetworkEventSource;
+import com.seibel.distanthorizons.core.network.event.internal.CloseInternalEvent;
+import com.seibel.distanthorizons.core.network.event.internal.IncompatibleMessageInternalEvent;
+import com.seibel.distanthorizons.core.network.messages.base.CurrentLevelKeyMessage;
+import com.seibel.distanthorizons.core.network.messages.base.SessionConfigMessage;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataSplitMessage;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataPartialUpdateMessage;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataPayload;
+import com.seibel.distanthorizons.core.network.session.NetworkSession;
+import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV2DTO;
+import com.seibel.distanthorizons.core.util.LodUtil;
+import com.seibel.distanthorizons.coreapi.ModInfo;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.CompositeByteBuf;
+import org.apache.logging.log4j.LogManager;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.Closeable;
+import java.util.List;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+
+public class ClientNetworkState implements Closeable
+{
+	protected static final ConfigBasedLogger LOGGER = new ConfigBasedLogger(LogManager.getLogger(),
+			() -> Config.Client.Advanced.Logging.logNetworkEvent.get());
+	
+	
+	private final ConcurrentMap<Integer, CompositeByteBuf> fullDataBufferById = CacheBuilder.newBuilder()
+			.expireAfterAccess(10, TimeUnit.SECONDS)
+			.<Integer, CompositeByteBuf>build()
+			.asMap();
+	
+	private final SessionConfig.AnyChangeListener configAnyChangeListener = new SessionConfig.AnyChangeListener(this::sendConfigMessage);
+	
+	
+	private final NetworkSession networkSession = new NetworkSession(null);
+	/**
+	 * Returns the client used by this instance. <p>
+	 * If you need to subscribe to any packet events, create an instance of {@link ScopedNetworkEventSource} using the returned instance.
+	 */
+	public NetworkSession getSession() { return this.networkSession; }
+	
+	public SessionConfig sessionConfig = new SessionConfig();
+	
+	private volatile boolean configReceived = false;
+	public boolean isReady() { return this.configReceived; }
+	
+	private EServerSupportStatus serverSupportStatus = EServerSupportStatus.NONE;
+	
+	/** Protocol version closest to supported by this mod version */
+	@Nullable
+	private Integer closestProtocolVersion;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public ClientNetworkState()
+	{
+		this.networkSession.registerHandler(IncompatibleMessageInternalEvent.class, event ->
+		{
+			if (this.closestProtocolVersion == null 
+				|| Math.abs(event.protocolVersion - ModInfo.PROTOCOL_VERSION) < this.closestProtocolVersion)
+			{
+				this.closestProtocolVersion = event.protocolVersion;
+			}
+		});
+		
+		this.networkSession.registerHandler(CurrentLevelKeyMessage.class, message ->
+		{
+			// we will also receive this message when we have full support
+			if (this.serverSupportStatus == EServerSupportStatus.NONE)
+			{
+				this.serverSupportStatus = EServerSupportStatus.LEVELS_ONLY;
+			}
+		});
+		
+		this.networkSession.registerHandler(SessionConfigMessage.class, message ->
+		{
+			this.serverSupportStatus = EServerSupportStatus.FULL;
+			
+			LOGGER.info("Connection config has been changed: ["+message.config+"].");
+			this.sessionConfig = message.config;
+			this.configReceived = true;
+		});
+		
+		this.networkSession.registerHandler(CloseInternalEvent.class, message ->
+		{
+			this.configReceived = false;
+		});
+		
+		this.networkSession.registerHandler(FullDataSplitMessage.class, message ->
+		{
+			if (message.isFirst)
+			{
+				CompositeByteBuf composite = this.fullDataBufferById.remove(message.bufferId);
+				if (composite != null)
+				{
+					composite.release();
+					LOGGER.debug("Released full data buffer ["+message.bufferId+"]: ["+composite+"]");
+				}
+			}
+			
+			CompositeByteBuf byteBuffer = this.fullDataBufferById.computeIfAbsent(message.bufferId, bufferId -> ByteBufAllocator.DEFAULT.compositeBuffer());
+			byteBuffer.addComponent(true, message.buffer);
+			LOGGER.debug("Full data buffer ["+message.bufferId+"]: ["+byteBuffer+"].");
+		});
+
+		this.networkSession.registerHandler(FullDataPartialUpdateMessage.class, msg ->
+		{
+			// Dummy handler to prevent unhandled message warnings
+		});
+	}
+	
+	
+	
+	//==============//
+	// send message //
+	//==============//
+	
+	public FullDataSourceV2DTO decodeDataSourceAndReleaseBuffer(FullDataPayload msg)
+	{
+		CompositeByteBuf compositeByteBuffer = this.fullDataBufferById.remove(msg.dtoBufferId);
+		LodUtil.assertTrue(compositeByteBuffer != null);
+		
+		try
+		{
+			return INetworkObject.decodeToInstance(FullDataSourceV2DTO.CreateEmptyDataSource(), compositeByteBuffer);
+		}
+		finally
+		{
+			compositeByteBuffer.release();
+		}
+	}
+	
+	public void sendConfigMessage()
+	{
+		this.configReceived = false;
+		this.getSession().sendMessage(new SessionConfigMessage(new SessionConfig()));
+	}
+	
+	
+	
+	//===========//
+	// debugging //
+	//===========//
+	
+	public void addDebugMenuStringsToList(List<String> messageList)
+	{
+		if (this.networkSession.isClosed())
+		{
+			messageList.add("NetworkSession closed: " + this.networkSession.getCloseReason().getMessage());
+			return;
+		}
+		
+		if (this.serverSupportStatus == EServerSupportStatus.NONE && this.closestProtocolVersion != null)
+		{
+			messageList.add("Incompatible protocol version: [" + this.closestProtocolVersion + "], required: [" + ModInfo.PROTOCOL_VERSION+ "]");
+			return;
+		}
+		
+		messageList.add(this.serverSupportStatus.message);
+	}
+	
+	
+	
+	//==========//
+	// shutdown //
+	//==========//
+	
+	@Override
+	public void close()
+	{
+		this.configAnyChangeListener.close();
+		this.networkSession.close();
+	}
+	
+	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	/**
+	 * NONE,        <br>
+	 * LEVELS_ONLY, <br>
+	 * FULL,        <br>
+	 */
+	private enum EServerSupportStatus
+	{
+		NONE("Server does not support DH"),
+		LEVELS_ONLY("Server supports shared level keys"),
+		FULL("Server has full DH support");
+		
+		public final String message;
+		
+		EServerSupportStatus(String message) { this.message = message; }
+		
+	}
+}

core/src/main/java/com/seibel/distanthorizons/core/multiplayer/client/SyncOnLoginRequestQueue.java

@@ -0,0 +1,57 @@
+package com.seibel.distanthorizons.core.multiplayer.client;
+
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.generation.RemoteWorldRetrievalQueue;
+import com.seibel.distanthorizons.core.level.IDhClientLevel;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
+
+/** 
+ * This queue only handles LOD updates for
+ * LODs that were changed when the player wasn't online
+ * and the player already loaded the LODs once.
+ * {@link RemoteWorldRetrievalQueue} is used for all other requests.
+ * 
+ * @see Config.Client.Advanced.Multiplayer.ServerNetworking#synchronizeOnLogin
+ * @see RemoteWorldRetrievalQueue
+ */
+public class SyncOnLoginRequestQueue extends AbstractFullDataNetworkRequestQueue
+{
+	//=============//
+	// constructor //
+	//=============//
+	
+	public SyncOnLoginRequestQueue(IDhClientLevel level, ClientNetworkState networkState)
+	{ super(networkState, level, true, Config.Client.Advanced.Debugging.DebugWireframe.showWorldGenQueue); }
+	
+	
+	
+	//=========//
+	// getters //
+	//=========//
+	
+	@Override
+	protected int getRequestRateLimit() { return this.networkState.sessionConfig.getSyncOnLoginRateLimit(); }
+	
+	@Override
+	protected String getQueueName() { return "Sync On Login Queue"; }
+	
+	
+	
+	//==================//
+	// request handling //
+	//==================//
+	
+	@Override
+	public boolean tick(DhBlockPos2D targetPos)
+	{
+		if (!this.networkState.sessionConfig.getSynchronizeOnLogin())
+		{
+			return false;
+		}
+		
+		return super.tick(targetPos);
+	}
+	
+	
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/multiplayer/config/SessionConfig.java

@@ -0,0 +1,184 @@
+package com.seibel.distanthorizons.core.multiplayer.config;
+
+import com.google.common.base.MoreObjects;
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.config.listeners.ConfigChangeListener;
+import com.seibel.distanthorizons.core.config.types.ConfigEntry;
+import com.seibel.distanthorizons.core.network.INetworkObject;
+import io.netty.buffer.ByteBuf;
+
+import java.io.Closeable;
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class SessionConfig implements INetworkObject
+{
+	private static final LinkedHashMap<String, Entry> CONFIG_ENTRIES = new LinkedHashMap<>();
+	
+	
+	private final LinkedHashMap<String, Object> values = new LinkedHashMap<>();
+	public SessionConfig constrainingConfig;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	static
+	{
+		// Note: config values are ordered by serversideShortName when transmitted
+		
+		registerConfigEntry(Config.Client.Advanced.Graphics.Quality.lodChunkRenderDistanceRadius, Math::min);
+		
+		registerConfigEntry(Config.Client.Advanced.WorldGenerator.enableDistantGeneration, (x, y) -> x && y);
+		registerConfigEntry(Config.Client.Advanced.Multiplayer.ServerNetworking.generationRequestRateLimit, Math::min);
+		
+		registerConfigEntry(Config.Client.Advanced.Multiplayer.ServerNetworking.enableRealTimeUpdates, (x, y) -> x && y);
+		
+		registerConfigEntry(Config.Client.Advanced.Multiplayer.ServerNetworking.synchronizeOnLogin, (x, y) -> x && y);
+		registerConfigEntry(Config.Client.Advanced.Multiplayer.ServerNetworking.syncOnLoginRateLimit, Math::min);
+	}
+	
+	public SessionConfig() {}
+	
+	
+	
+	//===============//
+	// public values //
+	//===============//
+	
+	public int getRenderDistanceRadius() { return this.getValue(Config.Client.Advanced.Graphics.Quality.lodChunkRenderDistanceRadius); }
+	public boolean isDistantGenerationEnabled() { return this.getValue(Config.Client.Advanced.WorldGenerator.enableDistantGeneration); }
+	public int getGenerationRequestRateLimit() { return this.getValue(Config.Client.Advanced.Multiplayer.ServerNetworking.generationRequestRateLimit); }
+	public boolean isRealTimeUpdatesEnabled() { return this.getValue(Config.Client.Advanced.Multiplayer.ServerNetworking.enableRealTimeUpdates); }
+	public boolean getSynchronizeOnLogin() { return this.getValue(Config.Client.Advanced.Multiplayer.ServerNetworking.synchronizeOnLogin); }
+	public int getSyncOnLoginRateLimit() { return this.getValue(Config.Client.Advanced.Multiplayer.ServerNetworking.syncOnLoginRateLimit); }
+	
+	
+	
+	//====================//
+	// entry registration //
+	//====================//
+	
+	private static <T> void registerConfigEntry(ConfigEntry<T> configEntry, BiFunction<T, T, T> valueConstrainer)
+	{
+		CONFIG_ENTRIES.put(Objects.requireNonNull(configEntry.getServersideShortName()), new Entry(configEntry, valueConstrainer));
+	}
+	
+	
+	
+	//==================//
+	// internal getters //
+	//==================//
+	
+	private <T> T getValue(ConfigEntry<T> configEntry) { return this.getValue(configEntry.getServersideShortName()); }
+	@SuppressWarnings("unchecked")
+	private <T> T getValue(String name)
+	{
+		Entry entry = CONFIG_ENTRIES.get(name);
+		
+		T value = (T) this.values.get(name);
+		if (value == null)
+		{
+			value = (T) entry.supplier.get();
+		}
+		
+		return (this.constrainingConfig != null
+				? (T) entry.valueConstrainer.apply(value, this.constrainingConfig.getValue(name))
+				: value);
+	}
+	
+	private Map<String, ?> getValues()
+	{
+		return CONFIG_ENTRIES.keySet().stream().collect(Collectors.toMap(
+				Function.identity(),
+				this::getValue,
+				(x, y) -> x,
+				LinkedHashMap::new
+		));
+	}
+	
+	
+	
+	//===============//
+	// serialization //
+	//===============//
+	
+	@Override
+	public void encode(ByteBuf outBuffer) { this.writeFixedLengthCollection(outBuffer, this.getValues().values()); }
+	
+	@Override
+	public void decode(ByteBuf inBuffer)
+	{
+		for (String key : CONFIG_ENTRIES.keySet())
+		{
+			Object currentValue = this.getValue(key);
+			Object newValue = Codec.getCodec(currentValue.getClass()).decode.apply(currentValue, inBuffer);
+			this.values.put(key, newValue);
+		}
+	}
+	
+	
+	
+	//================//
+	// base overrides //
+	//================//
+	
+	@Override
+	public String toString()
+	{
+		return MoreObjects.toStringHelper(this)
+				.add("values", this.getValues())
+				.toString();
+	}
+	
+	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	private static class Entry
+	{
+		public final ConfigEntry<Object> supplier;
+		public final BiFunction<Object, Object, Object> valueConstrainer;
+		
+		@SuppressWarnings("unchecked")
+		private <T> Entry(ConfigEntry<T> supplier, BiFunction<T, T, T> valueConstrainer)
+		{
+			this.supplier = (ConfigEntry<Object>) supplier;
+			this.valueConstrainer = (BiFunction<Object, Object, Object>) valueConstrainer;
+		}
+		
+	}
+	
+	/** fires if any config value was changed */
+	public static class AnyChangeListener implements Closeable
+	{
+		private final ArrayList<ConfigChangeListener<?>> changeListeners;
+		
+		public AnyChangeListener(Runnable runnable)
+		{
+			this.changeListeners = new ArrayList<>(CONFIG_ENTRIES.size());
+			for (Entry entry : CONFIG_ENTRIES.values())
+			{
+				this.changeListeners.add(new ConfigChangeListener<>(entry.supplier, ignored -> runnable.run()));
+			}
+		}
+		
+		@Override
+		public void close()
+		{
+			for (ConfigChangeListener<?> changeListener : this.changeListeners)
+			{
+				changeListener.close();
+			}
+			this.changeListeners.clear();
+		}
+		
+	}
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/multiplayer/server/RemotePlayerConnectionHandler.java

@@ -0,0 +1,85 @@
+package com.seibel.distanthorizons.core.multiplayer.server;
+
+import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
+import com.seibel.distanthorizons.core.network.session.NetworkSession;
+import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IServerPlayerWrapper;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Queue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ConcurrentMap;
+
+public class RemotePlayerConnectionHandler
+{
+	private final ConcurrentMap<IServerPlayerWrapper, ServerPlayerState> connectedPlayerStateByPlayerWrapper = new ConcurrentHashMap<>();
+	private final ConcurrentMap<IServerPlayerWrapper, Queue<AbstractNetworkMessage>> messageQueueByPlayerWrapper = new ConcurrentHashMap<>();
+	
+	
+	
+	//========================//
+	// player joining/leaving //
+	//========================//
+	
+	public ServerPlayerState registerJoinedPlayer(IServerPlayerWrapper serverPlayer)
+	{
+		ServerPlayerState playerState = new ServerPlayerState(serverPlayer);
+		this.connectedPlayerStateByPlayerWrapper.put(serverPlayer, playerState);
+		
+		Queue<AbstractNetworkMessage> queuedMessages = this.messageQueueByPlayerWrapper.get(serverPlayer);
+		if (queuedMessages != null)
+		{
+			NetworkSession networkSession = playerState.networkSession;
+			for (AbstractNetworkMessage message : queuedMessages)
+			{
+				networkSession.tryHandleMessage(message);
+			}
+			
+			this.messageQueueByPlayerWrapper.remove(serverPlayer);
+		}
+		
+		return playerState;
+	}
+	
+	public void unregisterLeftPlayer(IServerPlayerWrapper serverPlayer)
+	{
+		ServerPlayerState playerState = this.connectedPlayerStateByPlayerWrapper.remove(serverPlayer);
+		if (playerState != null)
+		{
+			playerState.close();
+		}
+	}
+	
+	
+	
+	//==========//
+	// messages //
+	//==========//
+	
+	public void handlePluginMessage(IServerPlayerWrapper player, AbstractNetworkMessage message)
+	{
+		ServerPlayerState playerState = this.connectedPlayerStateByPlayerWrapper.get(player);
+		if (playerState != null)
+		{
+			playerState.networkSession.tryHandleMessage(message);
+		}
+		else
+		{
+			this.messageQueueByPlayerWrapper.computeIfAbsent(player, k -> new ConcurrentLinkedQueue<>()).add(message);
+		}
+	}
+	
+	
+	
+	//=========//
+	// getters //
+	//=========//
+	
+	@Nullable
+	public ServerPlayerState getConnectedPlayer(IServerPlayerWrapper player) { return this.connectedPlayerStateByPlayerWrapper.get(player); }
+	public Iterable<ServerPlayerState> getConnectedPlayers() { return this.connectedPlayerStateByPlayerWrapper.values(); }
+	
+	
+	
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/multiplayer/server/ServerPlayerState.java

@@ -0,0 +1,123 @@
+package com.seibel.distanthorizons.core.multiplayer.server;
+
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.config.listeners.ConfigChangeListener;
+import com.seibel.distanthorizons.core.level.DhServerLevel;
+import com.seibel.distanthorizons.core.multiplayer.config.SessionConfig;
+import com.seibel.distanthorizons.core.network.messages.base.CurrentLevelKeyMessage;
+import com.seibel.distanthorizons.core.network.messages.base.SessionConfigMessage;
+import com.seibel.distanthorizons.core.network.event.internal.CloseInternalEvent;
+import com.seibel.distanthorizons.core.network.exceptions.RateLimitedException;
+import com.seibel.distanthorizons.core.network.messages.fullData.FullDataSourceRequestMessage;
+import com.seibel.distanthorizons.core.network.session.NetworkSession;
+import com.seibel.distanthorizons.core.util.ratelimiting.SupplierBasedRateAndConcurrencyLimiter;
+import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IServerPlayerWrapper;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.Closeable;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ServerPlayerState implements Closeable
+{
+	private final ConfigChangeListener<String> levelKeyPrefixChangeListener
+			= new ConfigChangeListener<>(Config.Client.Advanced.Multiplayer.ServerNetworking.levelKeyPrefix, this::onLevelKeyPrefixConfigChanged);
+	private final SessionConfig.AnyChangeListener configAnyChangeListener = new SessionConfig.AnyChangeListener(this::onSessionConfigChanged);
+	
+	
+	private String lastLevelKey = "";
+	
+	
+	public final NetworkSession networkSession;
+	public IServerPlayerWrapper getServerPlayer() { return this.networkSession.serverPlayer; }
+	
+	@NotNull
+	public final SessionConfig sessionConfig = new SessionConfig();
+	
+	private final ConcurrentHashMap<DhServerLevel, RateLimiterSet> rateLimiterSets = new ConcurrentHashMap<>();
+	public RateLimiterSet getRateLimiterSet(DhServerLevel level) { return this.rateLimiterSets.computeIfAbsent(level, ignored -> new RateLimiterSet()); }
+	public void clearRateLimiterSets() { this.rateLimiterSets.clear(); }
+	
+	
+	
+	//==============//
+	// constructors //
+	//==============//
+	
+	public ServerPlayerState(IServerPlayerWrapper serverPlayer)
+	{
+		this.networkSession = new NetworkSession(serverPlayer);
+		
+		this.networkSession.registerHandler(SessionConfigMessage.class, (sessionConfigMessage) ->
+		{
+			this.sessionConfig.constrainingConfig = sessionConfigMessage.config;
+			this.sendLevelKey();
+			this.networkSession.sendMessage(new SessionConfigMessage(this.sessionConfig));
+		});
+		
+		this.networkSession.registerHandler(CloseInternalEvent.class, event -> {
+			// No-op. prevents "Unhandled message" log entries
+		});
+	}
+	
+	
+	
+	//=================//
+	// client updating //
+	//=================//
+	
+	private void onLevelKeyPrefixConfigChanged(String newLevelKey) { this.sendLevelKey(); }
+	private void sendLevelKey()
+	{
+		if (Config.Client.Advanced.Multiplayer.ServerNetworking.sendLevelKeys.get())
+		{
+			// let the client's know about the change
+			String levelKey = this.getServerPlayer().getLevel().getKeyedLevelDimensionName();
+			if (!levelKey.equals(this.lastLevelKey))
+			{
+				this.lastLevelKey = levelKey;
+				this.networkSession.sendMessage(new CurrentLevelKeyMessage(levelKey));
+			}
+		}
+	}
+	
+	private void onSessionConfigChanged() { this.networkSession.sendMessage(new SessionConfigMessage(this.sessionConfig)); }
+	
+	
+	
+	//==========//
+	// shutdown //
+	//==========//
+	
+	@Override
+	public void close()
+	{
+		this.levelKeyPrefixChangeListener.close();
+		this.configAnyChangeListener.close();
+		this.networkSession.close();
+	}
+	
+	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	public class RateLimiterSet
+	{
+		public final SupplierBasedRateAndConcurrencyLimiter<FullDataSourceRequestMessage> generationRequestRateLimiter = new SupplierBasedRateAndConcurrencyLimiter<>(
+				() -> Config.Client.Advanced.Multiplayer.ServerNetworking.generationRequestRateLimit.get(),
+				msg -> {
+					msg.sendResponse(new RateLimitedException("Full data request rate limit: " + ServerPlayerState.this.sessionConfig.getGenerationRequestRateLimit()));
+				}
+		);
+		
+		public final SupplierBasedRateAndConcurrencyLimiter<FullDataSourceRequestMessage> syncOnLoginRateLimiter = new SupplierBasedRateAndConcurrencyLimiter<>(
+				() -> Config.Client.Advanced.Multiplayer.ServerNetworking.syncOnLoginRateLimit.get(),
+				msg -> {
+					msg.sendResponse(new RateLimitedException("Sync on login rate limit: " + ServerPlayerState.this.sessionConfig.getSyncOnLoginRateLimit()));
+				}
+		);
+		
+	}
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/network/INetworkObject.java

@@ -0,0 +1,228 @@
+/*
+ *    This file is part of the Distant Horizons mod
+ *    licensed under the GNU LGPL v3 License.
+ *
+ *    Copyright (C) 2020-2023 James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.distanthorizons.core.network;
+
+import io.netty.buffer.ByteBuf;
+import org.jetbrains.annotations.Contract;
+
+import javax.annotation.Nullable;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.function.*;
+
+/** The base for any object that can be sent over the network. */
+public interface INetworkObject
+{
+	/** Serializes this object into the given {@link ByteBuf} */
+	void encode(ByteBuf out);
+	/** Populates this object's from the given {@link ByteBuf} */
+	void decode(ByteBuf in);
+	
+	
+	
+	//========================//
+	// default/static methods //
+	//========================//
+	
+	/** 
+	 * @param obj the empty object that will be populated by the incoming {@link ByteBuf}
+	 */
+	static <T extends INetworkObject> T decodeToInstance(T obj, ByteBuf inputByteBuf)
+	{
+		obj.decode(inputByteBuf);
+		return obj;
+	}
+	
+	
+	
+	@Contract("_, null -> false; _, !null -> true")
+	default boolean writeOptional(ByteBuf outputByteBuf, Object value)
+	{
+		boolean isNull = value != null;
+		outputByteBuf.writeBoolean(isNull);
+		return isNull;
+	}
+	
+	@Nullable
+	default <T> T readOptional(ByteBuf inputByteBuf, Supplier<T> decoder)
+	{
+		return inputByteBuf.readBoolean()
+				? decoder.get() 
+				: null;
+	}
+	default void readOptional(ByteBuf inputByteBuf, Runnable decoder)
+	{
+		if (inputByteBuf.readBoolean())
+		{
+			decoder.run();
+		}
+	}
+	
+	
+	// strings //
+	
+	default void writeString(String inputString, ByteBuf outputByteBuf) { INetworkObject.writeStringStatic(inputString, outputByteBuf); }
+	static void writeStringStatic(String inputString, ByteBuf outputByteBuf)
+	{
+		byte[] bytes = inputString.getBytes(StandardCharsets.UTF_8);
+		outputByteBuf.writeShort(bytes.length);
+		outputByteBuf.writeBytes(bytes);
+	}
+	
+	default String readString(ByteBuf inputByteBuf) { return INetworkObject.readStringStatic(inputByteBuf); }
+	static String readStringStatic(ByteBuf inputByteBuf)
+	{
+		int length = inputByteBuf.readUnsignedShort();
+		return inputByteBuf.readSlice(length).toString(StandardCharsets.UTF_8);
+	}
+	
+	
+	// collections //
+	
+	default <T> void writeCollection(ByteBuf outputByteBuf, Collection<T> collection)
+	{
+		outputByteBuf.writeInt(collection.size());
+		this.writeFixedLengthCollection(outputByteBuf, collection);
+	}
+	default <T> void writeFixedLengthCollection(ByteBuf outputByteBuf, Collection<T> collection)
+	{
+		for (T item : collection)
+		{
+			Codec codec = Codec.getCodec(item.getClass());
+			codec.encode.accept(item, outputByteBuf);
+		}
+	}
+	
+	default <T> void readCollection(ByteBuf inputByteBuf, Collection<T> collection, Supplier<T> innerValueConstructor)
+	{
+		int size = inputByteBuf.readInt();
+		
+		Codec codec = null;
+		for (int i = 0; i < size; i++)
+		{
+			T item = innerValueConstructor.get();
+			
+			if (codec == null)
+			{
+				codec = Codec.getCodec(item.getClass());
+			}
+			//noinspection unchecked
+			item = (T) codec.decode.apply(item, inputByteBuf);
+			
+			collection.add(item);
+		}
+	}
+	
+	default <K, V> void readMap(ByteBuf inputByteBuf, Map<K, V> map, Supplier<K> keySupplier, Supplier<V> valueSupplier)
+	{
+		ArrayList<Map.Entry<K, V>> entryList = new ArrayList<>();
+		
+		this.readCollection(inputByteBuf, entryList, () -> new AbstractMap.SimpleEntry<>(keySupplier.get(), valueSupplier.get()));
+		for (Map.Entry<K, V> entry : entryList)
+		{
+			map.put(entry.getKey(), entry.getValue());
+		}
+	}
+	
+	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	/**
+	 * Defines (de)serialization for different classes,
+	 * specifically for base classes like {@link Integer}, {@link Boolean}, and {@link String}. <br><br>
+	 * 
+	 * Should only be used for non-editable classes;
+	 * otherwise, you may want to implement {@link INetworkObject} and use its methods where applicable.
+	 */
+	class Codec
+	{
+		private static final ConcurrentMap<Class<?>, Codec> CODEC_MAP = new ConcurrentHashMap<Class<?>, Codec>()
+		{{
+			// Primitives must be added manually here
+			this.put(Integer.class, new Codec((obj, outByteBuff) -> outByteBuff.writeInt((int)obj), (obj, inByteBuff) -> inByteBuff.readInt()));
+			this.put(Boolean.class, new Codec((obj, outByteBuff) -> outByteBuff.writeBoolean((boolean) obj), (obj, inByteBuff) -> inByteBuff.readBoolean()));
+			this.put(String.class, new Codec((obj, outByteBuff) -> INetworkObject.writeStringStatic((String) obj, outByteBuff), (obj, inByteBuff) -> INetworkObject.readStringStatic(inByteBuff)));
+			
+			this.put(INetworkObject.class, new Codec(INetworkObject::encode, INetworkObject::decodeToInstance));
+			this.put(Map.Entry.class, new Codec(
+					(obj, outByteBuff) -> 
+					{
+						Map.Entry<?, ?> entry = (Entry<?, ?>) obj;
+						getCodec(entry.getKey().getClass()).encode.accept(entry.getKey(), outByteBuff);
+						getCodec(entry.getValue().getClass()).encode.accept(entry.getValue(), outByteBuff);
+					},
+					(obj, inByteBuff) -> 
+					{
+						Map.Entry<?, ?> entry = (Entry<?, ?>) obj;
+						return new SimpleEntry<>(
+							getCodec(entry.getKey().getClass()).decode.apply(entry.getKey(), inByteBuff),
+							getCodec(entry.getValue().getClass()).decode.apply(entry.getValue(), inByteBuff)
+						);
+					}
+			));
+		}};
+		
+		
+		public final BiConsumer<Object, ByteBuf> encode;
+		public final BiFunction<Object, ByteBuf, Object> decode;
+		
+		
+		
+		//=============//
+		// constructor //
+		//=============//
+		
+		@SuppressWarnings("unchecked")
+		public <T> Codec(BiConsumer<T, ByteBuf> encode, BiFunction<T, ByteBuf, T> decode)
+		{
+			this.encode = (BiConsumer<Object, ByteBuf>) encode;
+			this.decode = (BiFunction<Object, ByteBuf, Object>) decode;
+		}
+		
+		
+		
+		//================//
+		// static methods //
+		//================//
+		
+		public static <T> Codec getCodec(Class<T> clazz)
+		{
+			return CODEC_MAP.computeIfAbsent(clazz, ignored -> 
+			{
+				// TODO when would this ever return true?
+				for (Map.Entry<Class<?>, Codec> entry : CODEC_MAP.entrySet())
+				{
+					if (entry.getKey().isAssignableFrom(clazz))
+					{
+						return entry.getValue();
+					}
+				}
+				
+				throw new AssertionError("Class has no compatible codec: " + clazz.getSimpleName());
+			});
+		}
+		
+	}
+}

core/src/main/java/com/seibel/distanthorizons/core/network/NetworkClient.java

@@ -1,175 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.core.network;
-
-import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.network.messages.CloseMessage;
-import com.seibel.distanthorizons.core.network.messages.CloseReasonMessage;
-import com.seibel.distanthorizons.core.network.messages.HelloMessage;
-import com.seibel.distanthorizons.core.network.protocol.NetworkChannelInitializer;
-//import io.netty.bootstrap.Bootstrap;
-//import io.netty.channel.Channel;
-//import io.netty.channel.ChannelFuture;
-//import io.netty.channel.ChannelOption;
-//import io.netty.channel.EventLoopGroup;
-//import io.netty.channel.nio.NioEventLoopGroup;
-//import io.netty.channel.socket.nio.NioSocketChannel;
-import org.apache.logging.log4j.Logger;
-
-import java.net.InetSocketAddress;
-import java.util.concurrent.TimeUnit;
-
-public class NetworkClient //extends NetworkEventSource implements AutoCloseable 
-{
-//    private static final Logger LOGGER = DhLoggerBuilder.getLogger();
-//	
-//    private enum EConnectionState
-//	{
-//        OPEN,
-//        RECONNECT,
-//        RECONNECT_FORCE,
-//        CLOSE_WAIT,
-//        CLOSED
-//    }
-//	
-//    private static final int FAILURE_RECONNECT_DELAY_SEC = 5;
-//    private static final int FAILURE_RECONNECT_ATTEMPTS = 3;
-//	
-//    // TODO move to payload of some sort
-//    private final InetSocketAddress address;
-//	
-//    private final EventLoopGroup workerGroup = new NioEventLoopGroup();
-//    private final Bootstrap clientBootstrap = new Bootstrap()
-//            .group(this.workerGroup)
-//            .channel(NioSocketChannel.class)
-//            .option(ChannelOption.SO_KEEPALIVE, true)
-//            .handler(new NetworkChannelInitializer(this.messageHandler));
-//	
-//    private EConnectionState connectionState;
-//    private Channel channel;
-//    private int reconnectAttempts = FAILURE_RECONNECT_ATTEMPTS;
-//	
-//	
-//	
-//    public NetworkClient(String host, int port)
-//	{
-//        this.address = new InetSocketAddress(host, port);
-//		
-//		this.registerHandlers();
-//		this.connect();
-//    }
-//	
-//    private void registerHandlers() 
-//	{
-//		this.registerHandler(HelloMessage.class, (helloMessage, channelContext) -> 
-//		{
-//            LOGGER.info("Connected to server: "+channelContext.channel().remoteAddress());
-//        });
-//		
-//		this.registerHandler(CloseReasonMessage.class, (closeReasonMessage, channelContext) -> 
-//		{
-//            LOGGER.info(closeReasonMessage.reason);
-//			this.connectionState = EConnectionState.CLOSE_WAIT;
-//        });
-//		
-//		this.registerHandler(CloseMessage.class, (closeMessage, channelContext) ->
-//		{
-//            LOGGER.info("Disconnected from server: "+channelContext.channel().remoteAddress());
-//            if (this.connectionState == EConnectionState.CLOSE_WAIT)
-//			{
-//				this.close();
-//			}
-//        });
-//    }
-//
-//    private void connect() 
-//	{
-//        LOGGER.info("Connecting to server: "+this.address);
-//		this.connectionState = EConnectionState.OPEN;
-//
-//		// FIXME sometimes this causes the MC connection to crash 
-//		//  this might happen if the URL can't be converted to a IP (IE UnknownHostException)
-//        ChannelFuture connectFuture = this.clientBootstrap.connect(this.address);
-//        connectFuture.addListener((ChannelFuture channelFuture) -> 
-//		{
-//            if (!channelFuture.isSuccess()) 
-//			{
-//                LOGGER.warn("Connection failed: "+channelFuture.cause());
-//                return;
-//            }
-//			
-//			this.channel.writeAndFlush(new HelloMessage());
-//        });
-//		
-//		this.channel = connectFuture.channel();
-//		this. channel.closeFuture().addListener((ChannelFuture channelFuture) -> 
-//		{
-//			switch (this.connectionState)
-//			{
-//				case OPEN:
-//					this.reconnectAttempts--;
-//					LOGGER.info("Reconnection attempts left: ["+this.reconnectAttempts+"] of ["+FAILURE_RECONNECT_ATTEMPTS+"].");
-//					if (this.reconnectAttempts == 0)
-//					{
-//						this.connectionState = EConnectionState.CLOSE_WAIT;
-//						return;
-//					}
-//					
-//					this.connectionState = EConnectionState.RECONNECT;
-//					this.workerGroup.schedule(this::connect, FAILURE_RECONNECT_DELAY_SEC, TimeUnit.SECONDS);
-//					break;
-//					
-//				case RECONNECT_FORCE:
-//					LOGGER.info("Reconnecting forcefully.");
-//					this.reconnectAttempts = FAILURE_RECONNECT_ATTEMPTS;
-//					
-//					this.connectionState = EConnectionState.RECONNECT;
-//					this.workerGroup.schedule(this::connect, 0, TimeUnit.SECONDS);
-//					break;
-//			}
-//        });
-//    }
-//
-//    /** Kills the current connection, triggering auto-reconnection immediately. */
-//    public void reconnect() 
-//	{
-//		this.connectionState = EConnectionState.RECONNECT_FORCE;
-//		this.channel.disconnect();
-//    }
-//
-//    @Override
-//    public void close() 
-//	{
-//        if (this.closeReason != null)
-//		{
-//			LOGGER.error(this.closeReason);
-//		}
-//
-//        if (this.connectionState == EConnectionState.CLOSED)
-//		{
-//			return;
-//		}
-//		
-//		this.connectionState = EConnectionState.CLOSED;
-//		this.workerGroup.shutdownGracefully().syncUninterruptibly();
-//		this.channel.close().syncUninterruptibly();
-//    }
-	
-}

core/src/main/java/com/seibel/distanthorizons/core/network/NetworkEventSource.java

@@ -1,82 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.core.network;
-
-import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.network.messages.AckMessage;
-import com.seibel.distanthorizons.core.network.messages.HelloMessage;
-import com.seibel.distanthorizons.core.network.protocol.INetworkMessage;
-import com.seibel.distanthorizons.core.network.protocol.MessageHandler;
-import com.seibel.distanthorizons.coreapi.ModInfo;
-//import io.netty.channel.ChannelHandlerContext;
-import org.apache.logging.log4j.Logger;
-
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-public abstract class NetworkEventSource implements AutoCloseable
-{
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
-	
-	protected final MessageHandler messageHandler = new MessageHandler();
-	protected String closeReason = null;
-
-
-
-//	public NetworkEventSource()
-//	{
-//		this.registerHandler(HelloMessage.class, (helloMessage, channelContext) -> 
-//		{
-//			if (helloMessage.version != ModInfo.PROTOCOL_VERSION)
-//			{
-//				try
-//				{
-//					String closeReason = "Ignoring message from channel ["+channelContext.name()+"], due to version mismatch. Expected version: ["+ModInfo.PROTOCOL_VERSION+"], received version: ["+helloMessage.version+"].";
-//					LOGGER.info(closeReason);
-//					this.close(closeReason);
-//				}
-//				catch (Exception e)
-//				{
-//					throw new RuntimeException(e);
-//				}
-//			}
-//		});
-//	}
-//	
-//	public <T extends INetworkMessage> void registerHandler(Class<T> clazz, BiConsumer<T, ChannelHandlerContext> handler) { this.messageHandler.registerHandler(clazz, handler); }
-//	
-//	public <T extends INetworkMessage> void registerAckHandler(Class<T> clazz, Consumer<ChannelHandlerContext> handler)
-//	{
-//		this.messageHandler.registerHandler(AckMessage.class, (ackMessage, channelContext) -> 
-//		{
-//			if (ackMessage.messageType == clazz)
-//			{
-//				handler.accept(channelContext);
-//			}
-//		});
-//	}
-//	
-//	public void close(String reason) throws Exception
-//	{
-//		this.closeReason = reason;
-//		this.close();
-//	}
-	
-}

core/src/main/java/com/seibel/distanthorizons/core/network/NetworkServer.java

@@ -1,122 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.core.network;
-
-import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.network.messages.CloseReasonMessage;
-import com.seibel.distanthorizons.core.network.messages.CloseMessage;
-import com.seibel.distanthorizons.core.network.messages.HelloMessage;
-import com.seibel.distanthorizons.core.network.protocol.NetworkChannelInitializer;
-//import io.netty.bootstrap.ServerBootstrap;
-//import io.netty.channel.*;
-//import io.netty.channel.nio.NioEventLoopGroup;
-//import io.netty.channel.socket.nio.NioServerSocketChannel;
-//import io.netty.handler.logging.LogLevel;
-//import io.netty.handler.logging.LoggingHandler;
-import org.apache.logging.log4j.Logger;
-
-public class NetworkServer //extends NetworkEventSource implements AutoCloseable
-{
-//	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
-//	
-//	// TODO move to the config
-//	private final int port;
-//	
-//	private final EventLoopGroup bossGroup = new NioEventLoopGroup(1);
-//	private final EventLoopGroup workerGroup = new NioEventLoopGroup();
-//	private Channel channel;
-//	private boolean isClosed = false;
-//	
-//	
-//	
-//	public NetworkServer(int port)
-//	{
-//		this.port = port;
-//		
-//		LOGGER.info("Starting server on port "+port);
-//		this.registerHandlers();
-//		this.bind();
-//	}
-//	
-//	private void registerHandlers()
-//	{
-//		this.registerHandler(HelloMessage.class, (helloMessage, channelContext) -> 
-//		{
-//			LOGGER.info("Client connected: "+channelContext.channel().remoteAddress());
-//			channelContext.channel().writeAndFlush(new HelloMessage());
-//		});
-//		
-//		this.registerHandler(CloseMessage.class, (closeMessage, channelContext) -> 
-//		{
-//			LOGGER.info("Client disconnected: "+channelContext.channel().remoteAddress());
-//		});
-//	}
-//	
-//	private void bind()
-//	{
-//		ServerBootstrap bootstrap = new ServerBootstrap()
-//				.group(this.bossGroup, this.workerGroup)
-//				.channel(NioServerSocketChannel.class)
-//				.handler(new LoggingHandler(LogLevel.DEBUG))
-//				.childHandler(new NetworkChannelInitializer(this.messageHandler));
-//		
-//		ChannelFuture bindFuture = bootstrap.bind(this.port);
-//		bindFuture.addListener((ChannelFuture channelFuture) -> 
-//		{
-//			if (!channelFuture.isSuccess())
-//			{
-//				throw new RuntimeException("Failed to bind: " + channelFuture.cause());
-//			}
-//			
-//			LOGGER.info("Server is started on port "+this.port);
-//		});
-//		
-//		this.channel = bindFuture.channel();
-//		this.channel.closeFuture().addListener(future -> this.close());
-//	}
-//	
-//	public void disconnectClient(ChannelHandlerContext ctx, String reason)
-//	{
-//		ctx.channel().config().setAutoRead(false);
-//		ctx.writeAndFlush(new CloseReasonMessage(reason))
-//				.addListener(ChannelFutureListener.CLOSE);
-//	}
-//	
-//	@Override
-//	public void close()
-//	{
-//		if (this.closeReason != null)
-//		{
-//			LOGGER.error(this.closeReason);
-//		}
-//		
-//		if (this.isClosed)
-//		{
-//			return;
-//		}
-//		this.isClosed = true;
-//		
-//		LOGGER.info("Shutting down the network server.");
-//		this.workerGroup.shutdownGracefully().syncUninterruptibly();
-//		this.bossGroup.shutdownGracefully().syncUninterruptibly();
-//		LOGGER.info("Network server has been closed.");
-//	}
-	
-}

core/src/main/java/com/seibel/distanthorizons/core/network/event/AbstractNetworkEventSource.java

@@ -0,0 +1,235 @@
+/*
+ *    This file is part of the Distant Horizons mod
+ *    licensed under the GNU LGPL v3 License.
+ *
+ *    Copyright (C) 2020-2023 James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.distanthorizons.core.network.event;
+
+import com.google.common.cache.CacheBuilder;
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
+import com.seibel.distanthorizons.core.network.event.internal.AbstractInternalEvent;
+import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
+import com.seibel.distanthorizons.core.network.messages.AbstractTrackableMessage;
+import com.seibel.distanthorizons.core.network.messages.MessageRegistry;
+import com.seibel.distanthorizons.core.network.session.SessionClosedException;
+import com.seibel.distanthorizons.core.network.messages.requests.CancelMessage;
+import com.seibel.distanthorizons.core.network.messages.requests.ExceptionMessage;
+import com.seibel.distanthorizons.coreapi.ModInfo;
+import org.apache.logging.log4j.LogManager;
+
+import java.io.InvalidClassException;
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.*;
+import java.util.function.Consumer;
+
+public abstract class AbstractNetworkEventSource
+{
+	private static final ConfigBasedLogger LOGGER = new ConfigBasedLogger(LogManager.getLogger(),
+			() -> Config.Client.Advanced.Logging.logNetworkEvent.get());
+	
+	
+	/**
+	 * Contains all message handlers. <br>
+	 * Grouped by: <br>
+	 * - {@link AbstractNetworkMessage} type <br>
+	 * - {@link AbstractNetworkEventSource} <br>
+	 */
+	private final ConcurrentHashMap<
+			Class<? extends AbstractNetworkMessage>,
+			ConcurrentMap<AbstractNetworkEventSource, Set<INetworkMessageConsumer>>
+			> networkHandlerSetByMessageClass = new ConcurrentHashMap<>();
+	
+	
+	private final ConcurrentHashMap<Long, FutureResponseData> pendingFutureById = new ConcurrentHashMap<>();
+	/** automatically forgets about ID's after a set time span. */
+	private final Set<Long> cancelledFutureIdSet = Collections.newSetFromMap(
+			CacheBuilder.newBuilder()
+			.expireAfterWrite(10, TimeUnit.SECONDS)
+			.<Long, Boolean>build()
+			.asMap());
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	protected void handleMessage(AbstractNetworkMessage message)
+	{
+		boolean handled = false;
+		
+		ConcurrentMap<AbstractNetworkEventSource, Set<INetworkMessageConsumer>> handlersByEventSource = this.networkHandlerSetByMessageClass.get(message.getClass());
+		if (handlersByEventSource != null)
+		{
+			for (Set<INetworkMessageConsumer> handlerSet : handlersByEventSource.values())
+			{
+				for (INetworkMessageConsumer handler : handlerSet)
+				{
+					handled = true;
+					handler.accept(message);
+				}
+			}
+		}
+		
+		if (message instanceof AbstractTrackableMessage)
+		{
+			AbstractTrackableMessage trackableMessage = (AbstractTrackableMessage) message;
+			
+			FutureResponseData responseData = this.pendingFutureById.get(trackableMessage.futureId);
+			if (responseData != null)
+			{
+				handled = true;
+				
+				if (message instanceof ExceptionMessage)
+				{
+					responseData.future.completeExceptionally(((ExceptionMessage) message).exception);
+				}
+				else if (message.getClass() != responseData.responseClass)
+				{
+					responseData.future.completeExceptionally(new InvalidClassException("Response with invalid type: expected " + responseData.responseClass.getSimpleName() + ", got:" + message));
+				}
+				else
+				{
+					responseData.future.complete(trackableMessage);
+				}
+			}
+			else if (this.cancelledFutureIdSet.remove(trackableMessage.futureId))
+			{
+				handled = true;
+			}
+		}
+		
+		if (!handled && ModInfo.IS_DEV_BUILD)
+		{
+			LOGGER.warn("Unhandled message: [{}].", message);
+		}
+	}
+	
+	
+	
+	//==================//
+	// abstract methods //
+	//==================//
+	
+	public abstract <T extends AbstractNetworkMessage> void registerHandler(Class<T> handlerClass, Consumer<T> handlerImplementation);
+	
+	
+	
+	//==================//
+	// message handlers //
+	//==================//
+	
+	protected final <T extends AbstractNetworkMessage> void registerHandler(AbstractNetworkEventSource eventSource, Class<T> handlerClass, Consumer<T> handlerImplementation)
+	{
+		if (!AbstractInternalEvent.class.isAssignableFrom(handlerClass))
+		{
+			MessageRegistry.INSTANCE.getMessageId(handlerClass);
+		}
+		
+		//noinspection unchecked
+		this.networkHandlerSetByMessageClass
+				.computeIfAbsent(handlerClass, missingHandlerClass -> new ConcurrentHashMap<>())
+				.computeIfAbsent(eventSource, missingEventSource -> ConcurrentHashMap.newKeySet())
+				.add((m) -> handlerImplementation.accept((T) m));
+	}
+	
+	protected void removeAllHandlers(AbstractNetworkEventSource eventSource)
+	{
+		for (ConcurrentMap<AbstractNetworkEventSource, Set<INetworkMessageConsumer>> handlerMap : this.networkHandlerSetByMessageClass.values())
+		{
+			handlerMap.remove(eventSource);
+		}
+	}
+	
+	
+	
+	//================//
+	// create message //
+	//================//
+	
+	protected <TResponse extends AbstractTrackableMessage> CompletableFuture<TResponse> createRequest(AbstractTrackableMessage msg, Class<TResponse> responseClass)
+	{
+		CompletableFuture<TResponse> responseFuture = new CompletableFuture<>();
+		responseFuture.whenComplete((response, throwable) ->
+		{
+			if (throwable instanceof CancellationException)
+			{
+				this.cancelledFutureIdSet.add(msg.futureId);
+				msg.sendResponse(new CancelMessage());
+			}
+			
+			if (!(throwable instanceof SessionClosedException))
+			{
+				this.pendingFutureById.remove(msg.futureId);
+			}
+		});
+		
+		this.pendingFutureById.put(msg.futureId, new FutureResponseData(responseClass, responseFuture));
+		
+		return responseFuture;
+	}
+	
+	
+	
+	//==========//
+	// shutdown //
+	//==========//
+	
+	public void close()
+	{
+		this.networkHandlerSetByMessageClass.clear();
+		this.completeAllFuturesExceptionally(new SessionClosedException(this.getClass().getSimpleName() + " is closed."));
+	}
+	private void completeAllFuturesExceptionally(Throwable cause)
+	{
+		for (FutureResponseData responseData : this.pendingFutureById.values())
+		{
+			responseData.future.completeExceptionally(cause);
+		}
+	}
+	
+	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	private static class FutureResponseData
+	{
+		public final Class<? extends AbstractTrackableMessage> responseClass;
+		public final CompletableFuture<AbstractTrackableMessage> future;
+		
+		private <T extends AbstractTrackableMessage> FutureResponseData(Class<T> responseClass, CompletableFuture<T> future)
+		{
+			this.responseClass = responseClass;
+			//noinspection unchecked
+			this.future = (CompletableFuture<AbstractTrackableMessage>) future;
+		}
+		
+	}
+	
+	/** Simple wrapper just to make the code here a bit more readable */
+	@FunctionalInterface
+	private interface INetworkMessageConsumer 
+	{
+		void accept(AbstractNetworkMessage message);
+	}
+	
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/network/event/ScopedNetworkEventSource.java

@@ -0,0 +1,81 @@
+/*
+ *    This file is part of the Distant Horizons mod
+ *    licensed under the GNU LGPL v3 License.
+ *
+ *    Copyright (C) 2020-2023 James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.seibel.distanthorizons.core.network.event;
+
+import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
+
+import java.util.function.Consumer;
+
+/** 
+ * Provides a way to register network message handlers which are expected to be removed later. <br><br>
+ * 
+ * In other words, listeners can be added to this {@link AbstractNetworkEventSource} and when
+ * you no longer need any of those listeners you can {@link ScopedNetworkEventSource#close()}
+ * this handler to remove all of them.
+ */
+public final class ScopedNetworkEventSource extends AbstractNetworkEventSource
+{
+	public final AbstractNetworkEventSource parent;
+	private boolean isClosed = false;
+	
+	private final Consumer<AbstractNetworkMessage> actualHandleMessageStable = this::handleMessage;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public ScopedNetworkEventSource(AbstractNetworkEventSource parent) { this.parent = parent; }
+	
+	
+	
+	//==================//
+	// message handlers //
+	//==================//
+	
+	@Override
+	public <T extends AbstractNetworkMessage> void registerHandler(Class<T> handlerClass, Consumer<T> handlerImplementation)
+	{
+		if (this.isClosed)
+		{
+			return;
+		}
+		
+		//noinspection unchecked
+		this.parent.registerHandler(this, handlerClass, (Consumer<T>) this.actualHandleMessageStable);
+		
+		super.registerHandler(this, handlerClass, handlerImplementation);
+	}
+	
+	
+	
+	//==========//
+	// shutdown //
+	//==========//
+	
+	@Override
+	public void close()
+	{
+		this.isClosed = true;
+		this.parent.removeAllHandlers(this);
+	}
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/network/event/internal/AbstractInternalEvent.java

@@ -0,0 +1,17 @@
+package com.seibel.distanthorizons.core.network.event.internal;
+
+import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
+import io.netty.buffer.ByteBuf;
+
+/** internal events are messages sent from the client/sever back to themselves. */
+public abstract class AbstractInternalEvent extends AbstractNetworkMessage
+{
+	@Override
+	public void encode(ByteBuf out)
+	{ throw new UnsupportedOperationException(this.getClass().getSimpleName() + " is an internal event, and cannot be sent."); }
+
+	@Override
+	public void decode(ByteBuf in)
+	{ throw new UnsupportedOperationException(this.getClass().getSimpleName() + " is an internal event, and cannot be received."); }
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/network/event/internal/CloseInternalEvent.java

@@ -0,0 +1,9 @@
+package com.seibel.distanthorizons.core.network.event.internal;
+
+/**
+ * This event is used to indicate a disconnect.
+ */
+public class CloseInternalEvent extends AbstractInternalEvent
+{
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/network/event/internal/IncompatibleMessageInternalEvent.java

@@ -0,0 +1,15 @@
+package com.seibel.distanthorizons.core.network.event.internal;
+
+/**
+ * This event is received instead of a message if its protocol version is incompatible with version the mod uses.
+ */
+public class IncompatibleMessageInternalEvent extends AbstractInternalEvent
+{
+	public final int protocolVersion;
+	
+	public IncompatibleMessageInternalEvent(int protocolVersion)
+	{
+		this.protocolVersion = protocolVersion;
+	}
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/network/event/internal/ProtocolErrorInternalEvent.java

@@ -0,0 +1,23 @@
+package com.seibel.distanthorizons.core.network.event.internal;
+
+import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * This event is used to indicate that encoding or decoding of a message threw an exception.
+ */
+public class ProtocolErrorInternalEvent extends AbstractInternalEvent
+{
+	public final Throwable reason;
+	@Nullable
+	public final AbstractNetworkMessage message;
+	public final boolean replyWithCloseReason;
+	
+	public ProtocolErrorInternalEvent(Throwable reason, @Nullable AbstractNetworkMessage message, boolean replyWithCloseReason)
+	{
+		this.reason = reason;
+		this.message = message;
+		this.replyWithCloseReason = replyWithCloseReason;
+	}
+	
+}

core/src/main/java/com/seibel/distanthorizons/core/network/exceptions/InvalidLevelException.java

@@ -17,11 +17,10 @@
  *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package com.seibel.distanthorizons.core.network.protocol;
+package com.seibel.distanthorizons.core.network.exceptions;
 
-/** For now this is only used for constraining listeners */
-public interface INetworkMessage extends INetworkObject
+/** Fired if a user attempts to run an operation in a level they aren't currently in. */
+public class InvalidLevelException extends Exception
 {
-	
+	public InvalidLevelException(String message) { super(message); }
 }
-

core/src/main/java/com/seibel/distanthorizons/core/network/exceptions/RateLimitedException.java

@@ -17,12 +17,11 @@
  *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package com.seibel.distanthorizons.core.level;
+package com.seibel.distanthorizons.core.network.exceptions;
 
-import com.seibel.distanthorizons.core.file.fullDatafile.GeneratedFullDataSourceProvider;
-
-public interface IDhWorldGenLevel extends IDhLevel, GeneratedFullDataSourceProvider.IOnWorldGenCompleteListener
+/** Fired if the client attempts to queue more tasks than the server is willing to handle. */
+public class RateLimitedException extends Exception
 {
-	void doWorldGen();
+	public RateLimitedException(String message) { super(message); }
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/network/exceptions/RequestRejectedException.java

@@ -0,0 +1,11 @@
+package com.seibel.distanthorizons.core.network.exceptions;
+
+/** 
+ * Fired if the client attempts an operation currently forbidden by the server. <Br>
+ * For example attempting to request LODs when world generation is disabled on the server. 
+ */
+public class RequestRejectedException extends Exception
+{
+	public RequestRejectedException(String message) { super(message); }
+	
+}