Add proof-of-concept dynamic fade

Done to fix a forge limitation where logos can't contain a file pathhttps://github.com/MinecraftForge/MinecraftForge/issues/7348

.editorconfig

@@ -10,7 +10,7 @@ insert_final_newline = false
 max_line_length = 1000
 tab_width = 4
 trim_trailing_whitespace = false
-ij_continuation_indent_size = 8
+ij_continuation_indent_size = 4
 ij_formatter_off_tag = @formatter:off
 ij_formatter_on_tag = @formatter:on
 ij_formatter_tags_enabled = true

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

@@ -39,10 +39,6 @@ package com.seibel.distanthorizons.api.enums;
  */
 public enum EDhApiDetailLevel
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	/**
 	 * detail level: 0 <Br>
 	 * width in Blocks: 1

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

@@ -28,10 +28,6 @@ package com.seibel.distanthorizons.api.enums.config;
  */
 public enum EDhApiBlocksToAvoid
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	NONE(false),
 	NON_COLLIDING(true);
 	

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

@@ -23,6 +23,7 @@ package com.seibel.distanthorizons.api.enums.config;
  * UNCOMPRESSED <br>
  * LZ4 <br>
  * Z_STD <br>
+ * Z_STD_STREAM <br>
  * LZMA2 <br><br>
  * 
  * Note: speed and compression ratios are examples
@@ -33,10 +34,6 @@ package com.seibel.distanthorizons.api.enums.config;
  */
 public enum EDhApiDataCompressionMode
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	/** 
 	 * Should only be used internally and for unit testing. <br><br> 
 	 * 
@@ -57,18 +54,32 @@ public enum EDhApiDataCompressionMode
 	LZ4(1),
 	
 	/**
-	 * Decent speed and good compression. <br><br> 
+	 * Great speed and good compression. <br><br> 
 	 *
+	 * Read Speed: 2.1 MS / DTO <br>
+	 * Write Speed: 4.9 MS / DTO <br>
+	 * Compression ratio: 0.2606 <br>
+	 */
+	Z_STD_BLOCK(4),
+	
+	/**
+	 * Similar to {@link EDhApiDataCompressionMode#Z_STD_BLOCK}
+	 * except slower. <br><br>
+	 * 
+	 * This option is only provided for legacy support when processing old databases. <br><br>
+	 * 
 	 * Read Speed: 9.31 MS / DTO <br>
 	 * Write Speed: 15.13 MS / DTO <br>
 	 * Compression ratio: 0.2606 <br>
 	 */
-	Z_STD(2),
-	
+	@Deprecated
+	@DisallowSelectingViaConfigGui
+	Z_STD_STREAM(2),
 	
 	/** 
-	 * Extremely slow, but very good compression. <br><br> 
-	 *
+	 * Extremely slow, but very good compression. <br>
+	 * Often causes whole computer stuttering due to memory bandwidth saturation. <br><br>
+	 * 
 	 * Read Speed: 13.29 MS / DTO <br>
 	 * Write Speed: 70.95 MS / DTO <br>
 	 * Compression ratio: 0.2068 <br>

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

@@ -44,9 +44,9 @@ public enum EDhApiGpuUploadMethod
 	/** Fast rendering but may stutter when uploading. */
 	SUB_DATA(false, false),
 	
-	/** Don't upload, only should be used for debugging */
-	@Deprecated // TODO remove before release
-	NONE(false, false),
+	///** Don't upload, only should be used for debugging */
+	//@Deprecated
+	//NONE(false, false),
 	
 	/**
 	 * May end up storing buffers in System memory. <br>

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

@@ -29,10 +29,6 @@ package com.seibel.distanthorizons.api.enums.config;
  */
 public enum EDhApiGrassSideRendering
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	AS_GRASS,
 	FADE_TO_DIRT,
 	AS_DIRT;

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

@@ -31,11 +31,6 @@ package com.seibel.distanthorizons.api.enums.config;
  */
 public enum EDhApiHorizontalQuality
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	// Note: any quadraticBase less than 2.0f has issues with DetailDistanceUtil, and will always return the lowest detail level.
 	//  So for now we are limiting the lowest value to 2.0
 	//  LOWEST was originally 1.0f and LOW was 1.5f

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

@@ -29,10 +29,6 @@ package com.seibel.distanthorizons.api.enums.config;
  */
 public enum EDhApiLodShading
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	/** 
 	 * Uses Minecraft's shading for LODs. <Br>
 	 * This means if Minecraft's shading is disabled DH's shading will be as well.

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

@@ -33,10 +33,6 @@ package com.seibel.distanthorizons.api.enums.config;
  */
 public enum EDhApiMcRenderingFadeMode
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	/**
 	 * No fading is done, there will be a pronounced border between
 	 * Minecraft and Distant Horizons. <br>

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

@@ -35,11 +35,6 @@ package com.seibel.distanthorizons.api.enums.config;
  */
 public enum EDhApiServerFolderNameMode
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	/** Only use the server name */
 	NAME_ONLY,
 	

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

@@ -34,11 +34,6 @@ package com.seibel.distanthorizons.api.enums.config;
 @Deprecated // not currently in use, if the config this enum represents is re-implemented, the deprecated flag can be removed
 public enum EDhApiVanillaOverdraw
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	/**
 	 * Don't draw LODs where a minecraft chunk could be.
 	 * Use Overdraw Offset to tweak the border thickness.

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

@@ -28,10 +28,6 @@ package com.seibel.distanthorizons.api.enums.config;
  */
 public enum EDhApiWorldCompressionMode
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	/** 
 	 * Every block/biome change is recorded in the database. <br>
 	 * This is what DH 2.0 and 2.0.1 all used by default and will store a lot of data. 

api/src/main/java/com/seibel/distanthorizons/api/enums/config/quickOptions/EDhApiQualityPreset.java

@@ -35,10 +35,6 @@ import com.seibel.distanthorizons.api.enums.config.DisallowSelectingViaConfigGui
  */
 public enum EDhApiQualityPreset
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	@DisallowSelectingViaConfigGui
 	CUSTOM,
 	

api/src/main/java/com/seibel/distanthorizons/api/enums/config/quickOptions/EDhApiThreadPreset.java

@@ -34,10 +34,6 @@ import com.seibel.distanthorizons.api.enums.config.DisallowSelectingViaConfigGui
  */
 public enum EDhApiThreadPreset
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	@DisallowSelectingViaConfigGui
 	CUSTOM,
 	

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

@@ -33,11 +33,6 @@ package com.seibel.distanthorizons.api.enums.rendering;
  */
 public enum EDhApiDebugRendering
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	/** LODs are rendered normally */
 	OFF,
 	

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

@@ -33,10 +33,6 @@ package com.seibel.distanthorizons.api.enums.rendering;
 @Deprecated
 public enum EDhApiFogDrawMode
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
 	/**
 	 * Use whatever Fog setting Optifine is using.
 	 * If Optifine isn't installed this defaults to {@link EDhApiFogDrawMode#FOG_ENABLED}.

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

@@ -30,11 +30,6 @@ package com.seibel.distanthorizons.api.enums.rendering;
  */
 public enum EDhApiFogFalloff
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	LINEAR(0),
 	EXPONENTIAL(1),
 	EXPONENTIAL_SQUARED(2);

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

@@ -33,11 +33,6 @@ package com.seibel.distanthorizons.api.enums.rendering;
  */
 public enum EDhApiHeightFogDirection
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	ABOVE_CAMERA                (true,  true,  false),
 	BELOW_CAMERA                (true,  false, true),
 	ABOVE_AND_BELOW_CAMERA      (true,  true,  true),

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

@@ -29,11 +29,6 @@ package com.seibel.distanthorizons.api.enums.rendering;
  */
 public enum EDhApiRendererMode
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	DEFAULT,
 	DEBUG,
 	DISABLED;

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

@@ -29,11 +29,6 @@ package com.seibel.distanthorizons.api.enums.rendering;
  */
 public enum EDhApiTransparency
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	DISABLED(false, false),
 	FAKE(true, true),
 	COMPLETE(true, false);

api/src/main/java/com/seibel/distanthorizons/api/enums/worldGeneration/EDhApiDistantGeneratorMode.java

@@ -34,11 +34,6 @@ package com.seibel.distanthorizons.api.enums.worldGeneration;
  */
 public enum EDhApiDistantGeneratorMode
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	/** Don't generate any new terrain, just generate LODs for already generated chunks. */
 	PRE_EXISTING_ONLY((byte) 1),
 	

api/src/main/java/com/seibel/distanthorizons/api/enums/worldGeneration/EDhApiDistantGeneratorProgressDisplayLocation.java

@@ -31,11 +31,6 @@ package com.seibel.distanthorizons.api.enums.worldGeneration;
  */
 public enum EDhApiDistantGeneratorProgressDisplayLocation
 {
-	// Reminder:
-	// when adding items up the API minor version
-	// when removing items up the API major version
-	
-	
 	OVERLAY,
 	CHAT,
 	LOG,

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

@@ -104,7 +104,7 @@ public interface IDhApiGraphicsConfig extends IDhApiConfigGroup
 	 * 2 = blending of 5x5			<br>
 	 * ...							<br>
 	 */
-//	IDhApiConfigValue<Integer> getBiomeBlending();
+	IDhApiConfigValue<Integer> getBiomeBlending();
 	
 	
 	

api/src/main/java/com/seibel/distanthorizons/api/interfaces/data/IDhApiTerrainDataRepo.java

@@ -161,9 +161,16 @@ public interface IDhApiTerrainDataRepo
 	//=========//
 	
 	/** 
+	 * Creates a new cache you manage that can be used to speed up repeat
+	 * read operations. <br>
+	 * Without a cache each operation must: hit the backing database file,
+	 * decompress it, and parse it; which is a fairly slow process. <br>
+	 * 
 	 * @return a {@link IDhApiTerrainDataCache} backed by {@link java.lang.ref.SoftReference}'s.
-	 * @since API 3.0.0
+	 * @since API 5.0.0
 	 */
-	IDhApiTerrainDataCache getSoftCache();
+	IDhApiTerrainDataCache createSoftCache();
+	
+	
 	
 }

api/src/main/java/com/seibel/distanthorizons/api/interfaces/events/IDhApiEventInjector.java

@@ -41,6 +41,7 @@ public interface IDhApiEventInjector extends IDependencyInjector<IDhApiEvent>
 	 * @throws IllegalArgumentException if the implementation object doesn't implement the interface
 	 */
 	// Note to self: Don't try adding a generic type to IDhApiEvent, the constructor won't accept it
+	// TODO why are we removing the class instead of an instance?
 	boolean unbind(Class<? extends IDhApiEvent> dependencyInterface, Class<? extends IDhApiEvent> dependencyClassToRemove) throws IllegalArgumentException;
 	
 	

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

@@ -169,7 +169,7 @@ public interface IDhApiWorldGenerator extends Closeable, IDhApiOverrideable
 	 *
 	 * After the {@link IDhApiWorldGenerator} 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.
+	 * Note: if air blocks aren't included in the {@link IDhApiFullDataSource} 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/methods/events/sharedParameterObjects/DhApiRenderParam.java

@@ -20,6 +20,8 @@
 package com.seibel.distanthorizons.api.methods.events.sharedParameterObjects;
 
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiRenderPass;
+import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper;
+import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiWorldLoadEvent;
 import com.seibel.distanthorizons.api.methods.events.interfaces.IDhApiEventParam;
 import com.seibel.distanthorizons.api.objects.math.DhApiMat4f;
 
@@ -27,7 +29,7 @@ import com.seibel.distanthorizons.api.objects.math.DhApiMat4f;
  * Contains information relevant to Distant Horizons and Minecraft rendering.
  *
  * @author James Seibel
- * @version 2024-1-31
+ * @version 2025-12-23
  * @since API 1.0.0
  */
 public class DhApiRenderParam implements IDhApiEventParam
@@ -61,6 +63,13 @@ public class DhApiRenderParam implements IDhApiEventParam
 	
 	public final int worldYOffset;
 	
+	/**
+	 * The level currently being rendered.
+	 * 
+	 * @since API 5.1.0 
+	 */
+	public final IDhApiLevelWrapper clientLevelWrapper;
+	
 	
 	
 	//==============//
@@ -70,12 +79,13 @@ public class DhApiRenderParam implements IDhApiEventParam
 	public DhApiRenderParam(DhApiRenderParam parent)
 	{
 		this(
-				parent.renderPass,
-				parent.partialTicks,
-				parent.nearClipPlane, parent.farClipPlane,
-				parent.mcProjectionMatrix.copy(), parent.mcModelViewMatrix.copy(),
-				parent.dhProjectionMatrix.copy(), parent.dhModelViewMatrix.copy(),
-				parent.worldYOffset
+			parent.renderPass,
+			parent.partialTicks,
+			parent.nearClipPlane, parent.farClipPlane,
+			parent.mcProjectionMatrix.copy(), parent.mcModelViewMatrix.copy(),
+			parent.dhProjectionMatrix.copy(), parent.dhModelViewMatrix.copy(),
+			parent.worldYOffset,
+			parent.clientLevelWrapper
 		);
 	}
 	public DhApiRenderParam(
@@ -84,7 +94,8 @@ public class DhApiRenderParam implements IDhApiEventParam
 			float nearClipPlane, float farClipPlane,
 			DhApiMat4f newMcProjectionMatrix, DhApiMat4f newMcModelViewMatrix,
 			DhApiMat4f newDhProjectionMatrix, DhApiMat4f newDhModelViewMatrix,
-			int worldYOffset
+			int worldYOffset,
+			IDhApiLevelWrapper clientLevelWrapper
 		)
 	{
 		this.renderPass = renderPass;
@@ -101,6 +112,7 @@ public class DhApiRenderParam implements IDhApiEventParam
 		this.dhModelViewMatrix = newDhModelViewMatrix;
 		
 		this.worldYOffset = worldYOffset;
+		this.clientLevelWrapper = clientLevelWrapper;
 		
 	}
 	

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

@@ -31,7 +31,7 @@ import java.util.List;
  * Contains a list of {@link DhApiTerrainDataPoint} representing the blocks in a Minecraft chunk.
  *
  * @author Builderb0y, James Seibel
- * @version 2024-7-21
+ * @version 2025-12-11
  * @since API 2.0.0
  * 
  * @see IDhApiWrapperFactory
@@ -54,27 +54,12 @@ 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 
-	 */
+	/** @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); }
+	{ return new DhApiChunk(chunkPosX, chunkPosZ, bottomYBlockPos, topYBlockPos); }
 	
-	/** 
-	 * 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)
+	/** Only visible to internal DH methods */
+	private DhApiChunk(int chunkPosX, int chunkPosZ, int bottomYBlockPos, int topYBlockPos)
 	{
 		this.chunkPosX = chunkPosX;
 		this.chunkPosZ = chunkPosZ;

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

@@ -29,7 +29,7 @@ import java.util.ArrayList;
  * Holds a single datapoint of terrain data.
  *
  * @author James Seibel
- * @version 2024-7-20
+ * @version 2025-11-15
  * @since API 1.0.0
  */
 public class DhApiTerrainDataPoint
@@ -47,6 +47,10 @@ public class DhApiTerrainDataPoint
 	
 	public final int blockLightLevel;
 	public final int skyLightLevel;
+	/**
+	 * An unsigned block position of the bottom vertex for this LOD relative to the level's minimum height. 
+	 * Should be greater than or equal to 0.
+	 */
 	public final int bottomYBlockPos;
 	public final int topYBlockPos;
 	
@@ -59,28 +63,7 @@ public class DhApiTerrainDataPoint
 	// 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 
-	 */
+	/** @since API 3.0.0 */
 	public static DhApiTerrainDataPoint create(
 			byte detailLevel,
 			int blockLightLevel, int skyLightLevel,
@@ -91,20 +74,15 @@ public class DhApiTerrainDataPoint
 		return new DhApiTerrainDataPoint(
 			detailLevel, blockLightLevel, skyLightLevel,
 			bottomYBlockPos, topYBlockPos,
-			blockStateWrapper, biomeWrapper,
-			false); 
+			blockStateWrapper, biomeWrapper); 
 	}
 	
-	/**
-	 * Only visible to internal DH methods 
-	 * @param ignoredParameter is only present to differentiate the two constructors and isn't actually used
-	 */
+	/** Only visible to internal DH methods */
 	private DhApiTerrainDataPoint(
 			byte detailLevel,
 			int blockLightLevel, int skyLightLevel,
 			int bottomYBlockPos, int topYBlockPos,
-			IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper,
-			boolean ignoredParameter
+			IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper
 		)
 	{
 		this.detailLevel = detailLevel;
@@ -118,4 +96,24 @@ public class DhApiTerrainDataPoint
 		this.biomeWrapper = biomeWrapper;
 	}
 	
+	
+	
+	//================//
+	// base overrides //
+	//================//
+	
+	@Override 
+	public String toString()
+	{
+		return "[Block:" + this.blockStateWrapper.getSerialString() + 
+				",Biome:" + this.biomeWrapper.getName() + 
+				",TopY:" + this.topYBlockPos + 
+				",BottomY:" + this.bottomYBlockPos + 
+				",BlockLight:" + this.blockLightLevel +
+				",SkyLight:" + this.skyLightLevel + 
+				"]";
+	}
+	
+	
+	
 }

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

@@ -31,21 +31,21 @@ public final class ModInfo
 	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 = 12;
+	public static final int PROTOCOL_VERSION = 13;
 	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.3.7-b-dev";
+	public static final String VERSION = "2.4.6-b-dev";
 	/** Returns true if the current build is an unstable developer build, false otherwise. */
 	public static final 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 = 5;
 	/** This version should be updated whenever new methods are added to the DH API */
-	public static final int API_MINOR_VERSION = 0;
+	public static final int API_MINOR_VERSION = 1;
 	/** This version should be updated whenever non-breaking fixes are added to the DH API */
 	public static final int API_PATCH_VERSION = 0;
 	

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

@@ -20,36 +20,43 @@
 package com.seibel.distanthorizons.core;
 
 import com.github.luben.zstd.ZstdOutputStream;
+import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeRenderEvent;
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.config.eventHandlers.IgnoredDimensionCsvHandler;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 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;
 import com.seibel.distanthorizons.core.api.external.methods.data.DhApiTerrainDataRepo;
 import com.seibel.distanthorizons.api.DhApi;
 import com.seibel.distanthorizons.core.render.DhApiRenderProxy;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
+import com.seibel.distanthorizons.coreapi.util.StringUtil;
 import net.jpountz.lz4.LZ4FrameOutputStream;
-import org.apache.logging.log4j.LogManager;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.sqlite.SQLiteJDBCLoader;
-import org.sqlite.util.OSInfo;
 import org.tukaani.xz.XZOutputStream;
 
-import java.awt.*;
-import java.io.File;
+import java.lang.management.GarbageCollectorMXBean;
+import java.lang.management.ManagementFactory;
+import java.util.List;
 
 /** Handles first time Core setup. */
 public class Initializer
 {
 	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
+	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
+	
+	
 	
 	public static void init()
 	{
+		LOGGER.info("Running library validation...");
+		
 		// confirm that all referenced libraries are available to use
 		try
 		{
@@ -57,6 +64,17 @@ public class Initializer
 			// will throw an error (not an exception)
 			Class<?> lz4Compressor = LZ4FrameOutputStream.class;
 			Class<?> zstdCompressor = ZstdOutputStream.class;
+			
+			{
+				byte[] testCompressByteArray = new byte[1024];
+				for (int i = 0; i < testCompressByteArray.length; i++)
+				{
+					testCompressByteArray[i] = (byte) (i % 126);
+				}
+				byte[] compressedBytes = com.github.luben.zstd.Zstd.compress(testCompressByteArray);
+				com.github.luben.zstd.Zstd.decompress(compressedBytes);
+			}
+			
 			Class<?> lzmaCompressor = XZOutputStream.class;
 			//Class<?> networking = ByteBuf.class;
 			Class<?> config = com.electronwill.nightconfig.core.Config.class;
@@ -73,9 +91,7 @@ public class Initializer
 		}
 		catch (Throwable e)
 		{
-			LOGGER.fatal("Critical programmer error: One or more libraries aren't present. Error: [" + e.getMessage() + "].", e);
-			// throwing here should crash the game, notifying the developer that something is wrong
-			throw new RuntimeException(e);
+			MC_CLIENT.crashMinecraft("Distant Horizons critical setup error: One or more libraries are either in-accessible, corrupted, or overwritten by another mod. Error: [" + e.getMessage() + "].", e);
 		}
 		
 		// confirm the resource directory is present
@@ -89,8 +105,7 @@ public class Initializer
 		}
 		catch (Exception e)
 		{
-			LOGGER.fatal("Critical programmer error: Can't read SQL Scripts resource folder is either missing or malformed. Error: [" + e.getMessage() + "].");
-			throw new RuntimeException(e);
+			MC_CLIENT.crashMinecraft("Critical programmer error: Can't read SQL Scripts resource folder is either missing or malformed. Error: [" + e.getMessage() + "].", e);
 		}
 		
 		// This code has been disabled since it can cause Mac
@@ -121,6 +136,45 @@ public class Initializer
 			LOGGER.error("Programmer Error: No ["+IWrapperFactory.class.getSimpleName()+"] assigned to the DhApi.");
 		}
 		
+		// log a warning if G1GC is being used
+		// (this garbage collector is known to cause stuttering)
+		{
+			boolean g1GcInUse = false;
+			
+			StringBuilder garbageCollectorNames = new StringBuilder();
+			List<GarbageCollectorMXBean> gcMxBeans = ManagementFactory.getGarbageCollectorMXBeans();
+			for (GarbageCollectorMXBean gcMxBean : gcMxBeans)
+			{
+				if (!garbageCollectorNames.toString().isEmpty())
+				{
+					garbageCollectorNames.append(", ");
+				}
+				garbageCollectorNames.append(gcMxBean.getName());
+				
+				// "G1 Young Generation" // "G1 Concurrent GC" // "G1 Old Generation"
+				if (gcMxBean.getName().toLowerCase().contains("g1 "))
+				{
+					g1GcInUse = true;
+				}
+			}
+			LOGGER.info("Garbage collectors: ["+garbageCollectorNames+"]");
+			
+			
+			if (g1GcInUse
+				&& Config.Common.Logging.Warning.logGarbageCollectorWarning.get())
+			{
+				LOGGER.warn(
+					"Distant Horizons: G1 Garbage collector detected. \n" +
+					"This garbage collector can cause FPS stuttering. \n" +
+					"It's recommended to use a concurrent garbage collector \n" +
+					"like ZGC (Java 21+) or Shenandoah (Java 8 through 17) for a smoother experience. \n" +
+					"");
+				
+			}
+		}
+		
+		DhApi.events.bind(DhApiBeforeRenderEvent.class, IgnoredDimensionCsvHandler.INSTANCE);
+		
 	}
 	
 }

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

@@ -28,6 +28,7 @@ import com.seibel.distanthorizons.api.interfaces.config.client.IDhApiHeightFogCo
 import com.seibel.distanthorizons.core.config.api.DhApiConfigValue;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.config.api.converters.ApiFogDrawModeConverter;
+import com.seibel.distanthorizons.core.config.api.converters.InvertedBoolConverter;
 
 public class DhApiFogConfig implements IDhApiFogConfig
 {
@@ -67,7 +68,7 @@ public class DhApiFogConfig implements IDhApiFogConfig
 	@Override
 	@Deprecated
 	public IDhApiConfigValue<Boolean> disableVanillaFog()
-	{ return new DhApiConfigValue<>(Config.Client.Advanced.Graphics.Fog.disableVanillaFog); }
+	{ return new DhApiConfigValue<>(Config.Client.Advanced.Graphics.Fog.enableVanillaFog, new InvertedBoolConverter()); }
 	@Override
 	public IDhApiConfigValue<Boolean> enableVanillaFog()
 	{ return new DhApiConfigValue<>(Config.Client.Advanced.Graphics.Fog.enableVanillaFog); }

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

@@ -97,10 +97,9 @@ public class DhApiGraphicsConfig implements IDhApiGraphicsConfig
 	public IDhApiConfigValue<Boolean> tintWithAvoidedBlocks()
 	{ return new DhApiConfigValue<Boolean, Boolean>(Config.Client.Advanced.Graphics.Quality.tintWithAvoidedBlocks); }
 	
-	// TODO re-implement
-//	@Override
-//	public IDhApiConfigValue<Integer> getBiomeBlending()
-//	{ return new DhApiConfigValue<Integer, Integer>(Quality.lodBiomeBlending); }
+	@Override
+	public IDhApiConfigValue<Integer> getBiomeBlending()
+	{ return new DhApiConfigValue<Integer, Integer>(Config.Client.Advanced.Graphics.Quality.lodBiomeBlending); }
 	
 	
 	

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

@@ -277,7 +277,7 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 					if (!getSpecificYCoordinate)
 					{
 						// if we aren't look for a specific datapoint, add each datapoint to the return array
-						returnArray[i] = DhApiTerrainDataPointUtil.createApiDatapoint(levelWrapper, mapping, requestedDetailLevel, dataPoint);
+						returnArray[i] = DhApiTerrainDataPointUtil.createApiDatapoint(levelWrapper.getMinHeight(), mapping, requestedDetailLevel, dataPoint);
 					}
 					else
 					{
@@ -294,7 +294,7 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 							if (bottomY <= requestedY && requestedY < topY) // blockPositions start from the bottom of the block, thus "<=" for bottomY, just "<" for topY
 							{
 								// this datapoint contains the requested block position, return it
-								DhApiTerrainDataPoint apiTerrainData = DhApiTerrainDataPointUtil.createApiDatapoint(levelWrapper, mapping, requestedDetailLevel, dataPoint);
+								DhApiTerrainDataPoint apiTerrainData = DhApiTerrainDataPointUtil.createApiDatapoint(levelWrapper.getMinHeight(), mapping, requestedDetailLevel, dataPoint);
 								return DhApiResult.createSuccess(new DhApiTerrainDataPoint[]{apiTerrainData});
 							}
 						}
@@ -345,7 +345,10 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 			@Nullable
 			IDhApiTerrainDataCache dataCache)
 	{
-		return this.raycastLodData(levelWrapper, new Vec3d(rayOriginX, rayOriginY, rayOriginZ), new Vec3f(rayDirectionX, rayDirectionY, rayDirectionZ), maxRayBlockLength, dataCache);
+		return this.raycastLodData(levelWrapper, 
+				new Vec3d(rayOriginX, rayOriginY, rayOriginZ), 
+				new Vec3f(rayDirectionX, rayDirectionY, rayDirectionZ), 
+				maxRayBlockLength, dataCache);
 	}
 	
 	/**
@@ -363,8 +366,8 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 	{
 		rayDirection.normalize();
 		
-		int minBlockHeight = levelWrapper.getMinHeight();
-		int maxBlockHeight = levelWrapper.getMaxHeight();
+		int minLevelBlockHeight = levelWrapper.getMinHeight();
+		int maxLevelBlockHeight = levelWrapper.getMaxHeight();
 		
 		
 		
@@ -380,7 +383,8 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 		DhApiRaycastResult closetFoundDataPoint = null;
 		
 		
-		while (blockPos.y >= minBlockHeight && blockPos.y < maxBlockHeight
+		while (blockPos.y >= minLevelBlockHeight 
+				&& blockPos.y < maxLevelBlockHeight
 				&& currentLength <= maxRayBlockLength)
 		{
 			// get the LOD columns around this position
@@ -403,7 +407,8 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 					{
 						// does this LOD contain the given Y position?
 						Vec3i dataPointPos = new Vec3i(columnPos.x, dataPoint.bottomYBlockPos, columnPos.z);
-						if (exactPos.y >= dataPoint.bottomYBlockPos && exactPos.y <= dataPoint.topYBlockPos)
+						if (exactPos.y >= dataPoint.bottomYBlockPos 
+							&& exactPos.y <= dataPoint.topYBlockPos)
 						{
 							if (closetFoundDataPoint == null)
 							{
@@ -516,7 +521,7 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 	//=============//
 	
 	@Override
-	public IDhApiTerrainDataCache getSoftCache() { return new DhApiTerrainDataCache(); }
+	public IDhApiTerrainDataCache createSoftCache() { return new DhApiTerrainDataCache(); }
 	
 	
 	
@@ -572,12 +577,16 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 					}
 					
 					// draw raycast position
-					if (rayCast.success && rayCast.payload != null)
+					if (rayCast.success 
+						&& rayCast.payload != null)
 					{
 						DebugRenderer.makeParticle(
 							new DebugRenderer.BoxParticle(
 								new DebugRenderer.Box(
-									DhSectionPos.encode((byte) 0, rayCast.payload.pos.x, rayCast.payload.pos.z), rayCast.payload.dataPoint.bottomYBlockPos, rayCast.payload.dataPoint.topYBlockPos, -0.1f, Color.RED),
+									DhSectionPos.encode((byte) 0, rayCast.payload.pos.x, rayCast.payload.pos.z), 
+										rayCast.payload.dataPoint.bottomYBlockPos, 
+										rayCast.payload.dataPoint.topYBlockPos, 
+										-0.1f, Color.RED),
 							1.0, 0f
 							)
 						);

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

@@ -23,33 +23,31 @@ import com.seibel.distanthorizons.api.DhApi;
 import com.seibel.distanthorizons.api.enums.config.EDhApiMcRenderingFadeMode;
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiRenderPass;
 import com.seibel.distanthorizons.api.methods.events.abstractEvents.*;
+import com.seibel.distanthorizons.api.objects.DhApiResult;
 import com.seibel.distanthorizons.core.api.internal.rendering.DhRenderState;
+import com.seibel.distanthorizons.core.enums.MinecraftTextFormat;
 import com.seibel.distanthorizons.core.file.structure.ClientOnlySaveStructure;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.network.messages.MessageRegistry;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.render.DhApiRenderProxy;
-import com.seibel.distanthorizons.core.render.renderer.VanillaFadeRenderer;
-import com.seibel.distanthorizons.core.render.renderer.LodRenderer;
-import com.seibel.distanthorizons.core.render.renderer.RenderParams;
+import com.seibel.distanthorizons.core.render.renderer.*;
 import com.seibel.distanthorizons.core.util.TimerUtil;
+import com.seibel.distanthorizons.core.util.math.Mat4f;
 import com.seibel.distanthorizons.core.util.objects.Pair;
+import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
 import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector;
 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.render.glObject.GLProxy;
-import com.seibel.distanthorizons.core.render.renderer.TestRenderer;
 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.IProfilerWrapper;
@@ -57,11 +55,23 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapp
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix4f;
+import org.joml.Vector4f;
 import org.lwjgl.glfw.GLFW;
+import org.lwjgl.opengl.GL32;
+import org.lwjgl.opengl.GL46;
 
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.image.BufferedImage;
 import java.io.File;
+import java.io.IOException;
+import java.text.NumberFormat;
 import java.util.*;
 import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.function.Function;
 
 /**
  * This holds the methods that should be called
@@ -157,10 +167,10 @@ public class ClientApi
 				
 				if (Config.Common.Logging.Warning.showReplayWarningOnStartup.get())
 				{
-					MC_CLIENT.sendChatMessage("\u00A76" + "Distant Horizons: Replay detected." + "\u00A7r"); // gold color
+					MC_CLIENT.sendChatMessage(MinecraftTextFormat.ORANGE + "Distant Horizons: Replay detected." + MinecraftTextFormat.CLEAR_FORMATTING);
 					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(MinecraftTextFormat.GRAY +".Minecraft" + File.separator + ClientOnlySaveStructure.SERVER_DATA_FOLDER_NAME + File.separator + ClientOnlySaveStructure.REPLAY_SERVER_FOLDER_NAME + File.separator + "DIMENSION_NAME"+ MinecraftTextFormat.CLEAR_FORMATTING);
 					MC_CLIENT.sendChatMessage("This can be disabled in DH's config under Advanced -> Logging.");
 					MC_CLIENT.sendChatMessage("");
 				}
@@ -246,7 +256,7 @@ public class ClientApi
 		}
 	}
 	
-	public void clientLevelLoadEvent(IClientLevelWrapper levelWrapper)
+	public void clientLevelLoadEvent(@Nullable IClientLevelWrapper levelWrapper)
 	{
 		// wait a moment before loading the level to give the server a chance to handle the client's login request
 		if (MC_CLIENT.clientConnectedToDedicatedServer())
@@ -322,41 +332,6 @@ public class ClientApi
 	
 	
 	
-	//============//
-	// clint tick //
-	//============//
-	
-	@Deprecated
-	public void clientTickEvent()
-	{
-		IProfilerWrapper profiler = MC_CLIENT.getProfiler();
-		profiler.push("DH-ClientTick");
-		
-		try
-		{
-			IDhClientWorld clientWorld = SharedApi.tryGetDhClientWorld();
-			if (clientWorld != null)
-			{
-				clientWorld.clientTick();
-				
-				// Ignore local world gen, as it's managed by server ticking
-				if (!(clientWorld instanceof DhClientServerWorld))
-				{
-					SharedApi.worldGenTick(clientWorld::worldGenTick);
-				}
-			}
-		}
-		catch (Exception e)
-		{
-			// handle errors here to prevent blowing up a mixin or API up stream
-			LOGGER.error("Unexpected error in ClientApi.clientTickEvent(), error: "+e.getMessage(), e);
-		}
-		
-		profiler.pop();
-	}
-	
-	
-	
 	//============//
 	// networking //
 	//============//
@@ -368,10 +343,27 @@ public class ClientApi
 	 */
 	public void pluginMessageReceived(@NotNull AbstractNetworkMessage message)
 	{
-		NetworkSession networkSession = this.pluginChannelApi.networkSession;
-		if (networkSession != null)
+		@Nullable ThreadPoolExecutor executor = ThreadPoolUtil.networkClientHandlerExecutor();
+		if (executor == null)
 		{
-			networkSession.tryHandleMessage(message);
+			LOGGER.warn("warn");
+			return;
+		}
+		
+		try
+		{
+			executor.execute(() ->
+			{
+				NetworkSession networkSession = this.pluginChannelApi.networkSession;
+				if (networkSession != null)
+				{
+					networkSession.tryHandleMessage(message);
+				}
+			});
+		}
+		catch (RejectedExecutionException e)
+		{
+			LOGGER.warn("Plugin message executor rejected");
 		}
 	}
 	
@@ -415,8 +407,11 @@ public class ClientApi
 			
 			try
 			{
+				// make sure the GLProxy is created for future use
+				GLProxy.getInstance();
+				
 				// these tasks always need to be called, regardless of whether the renderer is enabled or not to prevent memory leaks
-				GLProxy.getInstance().runRenderThreadTasks();
+				GLProxy.runRenderThreadTasks();
 			}
 			catch (Exception e)
 			{
@@ -544,10 +539,10 @@ public class ClientApi
 			this.rendererDisabledBecauseOfExceptions = true;
 			LOGGER.error("Unexpected Renderer error in render pass [" + renderPass + "]. Error: " + e.getMessage(), 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);
+			MC_CLIENT.sendChatMessage(MinecraftTextFormat.DARK_RED + "" + MinecraftTextFormat.BOLD + "ERROR: Distant Horizons renderer has encountered an exception!" + MinecraftTextFormat.CLEAR_FORMATTING);
+			MC_CLIENT.sendChatMessage(MinecraftTextFormat.DARK_RED + "Renderer disabled to try preventing GL state corruption." + MinecraftTextFormat.CLEAR_FORMATTING);
+			MC_CLIENT.sendChatMessage(MinecraftTextFormat.DARK_RED + "Toggle DH rendering via the config UI to re-activate DH rendering." + MinecraftTextFormat.CLEAR_FORMATTING);
+			MC_CLIENT.sendChatMessage(MinecraftTextFormat.DARK_RED + "Error: " + MinecraftTextFormat.CLEAR_FORMATTING + e);
 		}
 		
 		
@@ -566,12 +561,20 @@ public class ClientApi
 	 * The first fade pass.
 	 * Called after MC finishes rendering the opaque passes. 
 	 */
-	public void renderFadeOpaque()
+	public void renderFadeOpaque() // TODO this is actually the transparent pass
 	{
+		DepthCalculator.INSTANCE.getMcTransparentDepthTexture();
+		DepthCalculator.INSTANCE.tryCalculateAsync();
+		
 		// only fade when DH is rendering
 		if (Config.Client.Advanced.Debugging.rendererMode.get() == EDhApiRendererMode.DEFAULT
-			// only fade when requested
-			&& Config.Client.Advanced.Graphics.Quality.vanillaFadeMode.get() == EDhApiMcRenderingFadeMode.DOUBLE_PASS
+			&&
+			(
+				// only fade when requested
+				Config.Client.Advanced.Graphics.Quality.vanillaFadeMode.get() == EDhApiMcRenderingFadeMode.DOUBLE_PASS
+				// or if LOD-only mode is enabled (fading is used to remove the MC render pass)
+				|| Config.Client.Advanced.Debugging.lodOnlyMode.get()
+			)
 			// don't fade when Iris shaders are active, otherwise the rendering can get weird
 			&& !DhApiRenderProxy.INSTANCE.getDeferTransparentRendering())
 		{
@@ -583,8 +586,10 @@ public class ClientApi
 	 * Called after MC finishes rendering both opaque
 	 * and transparent passes. 
 	 */
-	public void renderFadeTransparent()
+	public void renderFadeTransparent() // TODO this is actually the opaque pass
 	{
+		DepthCalculator.INSTANCE.getMcOpaqueDepthTexture();
+		
 		// only fade when DH is rendering
 		if (Config.Client.Advanced.Debugging.rendererMode.get() == EDhApiRendererMode.DEFAULT)
 		{
@@ -613,27 +618,30 @@ public class ClientApi
 	/** Trigger once on key press, with CLIENT PLAYER. */
 	public void keyPressedEvent(int glfwKey)
 	{
-		if (!Config.Client.Advanced.Debugging.enableDebugKeybindings.get())
-		{
-			// keybindings are disabled
-			return;
-		}
+		//if (!Config.Client.Advanced.Debugging.enableDebugKeybindings.get())
+		//{
+		//	// keybindings are disabled
+		//	return;
+		//}
 		
 		
 		if (glfwKey == GLFW.GLFW_KEY_F8)
 		{
-			Config.Client.Advanced.Debugging.debugRendering.set(EDhApiDebugRendering.next(Config.Client.Advanced.Debugging.debugRendering.get()));
-			MC_CLIENT.sendChatMessage("F8: Set debug mode to " + Config.Client.Advanced.Debugging.debugRendering.get());
+			DepthCalculator.INSTANCE.pause = true;
+			//Config.Client.Advanced.Debugging.debugRendering.set(EDhApiDebugRendering.next(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_CLIENT.sendChatMessage("F6: Set rendering to " + Config.Client.Advanced.Debugging.rendererMode.get());
+			DepthCalculator.INSTANCE.pause = true;
+			//Config.Client.Advanced.Debugging.rendererMode.set(EDhApiRendererMode.next(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_CLIENT.sendChatMessage("P: Debug Pref Logger is " + (prefLoggerEnabled ? "enabled" : "disabled"));
+			DepthCalculator.INSTANCE.pause = true;
+			//prefLoggerEnabled = !prefLoggerEnabled;
+			//MC_CLIENT.sendChatMessage("P: Debug Pref Logger is " + (prefLoggerEnabled ? "enabled" : "disabled"));
 		}
 	}
 	
@@ -679,15 +687,15 @@ public class ClientApi
 	{
 		// dev build
 		if (ModInfo.IS_DEV_BUILD 
-			&& !this.isDevBuildMessagePrinted && MC_CLIENT.playerExists())
+			&& !this.isDevBuildMessagePrinted 
+			&& MC_CLIENT.playerExists())
 		{
 			this.isDevBuildMessagePrinted = true;
 			this.lastStaticWarningMessageSentMsTime = System.currentTimeMillis();
 			
 			// remind the user that this is a development build
 			String message =
-					// green text
-					"\u00A72" + "Distant Horizons: nightly/unstable build, version: [" + ModInfo.VERSION+"]." + "\u00A7r\n" +
+					MinecraftTextFormat.DARK_GREEN + "Distant Horizons: nightly/unstable build, version: [" + ModInfo.VERSION+"]." + MinecraftTextFormat.CLEAR_FORMATTING + "\n" +
 							"Issues may occur with this version.\n" +
 							"Here be dragons!\n";
 			MC_CLIENT.sendChatMessage(message);
@@ -711,7 +719,7 @@ public class ClientApi
 			{
 				String message =
 						// orange text		
-						"\u00A76" + "Distant Horizons: Low memory detected." + "\u00A7r \n" +
+						MinecraftTextFormat.ORANGE + "Distant Horizons: Low memory detected." + MinecraftTextFormat.CLEAR_FORMATTING + "\n" +
 						"Stuttering or low FPS may occur. \n" +
 						"Please increase Minecraft's available memory to 4 GB or more. \n" +
 						"This warning can be disabled in DH's config under Advanced -> Logging. \n";
@@ -725,22 +733,21 @@ public class ClientApi
 		if (!this.highVanillaRenderDistanceWarningPrinted 
 			&& Config.Common.Logging.Warning.showHighVanillaRenderDistanceWarning.get())
 		{
+			this.highVanillaRenderDistanceWarningPrinted = true;
+			
 			// DH generally doesn't need a vanilla render distance above 12 
 			if (MC_RENDER.getRenderDistance() > 12)
 			{
-				this.highVanillaRenderDistanceWarningPrinted = true;
 				this.lastStaticWarningMessageSentMsTime = System.currentTimeMillis();
 				
 				String message =
-						// yellow text
-						"\u00A7e" + "Distant Horizons: High vanilla render distance detected." + "\u00A7r \n" +
-						"Using a high vanilla render distance uses a lot of CPU power \n" +
-						"and doesn't improve graphics much after about 12.\n" +
-						"Lowing your vanilla render distance will give you better FPS\n" +
-						"and reduce stuttering at a similar visual quality.\n" +
-						// gray text		
-						"\u00A77" + "A vanilla render distance of 8 is recommended." + "\u00A7r \n" +
-						"This message can be disabled in DH's config under Advanced -> Logging.\n";
+					MinecraftTextFormat.YELLOW + "Distant Horizons: High vanilla render distance detected." + MinecraftTextFormat.CLEAR_FORMATTING + "\n" +
+					"Using a high vanilla render distance uses a lot of CPU power \n" +
+					"and doesn't improve graphics much after about 12.\n" +
+					"Lowering your vanilla render distance will give you better FPS\n" +
+					"and reduce stuttering at a similar visual quality.\n" +
+					MinecraftTextFormat.GRAY + "A vanilla render distance of 8 is recommended." + MinecraftTextFormat.CLEAR_FORMATTING + "\n" +
+					"This message can be disabled in DH's config under Advanced -> Logging.\n";
 				MC_CLIENT.sendChatMessage(message);
 			}
 		}

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

@@ -9,6 +9,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.network.event.internal.CloseInternalEvent;
 import com.seibel.distanthorizons.core.network.messages.base.LevelInitMessage;
 import com.seibel.distanthorizons.core.network.session.NetworkSession;
+import com.seibel.distanthorizons.core.render.glObject.GLProxy;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import org.jetbrains.annotations.NotNull;
@@ -89,7 +90,7 @@ public class ClientPluginChannelApi
 		
 		LOGGER.info("Server level key received: [" + msg.levelKey + "].");
 		
-		MC.executeOnRenderThread(() -> 
+		GLProxy.queueRunningOnRenderThread(() -> 
 		{
 			IClientLevelWrapper clientLevel = MC.getWrappedClientLevel(true);
 			IServerKeyedClientLevel existingKeyedClientLevel = KEYED_CLIENT_LEVEL_MANAGER.getServerKeyedLevel();

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

@@ -53,30 +53,6 @@ public class ServerApi
 	
 	
 	
-	//=============//
-	// tick events //
-	//=============//
-	
-	public void serverTickEvent()
-	{
-		try
-		{
-			IDhServerWorld serverWorld = SharedApi.tryGetDhServerWorld();
-			if (serverWorld != null)
-			{
-				serverWorld.serverTick();
-				SharedApi.worldGenTick(serverWorld::worldGenTick);
-			}
-		}
-		catch (Exception e)
-		{
-			// try catch is necessary to prevent crashing the internal server when an exception is thrown
-			LOGGER.error("ServerTickEvent error: " + e.getMessage(), e);
-		}
-	}
-	
-	
-	
 	//===============//
 	// server events //
 	//===============//
@@ -106,15 +82,15 @@ public class ServerApi
 	// level events //
 	//==============//
 	
-	public void serverLevelLoadEvent(IServerLevelWrapper level)
+	public void serverLevelLoadEvent(IServerLevelWrapper levelWrapper)
 	{
-		LOGGER.debug("Server Level " + level + " loading");
+		LOGGER.debug("Server Level " + levelWrapper + " loading");
 		
 		AbstractDhWorld serverWorld = SharedApi.getAbstractDhWorld();
 		if (serverWorld != null)
 		{
-			serverWorld.getOrLoadLevel(level);
-			ApiEventInjector.INSTANCE.fireAllEvents(DhApiLevelLoadEvent.class, new DhApiLevelLoadEvent.EventParam(level));
+			serverWorld.getOrLoadLevel(levelWrapper);
+			ApiEventInjector.INSTANCE.fireAllEvents(DhApiLevelLoadEvent.class, new DhApiLevelLoadEvent.EventParam(levelWrapper));
 		}
 	}
 	public void serverLevelUnloadEvent(IServerLevelWrapper level)

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

@@ -25,6 +25,7 @@ import com.seibel.distanthorizons.core.Initializer;
 import com.seibel.distanthorizons.core.api.internal.chunkUpdating.ChunkUpdateData;
 import com.seibel.distanthorizons.core.api.internal.chunkUpdating.ChunkUpdateQueueManager;
 import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.config.eventHandlers.IgnoredDimensionCsvHandler;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.generation.DhLightingEngine;
 import com.seibel.distanthorizons.core.level.DhClientLevel;
@@ -141,16 +142,6 @@ public class SharedApi
 		}
 	}
 	
-	public static void worldGenTick(Runnable worldGenRunnable)
-	{
-		lastWorldGenTickDelta--;
-		if (lastWorldGenTickDelta <= 0)
-		{
-			worldGenRunnable.run();
-			lastWorldGenTickDelta = 20;
-		}
-	}
-	
 	@Nullable
 	public static AbstractDhWorld getAbstractDhWorld() { return currentWorld; }
 	
@@ -194,12 +185,11 @@ public class SharedApi
 	public void chunkBlockChangedEvent(IChunkWrapper chunk, ILevelWrapper level) { this.applyChunkUpdate(chunk, level, true, false); }
 	public void chunkLoadEvent(IChunkWrapper chunk, ILevelWrapper level) { this.applyChunkUpdate(chunk, level, true, true); }
 	
-	//public void applyChunkUpdate(IChunkWrapper chunkWrapper, ILevelWrapper level, boolean canGetNeighboringChunks) { this.applyChunkUpdate(chunkWrapper, level, canGetNeighboringChunks, false); }
 	public void applyChunkUpdate(IChunkWrapper chunkWrapper, ILevelWrapper level, boolean canGetNeighboringChunks, boolean newlyLoaded)
 	{
-		//========================//
-		// world and level checks //
-		//========================//
+		//===================//
+		// validation checks //
+		//===================//
 		
 		if (chunkWrapper == null)
 		{
@@ -227,7 +217,6 @@ public class SharedApi
 			return;
 		}
 		
-		
 		// only continue if the level is loaded
 		IDhLevel dhLevel = dhWorld.getLevel(level);
 		if (dhLevel == null)
@@ -242,6 +231,7 @@ public class SharedApi
 			return;
 		}
 		
+		// ignore chunk updates if the network should handle them
 		if (dhLevel instanceof DhClientLevel)
 		{
 			if (!((DhClientLevel) dhLevel).shouldProcessChunkUpdate(chunkWrapper.getChunkPos()))
@@ -250,7 +240,14 @@ public class SharedApi
 			}
 		}
 		
-		// shoudln't normally happen, but just in case
+		// ignore chunk updates for non-rendered levels
+		String dimName = dhLevel.getLevelWrapper().getDimensionName();
+		if (IgnoredDimensionCsvHandler.INSTANCE.dimensionNameShouldBeIgnored(dimName))
+		{
+			return;
+		}
+		
+		// shouldn't normally happen, but just in case
 		if (CHUNK_UPDATE_QUEUE_MANAGER.contains(chunkWrapper.getChunkPos()))
 		{
 			// TODO this will prevent some LODs from updating across dimensions if multiple levels are loaded
@@ -258,94 +255,20 @@ public class SharedApi
 		}
 		
 		
-		
-		//===============================//
-		// update the necessary chunk(s) //
-		//===============================//
-		
-		if (!canGetNeighboringChunks)
-		{
-			// only update the center chunk
-			queueChunkUpdate(chunkWrapper, null, dhLevel, false);
-			return;
-		}
-		
-		
-		ArrayList<IChunkWrapper> neighboringChunkList = getNeighborChunkListForChunk(chunkWrapper, dhLevel);
-		
-		if (newlyLoaded)
-		{
-			// this means this chunkWrapper is a newly loaded chunk 
-			// which may be missing some neighboring chunk data
-			// because it is bordering the render distance
-			// thus, only the chunks neighboring this chunkWrapper will get updated
-			// because those are more likely to have their full neighboring chunk data
-			//TODO this does not prevent those neighboring chunks from updating
-			// this newly loaded chunk that were just skipped
-			// leading to occasional lighting issues
-			for (IChunkWrapper neighboringChunk : neighboringChunkList)
-			{
-				if (neighboringChunk == chunkWrapper)
-				{
-					continue;
-				}
-				
-				this.applyChunkUpdate(neighboringChunk, level, true, false);
-			}
-		}
-		else
-		{
-			// if not all neighboring chunk data is available, do not try to update
-			if (neighboringChunkList.size() < 9)
-			{
-				return;
-			}
-			
-			// update the center with any existing neighbour chunks. 
-			// this is done so lighting changes are propagated correctly
-			queueChunkUpdate(chunkWrapper, neighboringChunkList, dhLevel, true);
-		}
-	}
-	private static ArrayList<IChunkWrapper> getNeighborChunkListForChunk(IChunkWrapper chunkWrapper, IDhLevel dhLevel)
-	{
-		// get the neighboring chunk list
-		ArrayList<IChunkWrapper> neighborChunkList = new ArrayList<>(9);
-		for (int xOffset = -1; xOffset <= 1; xOffset++)
-		{
-			for (int zOffset = -1; zOffset <= 1; zOffset++)
-			{
-				if (xOffset == 0 && zOffset == 0)
-				{
-					// center chunk
-					neighborChunkList.add(chunkWrapper);
-				}
-				else
-				{
-					// neighboring chunk 
-					DhChunkPos neighborPos = new DhChunkPos(chunkWrapper.getChunkPos().getX() + xOffset, chunkWrapper.getChunkPos().getZ() + zOffset);
-					IChunkWrapper neighborChunk = dhLevel.getLevelWrapper().tryGetChunk(neighborPos);
-					if (neighborChunk != null)
-					{
-						neighborChunkList.add(neighborChunk);
-					}
-				}
-			}
-		}
-		return neighborChunkList;
+		queueChunkUpdate(chunkWrapper, dhLevel);
 	}
 	
-	private static void queueChunkUpdate(IChunkWrapper chunkWrapper, @Nullable ArrayList<IChunkWrapper> neighborChunkList, IDhLevel dhLevel, boolean canGetNeighboringChunks)
+	private static void queueChunkUpdate(IChunkWrapper chunkWrapper, IDhLevel dhLevel)
 	{
-				
 		// return if the chunk is already queued
 		if (CHUNK_UPDATE_QUEUE_MANAGER.contains(chunkWrapper.getChunkPos()))
 		{
 			return;
 		}
-			
+		
 		
 		// add chunk update data to preUpdate queue
-		ChunkUpdateData updateData = new ChunkUpdateData(chunkWrapper, neighborChunkList, dhLevel, canGetNeighboringChunks);
+		ChunkUpdateData updateData = new ChunkUpdateData(chunkWrapper, dhLevel);
 		CHUNK_UPDATE_QUEUE_MANAGER.addItemToPreUpdateQueue(chunkWrapper.getChunkPos(), updateData);
 		
 		
@@ -353,7 +276,8 @@ public class SharedApi
 		// (this prevents doing extra work queuing tasks that may not be necessary)
 		// and makes sure the chunks closest to the player are updated first
 		PriorityTaskPicker.Executor executor = ThreadPoolUtil.getChunkToLodBuilderExecutor();
-		if (executor != null && executor.getQueueSize() < executor.getPoolSize())
+		if (executor != null
+			&& executor.getQueueSize() < executor.getPoolSize())
 		{
 			try
 			{
@@ -393,10 +317,7 @@ public class SharedApi
 		// update the necessary chunk(s) //
 		//===============================//
 		
-		// process preUpdate queue
 		processQueuedChunkPreUpdate();
-		
-		// process update queue
 		processQueuedChunkUpdate();
 		
 		// queue the next position if there are still positions to process
@@ -425,8 +346,7 @@ public class SharedApi
 		
 		IDhLevel dhLevel = preUpdateData.dhLevel;
 		IChunkWrapper chunkWrapper = preUpdateData.chunkWrapper;
-		boolean canGetNeighboringChunks = preUpdateData.canGetNeighboringChunks;
-		ArrayList<IChunkWrapper> neighborChunkList = preUpdateData.neighborChunkList;
+		chunkWrapper.createDhHeightMaps();
 		
 		try
 		{
@@ -443,34 +363,6 @@ public class SharedApi
 					// do not update the chunk if the hash is the same
 					return;
 				}
-				
-				// if this chunk will update and can get neighbors
-				// then queue neighboring chunks to update as well
-				// neighboring chunk will get added directly to the update queue
-				// so they won't queue further chunk updates
-				if (neighborChunkList != null 
-					&& !neighborChunkList.isEmpty())
-				{
-					for (IChunkWrapper adjacentChunk : neighborChunkList)
-					{
-						// pulling a new chunkWrapper is necessary to prevent concurrent modification on the existing chunkWrappers
-						IChunkWrapper newCenterChunk = dhLevel.getLevelWrapper().tryGetChunk(adjacentChunk.getChunkPos());
-						if (newCenterChunk != null)
-						{
-							ChunkUpdateData newUpdateData;
-							if (canGetNeighboringChunks)
-							{
-								newUpdateData = new ChunkUpdateData(newCenterChunk, getNeighborChunkListForChunk(newCenterChunk, dhLevel), dhLevel, true);
-							}
-							else
-							{
-								newUpdateData = new ChunkUpdateData(newCenterChunk, null, dhLevel, false);
-							}
-							
-							CHUNK_UPDATE_QUEUE_MANAGER.addItemToUpdateQueue(newCenterChunk.getChunkPos(), newUpdateData);
-						}
-					}
-				}
 			}
 			
 			CHUNK_UPDATE_QUEUE_MANAGER.addItemToUpdateQueue(chunkWrapper.getChunkPos(), preUpdateData);
@@ -483,8 +375,6 @@ public class SharedApi
 	
 	private static void processQueuedChunkUpdate()
 	{
-		//LOGGER.trace(chunkWrapper.getChunkPos() + " " + executor.getActiveCount() + " / " + executor.getQueue().size() + " - " + executor.getCompletedTaskCount());
-		
 		ChunkUpdateData updateData = CHUNK_UPDATE_QUEUE_MANAGER.updateQueue.popClosest();
 		if (updateData == null)
 		{
@@ -494,15 +384,11 @@ public class SharedApi
 		IChunkWrapper chunkWrapper = updateData.chunkWrapper;
 		IDhLevel dhLevel = updateData.dhLevel;
 		ILevelWrapper levelWrapper = dhLevel.getLevelWrapper();
-		// having a list of the nearby chunks is needed for lighting and beacon generation
-		@Nullable ArrayList<IChunkWrapper> nearbyChunkList = updateData.neighborChunkList; 
 		
-		// a non-null list is needed for the lighting engine
-		if (nearbyChunkList == null)
-		{
-			nearbyChunkList = new ArrayList<IChunkWrapper>();
-			nearbyChunkList.add(chunkWrapper);
-		}
+		// having a list of the nearby chunks is needed for lighting and beacon generation
+		ArrayList<IChunkWrapper> nearbyChunkList  = tryGetNeighborChunkListForChunk(chunkWrapper);
+		
+		
 		
 		try
 		{
@@ -518,6 +404,35 @@ public class SharedApi
 		{
 			LOGGER.error("Unexpected error when updating chunk at pos: [" + chunkWrapper.getChunkPos() + "]", e);
 		}
+		
+		CHUNK_UPDATE_QUEUE_MANAGER.queuedChunkWrapperByChunkPos.remove(updateData.chunkWrapper.getChunkPos());
+	}
+	private static ArrayList<IChunkWrapper> tryGetNeighborChunkListForChunk(IChunkWrapper chunkWrapper)
+	{
+		// get the neighboring chunk list
+		ArrayList<IChunkWrapper> neighborChunkList = new ArrayList<>(9);
+		for (int xOffset = -1; xOffset <= 1; xOffset++)
+		{
+			for (int zOffset = -1; zOffset <= 1; zOffset++)
+			{
+				if (xOffset == 0 && zOffset == 0)
+				{
+					// center chunk
+					neighborChunkList.add(chunkWrapper);
+				}
+				else
+				{
+					// neighboring chunk 
+					DhChunkPos neighborPos = new DhChunkPos(chunkWrapper.getChunkPos().getX() + xOffset, chunkWrapper.getChunkPos().getZ() + zOffset);
+					IChunkWrapper neighborChunk = CHUNK_UPDATE_QUEUE_MANAGER.tryGetChunk(neighborPos);
+					if (neighborChunk != null)
+					{
+						neighborChunkList.add(neighborChunk);
+					}
+				}
+			}
+		}
+		return neighborChunkList;
 	}
 	
 	

core/src/main/java/com/seibel/distanthorizons/core/api/internal/chunkUpdating/ChunkPosQueue.java

@@ -2,6 +2,7 @@ package com.seibel.distanthorizons.core.api.internal.chunkUpdating;
 
 import com.seibel.distanthorizons.core.api.internal.SharedApi;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Comparator;
 import java.util.concurrent.ConcurrentHashMap;
@@ -105,6 +106,7 @@ public class ChunkPosQueue
 		this.furthestQueue.remove(closest);
 		return this.updateDataByChunkPos.remove(closest);
 	}
+	@Nullable
 	public ChunkUpdateData popFurthest()
 	{
 		if (this.furthestQueue.isEmpty())

core/src/main/java/com/seibel/distanthorizons/core/api/internal/chunkUpdating/ChunkUpdateData.java

@@ -9,18 +9,13 @@ import java.util.ArrayList;
 public class ChunkUpdateData
 {
 	public IChunkWrapper chunkWrapper;
-	@Nullable
-	public ArrayList<IChunkWrapper> neighborChunkList;
 	public IDhLevel dhLevel;
-	public boolean canGetNeighboringChunks;
 	
 	
 	
-	public ChunkUpdateData(IChunkWrapper chunkWrapper, @Nullable ArrayList<IChunkWrapper> neighborChunkList, IDhLevel dhLevel, boolean canGetNeighborChunks)
+	public ChunkUpdateData(IChunkWrapper chunkWrapper, IDhLevel dhLevel)
 	{
 		this.chunkWrapper = chunkWrapper;
-		this.neighborChunkList = neighborChunkList;
 		this.dhLevel = dhLevel;
-		this.canGetNeighboringChunks = canGetNeighborChunks;
 	}
 }

core/src/main/java/com/seibel/distanthorizons/core/api/internal/chunkUpdating/ChunkUpdateQueueManager.java

@@ -1,12 +1,22 @@
 package com.seibel.distanthorizons.core.api.internal.chunkUpdating;
 
+import com.google.common.cache.CacheBuilder;
 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.enums.MinecraftTextFormat;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.world.EWorldEnvironment;
 import com.seibel.distanthorizons.core.logging.DhLogger;
+import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
 
 public class ChunkUpdateQueueManager
 {
@@ -15,7 +25,14 @@ public class ChunkUpdateQueueManager
 	
 	public final ChunkPosQueue updateQueue;
 	public final ChunkPosQueue preUpdateQueue;
+	public final Set<DhChunkPos> ignoredChunkPosSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
 	
+	public final ConcurrentMap<DhChunkPos, IChunkWrapper> queuedChunkWrapperByChunkPos = CacheBuilder.newBuilder()
+		.expireAfterWrite(20, TimeUnit.SECONDS)
+		.<DhChunkPos, IChunkWrapper>build()
+		.asMap();
+	
+	/** dynamically changes based on the number of threads currently available */
 	public int maxSize = 500;
 	
 	private static long lastOverloadedLogMessageMsTime = 0;
@@ -38,12 +55,18 @@ public class ChunkUpdateQueueManager
 	// list/set methods //
 	//==================//
 	
-	public boolean contains(DhChunkPos pos) { return this.updateQueue.contains(pos) || this.preUpdateQueue.contains(pos); }
+	public boolean contains(DhChunkPos pos) 
+	{ 
+		return this.updateQueue.contains(pos)
+			|| this.ignoredChunkPosSet.contains(pos)	
+			|| this.preUpdateQueue.contains(pos); 
+	}
 	
 	public void clear()
 	{
 		this.updateQueue.clear();
 		this.preUpdateQueue.clear();
+		this.ignoredChunkPosSet.clear();
 	}
 	public int getQueuedCount() { return this.updateQueue.getQueuedCount() + this.preUpdateQueue.getQueuedCount(); }
 	public boolean isEmpty()
@@ -57,22 +80,27 @@ public class ChunkUpdateQueueManager
 	 * If there are no more slots, replaces the item furthest from the center in the update queue.
 	 */
 	public void addItemToPreUpdateQueue(DhChunkPos pos, ChunkUpdateData updateData)
+	{ this.addItemToQueue(pos, updateData, this.preUpdateQueue); }
+	
+	public void addItemToUpdateQueue(DhChunkPos pos, ChunkUpdateData updateData)
+	{ this.addItemToQueue(pos, updateData, this.updateQueue); }
+	
+	private void addItemToQueue(DhChunkPos pos, ChunkUpdateData updateData, ChunkPosQueue queue)
 	{
 		int remainingSlots = this.maxSize - this.getQueuedCount();
 		
 		// If no slots are left, get one by removing the item furthest from the center
 		if (remainingSlots <= 0)
 		{
-			if (!this.updateQueue.isEmpty())
+			ChunkUpdateData removedData = queue.popFurthest();
+			if (removedData != null)
 			{
-				this.updateQueue.popFurthest();
-			}
-			else
-			{
-				this.preUpdateQueue.popFurthest();
+				this.queuedChunkWrapperByChunkPos.remove(removedData.chunkWrapper.getChunkPos());
 			}
 		}
-		this.preUpdateQueue.addItem(pos, updateData);
+		
+		queue.addItem(pos,updateData);
+		this.queuedChunkWrapperByChunkPos.putIfAbsent(pos, updateData.chunkWrapper);
 		
 		remainingSlots = this.maxSize - this.getQueuedCount();
 		if (remainingSlots <= 0)
@@ -81,24 +109,6 @@ public class ChunkUpdateQueueManager
 		}
 	}
 	
-	public void addItemToUpdateQueue(DhChunkPos pos, ChunkUpdateData updateData)
-	{
-		int remainingSlots = this.maxSize - this.getQueuedCount();
-		
-		// If no slots are left, get one by removing the item furthest from the center
-		if (remainingSlots <= 0)
-		{
-			this.updateQueue.popFurthest();
-		}
-		
-		this.updateQueue.addItem(pos,updateData);
-		
-		remainingSlots = this.maxSize - this.getQueuedCount();
-		if (remainingSlots <= 0)
-		{
-			this.sendOverloadMessage();
-		}
-	}
 	
 	private void sendOverloadMessage()
 	{
@@ -108,7 +118,7 @@ public class ChunkUpdateQueueManager
 		{
 			lastOverloadedLogMessageMsTime = System.currentTimeMillis();
 			
-			String message = "\u00A76" + "Distant Horizons overloaded, too many chunks queued for LOD processing. " + "\u00A7r" +
+			String message = MinecraftTextFormat.ORANGE + "Distant Horizons overloaded, too many chunks queued for LOD processing. " + MinecraftTextFormat.CLEAR_FORMATTING +
 					"\nThis may result in holes in your LODs. " +
 					"\nFix: move through the world slower, decrease your vanilla render distance, slow down your world pre-generator (IE Chunky), or increase the Distant Horizons' CPU thread counts. " +
 					"\nMax queue count [" + SharedApi.CHUNK_UPDATE_QUEUE_MANAGER.maxSize + "] ([" + SharedApi.MAX_UPDATING_CHUNK_COUNT_PER_THREAD_AND_PLAYER + "] per thread+players).";
@@ -129,6 +139,35 @@ public class ChunkUpdateQueueManager
 		}
 	}
 	
+	/** 
+	 * Tries to return a cloned chunk wrapper from memory.
+	 * Returns null if no chunk is available.
+	 * <br><br>
+	 * This is done instead of accessing the MC level since
+	 * accessing the level often requires running on the render or server
+	 * thread, which causes stuttering.
+	 */
+	@Nullable
+	public IChunkWrapper tryGetChunk(DhChunkPos pos)
+	{
+		IChunkWrapper existingWrapper = this.queuedChunkWrapperByChunkPos.get(pos);
+		if (existingWrapper == null)
+		{
+			return null;
+		}
+	
+		return existingWrapper.copy();
+	}
+	
+	
+	
+	//=========//
+	// ignores //
+	//=========//
+	
+	public void addPosToIgnore(DhChunkPos chunkPos) { this.ignoredChunkPosSet.add(chunkPos); }
+	public void removePosToIgnore(DhChunkPos chunkPos) { this.ignoredChunkPosSet.remove(chunkPos); }
+	
 	
 	
 	//==================//

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

@@ -33,13 +33,12 @@ import com.seibel.distanthorizons.core.config.types.enums.*;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
+import com.seibel.distanthorizons.core.util.NativeDialogUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import com.seibel.distanthorizons.core.logging.DhLogger;
-import org.lwjgl.util.tinyfd.TinyFileDialogs;
 
-import java.awt.*;
 import java.io.File;
 import java.util.*;
 import java.util.List;
@@ -103,10 +102,7 @@ public class Config
 		
 		public static ConfigUiLinkedEntry quickEnableWorldGenerator = new ConfigUiLinkedEntry(Common.WorldGenerator.enableDistantGeneration);
 		
-		public static ConfigEntry<Boolean> quickShowWorldGenProgress = new ConfigEntry.Builder<Boolean>()
-				.set(false) // TODO should be set by the underlying world gen progress button, not a static default
-				.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
-				.build();
+		public static ConfigUiLinkedEntry quickShowWorldGenProgress = new ConfigUiLinkedEntry(Common.WorldGenerator.showGenerationProgress);
 		
 		public static ConfigUiLinkedEntry quickLodCloudRendering = new ConfigUiLinkedEntry(Advanced.Graphics.GenericRendering.enableCloudRendering);
 		
@@ -122,11 +118,24 @@ public class Config
 		
 		
 		
+		public static ConfigEntry<Boolean> dynamicFadeUseOpaqueMcDepth = new ConfigEntry.Builder<Boolean>()
+			.set(true)
+			.comment(""
+				+ "")
+			.build();
+		
+		public static ConfigEntry<String> dynamicFadeExportPath = new ConfigEntry.Builder<String>()
+			.set("C:/Users/James_Seibel/Desktop/")
+			.comment(""
+				+ "")
+			.build();
+		
+		
+		
 		public static class Advanced
 		{
 			// common config links need to have their destination
 			// since they aren't part of "client" config class
-			// TODO determine their destination programically instead of hard coding the value
 			
 			public static ConfigUIComment advancedHeader = new ConfigUIComment.Builder().setParentConfigClass(Advanced.class).build();
 			
@@ -172,6 +181,20 @@ public class Config
 				public static ConfigCategory culling = new ConfigCategory.Builder().set(Culling.class).build();
 				public static ConfigUISpacer cullingSpacer = new ConfigUISpacer.Builder().build();
 				
+				public static ConfigEntry<Boolean> overrideVanillaGraphicsSettings = new ConfigEntry.Builder<Boolean>()
+					.set(true)
+					.comment("" +
+						"If true some vanilla graphics settings will be automatically changed \n" +
+						"during DH setup to provide a better experience. \n" +
+						" \n" +
+						"IE disabling vanilla clouds (which render on top of DH LODs), \n" +
+						"   and chunk fading (DH already fades MC chunks) \n" +
+						"")
+					.build();
+				public static ConfigUISpacer overrideVanillaSpacer = new ConfigUISpacer.Builder().build();
+				
+				
+				
 				public static ConfigCategory experimental = new ConfigCategory.Builder().set(Experimental.class).build();
 				
 				
@@ -263,7 +286,7 @@ public class Config
 					public static ConfigEntry<Double> lodBias = new ConfigEntry.Builder<Double>()
 							.setMinDefaultMax(0d, 0d, null)
 							.comment(""
-									+ "What the value should vanilla Minecraft's texture LodBias be? \n"
+									+ "What value should vanilla Minecraft's texture LodBias be? \n"
 									+ "If set to 0 the mod wont overwrite vanilla's default (which so happens to also be 0)")
 							.build();
 					
@@ -410,6 +433,14 @@ public class Config
 									"")
 							.build();
 					
+					public static ConfigEntry<Integer> fadeDistanceInBlocks = new ConfigEntry.Builder<Integer>()
+							.setMinDefaultMax(0, 1_600, 30_000_000)
+							.comment("" +
+									"The distance in blocks from the camera where the SSAO will fade out to. \n"+
+									"This is done to prevent banding and noise at extreme distances. \n"+
+									"")
+							.build();
+					
 				}
 				
 				public static class GenericRendering
@@ -440,6 +471,15 @@ public class Config
 									+ "")
 							.build();
 					
+					public static ConfigEntry<Boolean> expandDistantBeacons = new ConfigEntry.Builder<Boolean>()
+						.set(true) 
+						.comment(""
+							+ "If true LOD beacon beams will be rendered wider at extreme distances, \n"
+							+ "making them easier to see. \n"
+							+ "If false all LOD beacon beams will only ever be 1 block wide. \n"
+							+ "")
+						.build();
+					
 					public static ConfigEntry<Boolean> enableCloudRendering = new ConfigEntry.Builder<Boolean>()
 							.set(true)
 							.comment(""
@@ -488,11 +528,6 @@ public class Config
 									+ "Note: Other mods may conflict with this setting. \n"
 									+ "")
 							.build();
-					@Deprecated
-					public static ConfigEntry<Boolean> disableVanillaFog = new ConfigEntry.Builder<Boolean>()
-							.set(!enableVanillaFog.get())
-							.setAppearance(EConfigEntryAppearance.ONLY_IN_API)
-							.build();
 					
 					
 					
@@ -554,14 +589,6 @@ public class Config
 					
 					
 					
-					static
-					{
-						disableVanillaFog.addListener(
-								new ConfigChangeListener<Boolean>(disableVanillaFog,
-								(disableVanillaFog) -> enableVanillaFog.setApiValue(disableVanillaFog))
-						);
-					}
-					
 					public static class HeightFog
 					{
 						public static ConfigUIComment heightFogHeader = new ConfigUIComment.Builder().setParentConfigClass(HeightFog.class).build();
@@ -776,6 +803,11 @@ public class Config
 									+ "A comma separated list of block resource locations that won't be rendered by DH. \n"
 									+ "Air is always included in this list. \n"
 									+ "Requires a restart to change. \n"
+									+ "\n"
+									+ "Note:\n"
+									+ "If you see gaps, or holes you may have to change\n"
+									+ "worldCompression to ["+EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS+"] and re-generate the LODs.\n"
+									+ "Black spots may happen occur to block lighting being zero for covered blocks.\n"
 									+ "")
 							.build();
 					
@@ -824,7 +856,7 @@ public class Config
 					public static ConfigUIComment experimentalHeader = new ConfigUIComment.Builder().setParentConfigClass(Experimental.class).build();
 					
 					public static ConfigEntry<Integer> earthCurveRatio = new ConfigEntry.Builder<Integer>()
-							.setMinDefaultMax(0, 0, 5000)
+							.setMinDefaultMax(-5000, 0, 5000)
 							.comment(""
 									+ "This is the earth size ratio when applying the curvature shader effect. \n"
 									+ "Note: Enabling this feature may cause rendering bugs. \n"
@@ -834,24 +866,26 @@ public class Config
 									+ "100 = 1 to 100 (63,710 blocks) \n"
 									+ "10000 = 1 to 10000 (637.1 blocks) \n"
 									+ "\n"
-									+ "Note: Due to current limitations, the min value is 50 \n"
+									+ "Note: Due to current limitations, the min value is ["+WorldCurvatureConfigEventHandler.MIN_VALID_CURVE_VALUE+"] \n"
 									+ "and the max value is 5000. Any values outside this range \n"
 									+ "will be set to 0 (disabled).")
 							.addListener(WorldCurvatureConfigEventHandler.INSTANCE)
 							.build();
 					
-					// TODO should be replaced with a better long-term solution
-					@Deprecated
-					public static ConfigEntry<Boolean> onlyLoadCenterLods = new ConfigEntry.Builder<Boolean>()
-							.set(false)
-							.comment(""
-									+ "For internal testing:\n"
-									+ "Skips loading adjacent LODs to significantly reduce load times (~5x)\n"
-									+ "but causes lighting on LOD borders to appear as full-bright\n"
-									+ "and other graphical bugs.\n"
-									+ "")
-							.addListener(ReloadLodsConfigEventHandler.DELAYED_INSTANCE)
-							.build();
+					public static ConfigEntry<String> ignoredDimensionCsv = new ConfigEntry.Builder<String>()
+						.set("")
+						.comment(""
+							+ "A comma separated list of dimension resource locations where DH won't render. \n"
+							+ "\n"
+							+ "Example: \"minecraft:the_nether,minecraft:the_end\"\n"
+							+ "\n"
+							+ "Note:\n"
+							+ "Some DH settings will be disabled and/or changed to improve \n"
+							+ "visuals when DH rendering is disabled. \n"
+							+ "")
+						.addListener(IgnoredDimensionCsvHandler.INSTANCE)
+						.build();
+					
 				}
 				
 			}
@@ -1233,23 +1267,17 @@ public class Config
 							.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE) // no GUI renderer set up currently
 							.build();
 					
-					public static ConfigUIButton uiButtonTest = new ConfigUIButton(() -> 
+					public static ConfigUIButton uiButtonTest = new ConfigUIButton(() ->
 					{
 						// running on a separate thread is necessary to prevent locking
-						new Thread(() -> 
-						{
-							if (!GraphicsEnvironment.isHeadless())
-							{
-								LOGGER.info("Attempting to show tinyfd message box...");
-								boolean buttonPress = TinyFileDialogs.tinyfd_messageBox("Button pressed!", "UITester dialog", "ok", "info", false);
-								LOGGER.info("dialog returned with ["+(buttonPress ? "TRUE" : "FALSE")+"]");
-							}
-							else
-							{
-								LOGGER.info("button pressed!");
-							}
-						}).start();
+						new Thread(() -> onButtonPressed()).start();
 					});
+					public static void onButtonPressed()
+					{
+						LOGGER.info("Attempting to show tinyfd message box...");
+						boolean buttonPress = NativeDialogUtil.showDialog("Button pressed!", "UITester dialog", "ok", "info");
+						LOGGER.info("dialog returned with ["+(buttonPress ? "TRUE" : "FALSE")+"]");
+					}
 					
 					public static ConfigCategory categoryTest = new ConfigCategory.Builder().set(CategoryTest.class).build();
 					
@@ -1365,6 +1393,37 @@ public class Config
 							+ "")
 					.build();
 			
+			public static ConfigEntry<Integer> generationCenterChunkX = new ConfigEntry.Builder<Integer>()
+				.setChatCommandName("generation.bounds.centerChunk.x")
+				.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE)
+				.setMinDefaultMax(Integer.MIN_VALUE, 0, Integer.MAX_VALUE)
+				.comment("" +
+					"The center X chunk position that the world gen max radius is centered around. \n" +
+					"")
+				.build();
+			public static ConfigEntry<Integer> generationCenterChunkZ = new ConfigEntry.Builder<Integer>()
+				.setChatCommandName("generation.bounds.centerChunk.z")
+				.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE)
+				.setMinDefaultMax(Integer.MIN_VALUE, 0, Integer.MAX_VALUE)
+				.comment("" +
+					"The center Z chunk position that the world gen max radius is centered around. \n" +
+					"")
+				.build();
+			public static ConfigEntry<Integer> generationMaxChunkRadius = new ConfigEntry.Builder<Integer>()
+				.setChatCommandName("generation.bounds.radiusInChunks")
+				.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE)
+				.setMinDefaultMax(0, 0, Integer.MAX_VALUE)
+				.comment("" +
+					"The max radius in chunks around the central point where world generation is allowed. \n" +
+					"If this value is set to 0, generation bounds are disabled and the render distance will be used. \n" +
+					"\n" +
+					"This should only be set if you have a pre-generated world that has a very limited size. \n" +
+					"Setting this on a normal MC world will prevent the world generator from filling \n" +
+					"out your render distance. \n" +
+					"")
+				.build();
+			
+			
 		}
 		
 		public static class LodBuilding
@@ -1375,7 +1434,7 @@ public class Config
 					.set(false)
 					// enabling this can be quite detrimental to performance,
 					// so hiding it in the config file should reduce people accidentally enabling it
-					.setAppearance(isRunningInDevEnvironment() ? EConfigEntryAppearance.ALL : EConfigEntryAppearance.ONLY_IN_FILE)
+					.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE)
 					.comment(""
 							+ "Enabling this will drastically increase chunk processing time\n"
 							+ "and you may need to increase your CPU load to handle it.\n"
@@ -1390,37 +1449,9 @@ public class Config
 					.build();
 			
 			public static ConfigEntry<EDhApiDataCompressionMode> dataCompression = new ConfigEntry.Builder<EDhApiDataCompressionMode>()
-					.set(EDhApiDataCompressionMode.Z_STD)
-					.comment(""
-							+ "What algorithm should be used to compress new LOD data? \n"
-							+ "This setting will only affect new or updated LOD data, \n"
-							+ "any data already generated when this setting is changed will be\n"
-							+ "unaffected until it needs to be re-written to the database.\n"
-							+ "\n"
-							+ EDhApiDataCompressionMode.UNCOMPRESSED + " \n"
-							+ "Should only be used for testing, is worse in every way vs ["+EDhApiDataCompressionMode.LZ4+"].\n"
-							+ "Expected Compression Ratio: 1.0\n"
-							+ "Estimated average DTO read speed: 6.09 milliseconds\n"
-							+ "Estimated average DTO write speed: 6.01 milliseconds\n"
-							+ "\n"
-							+ EDhApiDataCompressionMode.LZ4 + " \n"
-							+ "A good option if you're CPU limited and have plenty of hard drive space.\n"
-							+ "Expected Compression Ratio: 0.4513\n"
-							+ "Estimated average DTO read speed: 3.25 ms\n"
-							+ "Estimated average DTO write speed: 5.99 ms\n"
-							+ "\n"
-							+ EDhApiDataCompressionMode.Z_STD + " \n"
-							+ "A good option if you're CPU limited and have plenty of hard drive space.\n"
-							+ "Expected Compression Ratio: 0.2606\n"
-							+ "Estimated average DTO read speed: 9.31 ms\n"
-							+ "Estimated average DTO write speed: 15.13 ms\n"
-							+ "\n"
-							+ EDhApiDataCompressionMode.LZMA2 + " \n"
-							+ "Slow but very good compression.\n"
-							+ "Expected Compression Ratio: 0.2\n"
-							+ "Estimated average DTO read speed: 13.29 ms\n"
-							+ "Estimated average DTO write speed: 70.95 ms\n"
-							+ "")
+					.set(EDhApiDataCompressionMode.Z_STD_BLOCK)
+					// only visible via the API since there is no reason to use any compressor except ZStandard as of 2025-11-24
+					.setAppearance(EConfigEntryAppearance.ONLY_IN_API)
 					.build();
 			
 			public static ConfigEntry<EDhApiWorldCompressionMode> worldCompression = new ConfigEntry.Builder<EDhApiWorldCompressionMode>()
@@ -1443,49 +1474,6 @@ public class Config
 							+ "")
 					.build();
 			
-			public static ConfigEntry<Boolean> recalculateChunkHeightmaps = new ConfigEntry.Builder<Boolean>()
-					.set(false)
-					.comment(""
-							+ "True: Recalculate chunk height maps before chunks can be used by DH.\n"
-							+ "      This can fix problems with worlds created by World Painter or \n"
-							+ "      other external tools where the heightmap format may be incorrect. \n"
-							+ "False: Assume any height maps handled by Minecraft are correct. \n"
-							+ "\n"
-							+ "Fastest: False\n"
-							+ "Most Compatible: True\n"
-							+ "")
-					.build();
-			
-			public static ConfigEntry<Boolean> pullLightingForPregeneratedChunks = new ConfigEntry.Builder<Boolean>()
-					.set(false)
-					.comment(""
-							+ "If true LOD generation for pre-existing chunks will attempt to pull the lighting data \n"
-							+ "saved in Minecraft's Region files. \n"
-							+ "If false DH will pull in chunks without lighting and re-light them. \n"
-							+ " \n"
-							+ "Setting this to true will result in faster LOD generation \n"
-							+ "for already generated worlds, but is broken by most lighting mods. \n"
-							+ " \n"
-							+ "Set this to false if LODs are black. \n"
-							+ "")
-					.build();
-			
-			public static ConfigEntry<Boolean> assumePreExistingChunksAreFinished = new ConfigEntry.Builder<Boolean>()
-					.set(false)
-					.comment(""
-							+ "When DH pulls in pre-existing chunks it will attempt to \n"
-							+ "run any missing world generation steps; for example: \n"
-							+ "if a chunk has the status SURFACE, DH will skip BIOMES \n"
-							+ "and SURFACE, but will run FEATURES. \n"
-							+ " \n"
-							+ "However if for some reason the chunks are malformed \n"
-							+ "or there's some other issue that causes the status \n"
-							+ "to be incorrect that can either cause world gen \n"
-							+ "lock-ups and/or crashes. \n"
-							+ "If either of those happen try setting this to True. \n"
-							+ "")
-					.build();
-			
 			public static ConfigCategory experimental = new ConfigCategory.Builder().set(Experimental.class).build();
 			
 			
@@ -1527,6 +1515,7 @@ public class Config
 							+ "How many threads should be used by Distant Horizons? \n"
 							+ "")
 					.build();
+			
 			public static final ConfigEntry<Double> threadRunTimeRatio = new ConfigEntry.Builder<Double>()
 					.setChatCommandName("threading.threadRunTimeRatio")
 					.setMinDefaultMax(0.01, ThreadPresetConfigEventHandler.getDefaultRunTimeRatio(), 1.0)
@@ -1540,6 +1529,19 @@ public class Config
 							"")
 					.build();
 			
+			public static final ConfigEntry<Integer> threadPriority = new ConfigEntry.Builder<Integer>()
+				.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE) // only in file since this requires a MC reboot to change
+				.setMinDefaultMax(Thread.MIN_PRIORITY, // 1
+					Thread.NORM_PRIORITY, // 5 (1 higher than C2ME's default priority of 4 which can help reduce issues with Chunky)
+					Thread.MAX_PRIORITY) // 10
+				.comment(""
+					+ "What Java thread priority should DH's primary thread pools run with? \n"
+					+ "\n"
+					+ "You probably don't need to change this unless you are also \n"
+					+ "running C2ME and are seeing thread starvation in either C2ME or DH. \n"
+					+ "")
+				.build();
+			
 			
 			
 		}
@@ -1576,14 +1578,6 @@ public class Config
 							+ "This can be useful for debugging.")
 					.build();
 			
-			public static ConfigEntry<EDhApiLoggerLevel> logWorldGenPerformanceToFile = new ConfigEntry.Builder<EDhApiLoggerLevel>()
-					.setChatCommandName("logging.logWorldGenPerformance")
-					.set(EDhApiLoggerLevel.INFO)
-					.comment(""
-							+ "If enabled, the mod will log performance about the world generation process. \n"
-							+ "This can be useful for debugging.")
-					.build();
-			
 			public static ConfigEntry<EDhApiLoggerLevel> logWorldGenChunkLoadEventToFile = new ConfigEntry.Builder<EDhApiLoggerLevel>()
 					.setChatCommandName("logging.logWorldGenLoadEvent")
 					.set(EDhApiLoggerLevel.INFO)
@@ -1621,6 +1615,14 @@ public class Config
 							+ "This can be useful for debugging.")
 					.build();
 			
+			public static ConfigEntry<EDhApiLoggerLevel> logConnectionConfigChangesToFile = new ConfigEntry.Builder<EDhApiLoggerLevel>()
+					.setChatCommandName("logging.logConnectionConfigChanges")
+					.set(EDhApiLoggerLevel.WARN)
+					.comment(""
+							+ "If enabled, config changes sent by the server will be logged. \n"
+							+ "")
+					.build();
+			
 			public static ConfigCategory warning = new ConfigCategory.Builder().set(Warning.class).build();
 			
 			
@@ -1669,6 +1671,14 @@ public class Config
 								+ "")
 						.build();
 				
+				public static ConfigEntry<Boolean> showSlowWorldGenSettingWarnings = new ConfigEntry.Builder<Boolean>()
+						.set(true)
+						.comment(""
+								+ "If enabled, a chat message will be displayed when DH has too many chunks \n"
+								+ "queued for updating. \n"
+								+ "")
+						.build();
+				
 				public static ConfigEntry<Boolean> showModCompatibilityWarningsOnStartup = new ConfigEntry.Builder<Boolean>()
 						.set(true)
 						.comment(""
@@ -1677,6 +1687,15 @@ public class Config
 								+ "")
 						.build();
 				
+				public static ConfigEntry<Boolean> logGarbageCollectorWarning = new ConfigEntry.Builder<Boolean>()
+					.set(true)
+					.comment(""
+						+ "If enabled, a message will be logged if the garbage \n"
+						+ "collector Java is currently using is known \n"
+						+ "to cause stutters and/or issues. \n"
+						+ "")
+					.build();
+				
 			}
 		}
 		
@@ -1746,32 +1765,6 @@ public class Config
 						"")
 				.build();
 		
-		public static ConfigEntry<Integer> generationBoundsX = new ConfigEntry.Builder<Integer>()
-				.setChatCommandName("generation.bounds.x")
-				.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE)
-				.setMinDefaultMax(Integer.MIN_VALUE, 0, Integer.MAX_VALUE)
-				.comment("" +
-						"Defines the X-coordinate of the central point for generation boundaries, in blocks. \n" +
-						"")
-				.build();
-		public static ConfigEntry<Integer> generationBoundsZ = new ConfigEntry.Builder<Integer>()
-				.setChatCommandName("generation.bounds.z")
-				.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE)
-				.setMinDefaultMax(Integer.MIN_VALUE, 0, Integer.MAX_VALUE)
-				.comment("" +
-						"Defines the Z-coordinate of the central point for generation boundaries, in blocks. \n" +
-						"")
-				.build();
-		public static ConfigEntry<Integer> generationBoundsRadius = new ConfigEntry.Builder<Integer>()
-				.setChatCommandName("generation.bounds.radius")
-				.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE)
-				.setMinDefaultMax(0, 0, Integer.MAX_VALUE)
-				.comment("" +
-						"Defines the radius around the central point within which generation is allowed, in blocks. \n" +
-						"If this value is set to 0, generation bounds are disabled." +
-						"")
-				.build();
-		
 		
 		// Real-time updates
 		public static ConfigEntry<Boolean> enableRealTimeUpdates = new ConfigEntry.Builder<Boolean>()
@@ -1892,7 +1885,8 @@ public class Config
 				ThreadPresetConfigEventHandler.INSTANCE.setUiOnlyConfigValues();
 				RenderQualityPresetConfigEventHandler.INSTANCE.setUiOnlyConfigValues();
 				QuickRenderToggleConfigEventHandler.INSTANCE.setUiOnlyConfigValues();
-				QuickShowWorldGenProgressConfigEventHandler.INSTANCE.setUiOnlyConfigValues();
+				
+				IgnoredDimensionCsvHandler.INSTANCE.onConfigValueSet();
 			}
 			catch (Exception e)
 			{

core/src/main/java/com/seibel/distanthorizons/core/config/api/converters/InvertedBoolConverter.java

@@ -17,34 +17,27 @@
  *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package com.seibel.distanthorizons.core.enums.worldGeneration;
+package com.seibel.distanthorizons.core.config.api.converters;
+
+import com.seibel.distanthorizons.api.enums.rendering.EDhApiRendererMode;
+import com.seibel.distanthorizons.coreapi.interfaces.config.IConverter;
 
 /**
- * MULTI_THREADED, <br>
- * SINGLE_THREADED, <br>
- * SERVER_THREAD, <br>
+ * Used to support deprecated config options that may be identical
+ * in implementation but with the On/Off values flipped.
  *
  * @author James Seibel
- * @version 7-25-2022
+ * @version 2025-12-22
  */
-public enum EWorldGenThreadMode
+public class InvertedBoolConverter implements IConverter<Boolean, Boolean>
 {
-	/**
-	 * This world generator can be run on an unlimited number
-	 * of concurrent threads.
-	 */
-	MULTI_THREADED,
 	
-	/**
-	 * This world generator can only be run on one thread at
-	 * a time, however that thread can run concurrently
-	 * to Minecraft's server thread.
-	 */
-	SINGLE_THREADED,
+	@Override 
+	public Boolean convertToCoreType(Boolean core)
+	{ return !core; }
+	
+	@Override 
+	public Boolean convertToApiType(Boolean api)
+	{ return !api; }
 	
-	/**
-	 * This world generator can only be run on Minecraft's
-	 * server thread.
-	 */
-	SERVER_THREAD,
 }

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

@@ -0,0 +1,125 @@
+/*
+ *    This file is part of the Distant Horizons mod
+ *    licensed under the GNU LGPL v3 License.
+ *
+ *    Copyright (C) 2020 James Seibel
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU 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.eventHandlers;
+
+import com.seibel.distanthorizons.api.enums.config.EDhApiMcRenderingFadeMode;
+import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeRenderEvent;
+import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiCancelableEventParam;
+import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.config.listeners.IConfigListener;
+import com.seibel.distanthorizons.core.logging.DhLogger;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.coreapi.util.StringUtil;
+
+public class IgnoredDimensionCsvHandler extends DhApiBeforeRenderEvent implements IConfigListener
+{
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
+	
+	public static IgnoredDimensionCsvHandler INSTANCE = new IgnoredDimensionCsvHandler();
+	
+	private String[] dimensionNames = null;
+	
+	
+	
+	//=============//
+ 	// constructor //
+	//=============//
+	
+	/** private since we only ever need one handler at a time */
+	private IgnoredDimensionCsvHandler() { }
+	
+	
+	
+	//=================//
+	// config handling //
+	//=================//
+	
+	@Override
+	public void onConfigValueSet()
+	{
+		String ignoredDimensionCsvString = Config.Client.Advanced.Graphics.Experimental.ignoredDimensionCsv.get();
+		if (ignoredDimensionCsvString == null 
+			|| ignoredDimensionCsvString.isEmpty())
+		{
+			LOGGER.info("Dimension ignoring disabled, DH will render all dimensions.");
+			this.dimensionNames = null;
+		}
+		else
+		{
+			try
+			{
+				this.dimensionNames = ignoredDimensionCsvString.split(",");
+				LOGGER.info("DH set to ignore dimensions: ["+ StringUtil.join(", ", this.dimensionNames)+"].");
+			}
+			catch (Exception e)
+			{
+				LOGGER.error("Failed to separate ignored dimensions from CSV string, error: ["+e.getMessage()+"].", e);
+				this.dimensionNames = null;
+			}
+		}
+		
+	}
+	
+	
+	
+	//===================//
+	// external handling //
+	//===================//
+	
+	@Override
+	public void beforeRender(DhApiCancelableEventParam<DhApiRenderParam> event)
+	{
+		String dimName = event.value.clientLevelWrapper.getDimensionName();
+		if (IgnoredDimensionCsvHandler.INSTANCE.dimensionNameShouldBeIgnored(dimName))
+		{
+			event.cancelEvent();
+			Config.Client.Advanced.Graphics.Fog.enableVanillaFog.setApiValue(true);
+			Config.Client.Advanced.Graphics.Quality.vanillaFadeMode.setApiValue(EDhApiMcRenderingFadeMode.NONE);
+		}
+		else
+		{
+			Config.Client.Advanced.Graphics.Fog.enableVanillaFog.setApiValue(null);
+			Config.Client.Advanced.Graphics.Quality.vanillaFadeMode.setApiValue(null);
+		}
+	}
+	
+	public boolean dimensionNameShouldBeIgnored(String dimName)
+	{
+		if (this.dimensionNames == null 
+			|| this.dimensionNames.length == 0)
+		{
+			return false;
+		}
+		
+		for (int i = 0; i < this.dimensionNames.length; i++)
+		{
+			String dimNameToIgnore = this.dimensionNames[i];
+			if (dimName.equalsIgnoreCase(dimNameToIgnore))
+			{
+				return true;
+			}
+		}
+		
+		return false;
+	}
+	
+	
+}

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

@@ -35,7 +35,7 @@ public class WorldCurvatureConfigEventHandler implements IConfigListener
 {
 	public static WorldCurvatureConfigEventHandler INSTANCE = new WorldCurvatureConfigEventHandler();
 	
-	private static final int MIN_VALID_CURVE_VALUE = 50; 
+	public static final int MIN_VALID_CURVE_VALUE = 50; 
 	
 	
 	/** private since we only ever need one handler at a time */
@@ -52,6 +52,11 @@ public class WorldCurvatureConfigEventHandler implements IConfigListener
 			// shouldn't update the UI, otherwise we may end up fighting the user
 			Config.Client.Advanced.Graphics.Experimental.earthCurveRatio.set(MIN_VALID_CURVE_VALUE);
 		}
+		else if (curveRatio < 0 && curveRatio > -MIN_VALID_CURVE_VALUE)
+		{
+			// same as above, but in the negative direction
+			Config.Client.Advanced.Graphics.Experimental.earthCurveRatio.set(-MIN_VALID_CURVE_VALUE);
+		}
 		
 	}
 	

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

@@ -1,66 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU 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.eventHandlers.presets;
-
-import com.seibel.distanthorizons.api.enums.rendering.EDhApiRendererMode;
-import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiDistantGeneratorProgressDisplayLocation;
-import com.seibel.distanthorizons.core.config.Config;
-import com.seibel.distanthorizons.core.config.listeners.ConfigChangeListener;
-
-public class QuickShowWorldGenProgressConfigEventHandler
-{
-	public static QuickShowWorldGenProgressConfigEventHandler INSTANCE = new QuickShowWorldGenProgressConfigEventHandler();
-	
-	private final ConfigChangeListener<Boolean> quickChangeListener;
-	private final ConfigChangeListener<EDhApiDistantGeneratorProgressDisplayLocation> fullChangeListener;
-	
-	
-	
-	/** private since we only ever need one handler at a time */
-	private QuickShowWorldGenProgressConfigEventHandler()
-	{
-		this.quickChangeListener = new ConfigChangeListener<>(Config.Client.quickShowWorldGenProgress, 
-				(val) -> 
-				{
-					boolean quickShowProgress = Config.Client.quickShowWorldGenProgress.get();
-					Config.Common.WorldGenerator.showGenerationProgress.set(
-							quickShowProgress
-							? EDhApiDistantGeneratorProgressDisplayLocation.OVERLAY
-							: EDhApiDistantGeneratorProgressDisplayLocation.DISABLED); 
-				});
-		this.fullChangeListener = new ConfigChangeListener<>(Config.Common.WorldGenerator.showGenerationProgress, 
-				(val) -> 
-				{
-					boolean showProgress = Config.Common.WorldGenerator.showGenerationProgress.get() != EDhApiDistantGeneratorProgressDisplayLocation.DISABLED;
-					Config.Client.quickShowWorldGenProgress.setWithoutFiringEvents(showProgress); 
-				});
-	}
-	
-	/**
-	 * Set the UI only config based on what is set in the file. <br>
-	 * This should only be called once.
-	 */
-	public void setUiOnlyConfigValues()
-	{
-		boolean showProgress = Config.Common.WorldGenerator.showGenerationProgress.get() != EDhApiDistantGeneratorProgressDisplayLocation.DISABLED;
-		Config.Client.quickShowWorldGenProgress.set(showProgress);
-	}
-	
-}

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

@@ -24,12 +24,14 @@ import com.seibel.distanthorizons.core.config.ConfigHandler;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.config.types.AbstractConfigBase;
 import com.seibel.distanthorizons.core.config.types.ConfigEntry;
+import com.seibel.distanthorizons.core.jar.EPlatform;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import org.apache.logging.log4j.LogManager;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 
+import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/fullData/FullDataPointIdMap.java

@@ -268,7 +268,7 @@ public class FullDataPointIdMap
 			// necessary to prevent issues with deserializing objects after the level has been closed
 			if (Thread.interrupted())
 			{
-				throw new InterruptedException(FullDataPointIdMap.class.getSimpleName() + " task interrupted.");
+				throw new InterruptedException("[" + FullDataPointIdMap.class.getSimpleName() + "] deserializing interrupted.");
 			}
 			
 			

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

@@ -44,6 +44,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import it.unimi.dsi.fastutil.bytes.ByteArrayList;
+import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -92,8 +93,6 @@ public class FullDataSourceV2
 	public long lastModifiedUnixDateTime;
 	public long createdUnixDateTime;
 	
-	public int levelMinY;
-	
 	/** 
 	 * stores how far each column has been generated should start with {@link EDhApiWorldGenerationStep#EMPTY}
 	 *
@@ -122,7 +121,7 @@ public class FullDataSourceV2
 	public Boolean applyToChildren = null;
 	
 	/** should only be used by methods exposed via the DH API */
-	private boolean runApiChunkValidation = false;
+	private boolean runApiSetterValidation = false;
 	
 	
 	
@@ -203,8 +202,9 @@ public class FullDataSourceV2
 	
 	public static FullDataSourceV2 createEmpty(long pos)
 	{
+		FullDataPointIdMap map = new FullDataPointIdMap(pos);
 		return new FullDataSourceV2(
-				pos, new FullDataPointIdMap(pos),
+				pos, map,
 				// data points, genSteps, and columnCompression are all null since
 				// nothing has been generated yet.
 				// Using the default value of all 0's is adequate
@@ -299,9 +299,9 @@ public class FullDataSourceV2
 	 * returns {@link FullDataPointUtil#EMPTY_DATA_POINT} if the given {@link DhBlockPos}
 	 * is outside this data source's boundaries.
 	 */
-	public long getDataPointAtBlockPos(DhBlockPos blockPos)
+	public long getDataPointAtBlockPos(int blockPosX, int blockPosY, int blockPosZ, int levelMinY)
 	{
-		DhLodPos requestedPos = new DhLodPos(LodUtil.BLOCK_DETAIL_LEVEL, blockPos.getX(), blockPos.getZ());
+		DhLodPos requestedPos = new DhLodPos(LodUtil.BLOCK_DETAIL_LEVEL, blockPosX, blockPosZ);
 		
 		// stop if the requested blockPos is outside this datasource
 		{
@@ -331,6 +331,7 @@ public class FullDataSourceV2
 		
 		
 		// search for a datapoint that contains the given block y position
+		int relBlockPosY = blockPosY - levelMinY;
 		long dataPoint;
 		for (int i = 0; i < dataColumn.size(); i++)
 		{
@@ -345,14 +346,13 @@ public class FullDataSourceV2
 			
 			
 			
-			int requestedY = blockPos.getY();
-			int bottomY = FullDataPointUtil.getBottomY(dataPoint) + this.levelMinY;
+			int bottomY = FullDataPointUtil.getBottomY(dataPoint);
 			int height = FullDataPointUtil.getHeight(dataPoint);
 			int topY = bottomY + height;
 			
 			// does this datapoint contain the requested Y position? 
-			if (bottomY <= requestedY
-				&& requestedY < topY) // blockPositions start from the bottom of the block, thus "<=" for bottomY, just "<" for topY
+			if (bottomY <= relBlockPosY
+				&& relBlockPosY < topY) // blockPositions start from the bottom of the block, thus "<=" for bottomY, just "<" for topY
 			{
 				return dataPoint;
 			}
@@ -367,7 +367,7 @@ public class FullDataSourceV2
 	// updating //
 	//==========//
 	
-	public boolean updateFromChunk(@NotNull FullDataSourceV2 inputDataSource)
+	public boolean updateFromDataSource(@NotNull FullDataSourceV2 inputDataSource)
 	{
 		// don't try updating if the input is empty
 		if (inputDataSource.mapping.isEmpty())
@@ -470,7 +470,7 @@ public class FullDataSourceV2
 		return dataChanged;
 	}
 	
-	public boolean updateFromSameDetailLevel(FullDataSourceV2 inputDataSource, int[] remappedIds)
+	private boolean updateFromSameDetailLevel(FullDataSourceV2 inputDataSource, int[] remappedIds)
 	{
 		// both data sources should have the same detail level
 		if (DhSectionPos.getDetailLevel(inputDataSource.pos) != DhSectionPos.getDetailLevel(this.pos))
@@ -486,96 +486,103 @@ public class FullDataSourceV2
 			for (int z = 0; z < WIDTH; z++)
 			{
 				int index = relativePosToIndex(x, z);
-				
 				LongArrayList inputDataArray = inputDataSource.dataPoints[index];
-				if (inputDataArray != null)
+				if (inputDataArray == null)
 				{
-					byte thisGenState = this.columnGenerationSteps.getByte(index);
-					byte inputGenState = inputDataSource.columnGenerationSteps.getByte(index);
+					continue;
+				}
 				
-					
-					// determine if this column should be updated
-					boolean genStateAllowsUpdating = false;
-					// if the input is downsampled, we only want to replace empty or downsampled values
-					if (inputGenState == EDhApiWorldGenerationStep.DOWN_SAMPLED.value
-						&&
-						(
-							thisGenState == EDhApiWorldGenerationStep.EMPTY.value
-							|| thisGenState == EDhApiWorldGenerationStep.DOWN_SAMPLED.value
-						))
+				
+				
+				byte thisGenState = this.columnGenerationSteps.getByte(index);
+				byte inputGenState = inputDataSource.columnGenerationSteps.getByte(index);
+				
+				
+				// determine if this column should be updated
+				boolean genStateAllowsUpdating = false;
+				// if the input is downsampled, we only want to replace empty or downsampled values
+				if (inputGenState == EDhApiWorldGenerationStep.DOWN_SAMPLED.value
+					&&
+					(
+						thisGenState == EDhApiWorldGenerationStep.EMPTY.value
+						|| thisGenState == EDhApiWorldGenerationStep.DOWN_SAMPLED.value
+					))
+				{
+					genStateAllowsUpdating = true;
+				}
+				// if the input is any other non-empty value,
+				// replace anything that is less-complete
+				else if (inputGenState != EDhApiWorldGenerationStep.EMPTY.value
+					&& thisGenState <= inputGenState)
+				{
+					// don't apply less-complete generation data
+					genStateAllowsUpdating = true;
+				}
+				
+				if (!genStateAllowsUpdating)
+				{
+					continue;
+				}
+				
+				
+				
+				// check if the data changed
+				if (this.dataPoints[index] == null)
+				{
+					// no data was present previously
+					this.dataPoints[index] = new LongArrayList(inputDataArray);
+					dataChanged = true;
+				}
+				else if (this.dataPoints[index].size() != inputDataArray.size())
+				{
+					// data is present, but the size is different
+					dataChanged = true;
+				}
+				
+				int oldDataHash = 0;
+				if (!dataChanged)
+				{
+					// some old data existed with the same length,
+					// we'll have to compare the caches
+					oldDataHash = this.dataPoints[index].hashCode();
+				}
+				
+				
+				// copy over the new data
+				this.dataPoints[index].clear();
+				this.dataPoints[index].addAll(inputDataArray);
+				this.remapDataColumn(index, remappedIds);
+				
+				if (RUN_DATA_ORDER_VALIDATION)
+				{
+					throwIfDataColumnInWrongOrder(inputDataSource.pos, this.dataPoints[index]);
+				}
+				
+				
+				
+				if (!dataChanged)
+				{
+					// check if the identical length data column hashes are the same
+					// hashes need to be compared after the ID's have been remapped otherwise the ID's won't match even if the data is the same
+					if (oldDataHash != this.dataPoints[index].hashCode())
 					{
-						genStateAllowsUpdating = true;
-					}
-					// if the input is any other non-empty value,
-					// replace anything that is less-complete
-					else if (inputGenState != EDhApiWorldGenerationStep.EMPTY.value
-							&& thisGenState <= inputGenState)
-					{
-						// don't apply less-complete generation data
-						genStateAllowsUpdating = true;
-					}
-					
-					
-					if (genStateAllowsUpdating)
-					{
-						// check if the data changed
-						if (this.dataPoints[index] == null)
-						{
-							// no data was present previously
-							this.dataPoints[index] = new LongArrayList(inputDataArray);
-							dataChanged = true;
-						}
-						else if (this.dataPoints[index].size() != inputDataArray.size())
-						{
-							// data is present, but the size is different
-							dataChanged = true;
-						}
-						
-						int oldDataHash = 0;
-						if (!dataChanged)
-						{
-							// some old data existed with the same length,
-							// we'll have to compare the caches
-							oldDataHash = this.dataPoints[index].hashCode();
-						}
-						
-						
-						// copy over the new data
-						this.dataPoints[index].clear();
-						this.dataPoints[index].addAll(inputDataArray);
-						this.remapDataColumn(index, remappedIds);
-						
-						if (RUN_DATA_ORDER_VALIDATION)
-						{
-							throwIfDataColumnInWrongOrder(inputDataSource.pos, this.dataPoints[index]);
-						}
-						
-						
-						
-						if (!dataChanged)
-						{
-							// check if the identical length data column hashes are the same
-							// hashes need to be compared after the ID's have been remapped otherwise the ID's won't match even if the data is the same
-							if (oldDataHash != this.dataPoints[index].hashCode())
-							{
-								// the hashes are different, something was changed
-								dataChanged = true;
-							}
-						}
-						
-						
-						this.columnGenerationSteps.set(index, inputGenState);
-						// always overwrite the compression mode since we're replacing this column
-						this.columnWorldCompressionMode.set(index, inputDataSource.columnWorldCompressionMode.getByte(index));
-						this.isEmpty = false;
+						// the hashes are different, something was changed
+						dataChanged = true;
 					}
 				}
+				
+				
+				this.columnGenerationSteps.set(index, inputGenState);
+				// always overwrite the compression mode since we're replacing this column
+				this.columnWorldCompressionMode.set(index, inputDataSource.columnWorldCompressionMode.getByte(index));
+				this.isEmpty = false;
 			}
 		}
 		
 		return dataChanged;
 	}
-	public boolean updateFromOneBelowDetailLevel(FullDataSourceV2 inputDataSource, int[] remappedIds)
+	
+	private boolean updateFromOneBelowDetailLevel(FullDataSourceV2 inputDataSource, int[] remappedIds)
 	{
 		if (DhSectionPos.getDetailLevel(inputDataSource.pos) + 1 != DhSectionPos.getDetailLevel(this.pos))
 		{
@@ -711,176 +718,221 @@ public class FullDataSourceV2
 	{
 		LongArrayList newColumnList = new LongArrayList();
 		
-		// special numbers:
-		// -2 = the column's height hasn't been determined yet
-		// -1 = we've reached the end of the column
-		int[] currentDatapointIndex = new int[] { -2, -2, -2, -2 };
+		
+		//=========================//
+		// get the 4 input columns //
+		//=========================//
+		
+		LongArrayList[] inputColumns = new LongArrayList[4];
+		int colIndex = 0;
+		for (int inputX = x; inputX < x + 2; inputX++)
+		{
+			for (int inputZ = z; inputZ < z + 2; inputZ++, colIndex++)
+			{
+				inputColumns[colIndex] = inputDataSource.dataPoints[relativePosToIndex(inputX, inputZ)];
+				if (inputColumns[colIndex] != null 
+					&& RUN_DATA_ORDER_VALIDATION)
+				{
+					throwIfDataColumnInWrongOrder(inputDataSource.pos, inputColumns[colIndex]);
+				}
+			}
+		}
+		
+		
+		
+		//========================================//
+		// find all y levels where changes happen //
+		//========================================//
+		
+		IntArrayList yTransitions = new IntArrayList();
+		for (int i = 0; i < 4; i++)
+		{
+			if (inputColumns[i] == null 
+				|| inputColumns[i].isEmpty())
+			{
+				continue;
+			}
+			
+			for (int j = 0; j < inputColumns[i].size(); j++)
+			{
+				long datapoint = inputColumns[i].getLong(j);
+				int minY = FullDataPointUtil.getBottomY(datapoint);
+				int maxY = minY + FullDataPointUtil.getHeight(datapoint);
+				
+				if (!yTransitions.contains(minY))
+				{
+					yTransitions.add(minY);
+				}
+				
+				if (!yTransitions.contains(maxY))
+				{
+					yTransitions.add(maxY);
+				}
+			}
+		}
+		
+		// can happen if the columns are empty
+		if (yTransitions.isEmpty())
+		{
+			return newColumnList;
+		}
+		
+		// sort the transitions from bottom to top // TODO
+		yTransitions.sort(null);
+		
+		// create index trackers for each column, 
+		// starting with the top-most datapoint
+		int[] currentIndices = new int[4];
+		for (int i = 0; i < 4; i++)
+		{
+			if (inputColumns[i] != null 
+				&& !inputColumns[i].isEmpty())
+			{
+				currentIndices[i] = inputColumns[i].size() - 1;
+			}
+			else
+			{
+				currentIndices[i] = -1;
+			}
+		}
+		
+		
+		
+		//=======================//
+		// process each Y change //
+		//=======================//
 		
 		int lastId = 0;
 		byte lastBlockLight = 0;
 		byte lastSkyLight = 0;
-		int height = 0;
-		int minY = 0;
+		int currentMinY = yTransitions.getInt(0);
+		int accumulatedHeight = 0;
 		
-		
-		// these arrays will be reused quite often, so re-using them helps reduce some GC pressure
-		long[] datapointsForYSlice = new long[4];
 		int[] mergeIds = new int[4];
 		int[] mergeBlockLights = new int[4];
 		int[] mergeSkyLights = new int[4];
 		
-		
-		for (int blockY = 0; blockY < RenderDataPointUtil.MAX_WORLD_Y_SIZE; blockY++, height++)
+		for (int yIndex = 0; yIndex < yTransitions.size() - 1; yIndex++)
 		{
-			// if each column has reached the end of their data, nothing more needs to be done
-			if (currentDatapointIndex[0] == -1
-				&& currentDatapointIndex[1] == -1
-				&& currentDatapointIndex[2] == -1
-				&& currentDatapointIndex[3] == -1
-				)
-			{
-				break;
-			}
-			
-			
-			// scary double loop but, 
-			// this will only ever loop 4 times, 
-			// once for each of the 4 input columns
-			Arrays.fill(datapointsForYSlice, 0L);
-			int colIndex = 0;
-			for (int inputX = x; inputX < x + 2; inputX++)
-			{
-				for (int inputZ = z; inputZ < z + 2; inputZ++, colIndex++)
-				{
-					// TODO throw an assertion if the column isn't in top-down order or just fix it...
-					LongArrayList inputDataArray = inputDataSource.dataPoints[relativePosToIndex(inputX, inputZ)];
-					if (inputDataArray == null || inputDataArray.size() == 0)
-					{
-						currentDatapointIndex[colIndex] = -1;
-						continue;
-					}
-					
-					// determine the last index (the lowest data point) for each column
-					if (currentDatapointIndex[colIndex] == -2)
-					{
-						currentDatapointIndex[colIndex] = inputDataArray.size() - 1;
-						
-						if (RUN_DATA_ORDER_VALIDATION)
-						{
-							throwIfDataColumnInWrongOrder(inputDataSource.pos, inputDataArray);
-						}
-					}
-					
-					
-					int dataPointIndex = currentDatapointIndex[colIndex];
-					if (dataPointIndex == -1)
-					{
-						// went over the end 
-						continue;
-					}
-					long datapoint = inputDataArray.getLong(dataPointIndex);
-					
-					int datapointMinY = FullDataPointUtil.getBottomY(datapoint);
-					int numbOfBlocksTall = FullDataPointUtil.getHeight(datapoint);
-					int datapointMaxY = (datapointMinY + numbOfBlocksTall);
-					
-					
-					// check if y position is inside this datapoint
-					if (blockY < datapointMinY)
-					{
-						// this y-slice is below this datapoint, nothing can be added
-						continue;
-					}
-					else if (blockY >= datapointMaxY)
-					{
-						// this y-slice is above the current datapoint,
-						// try the next data point
-						
-						int newDatapointIndex = currentDatapointIndex[colIndex] - 1;
-						if (newDatapointIndex < 0)
-						{
-							// went to far, no additional data present
-							newDatapointIndex = -1;
-						}
-						currentDatapointIndex[colIndex] = newDatapointIndex;
-						
-						
-						// try again with the next data point
-						inputZ--;
-						colIndex--;
-						continue;
-					}
-					
-					
-					
-					datapointsForYSlice[colIndex] = datapoint;
-				}
-			}
-			
+			int sliceMinY = yTransitions.getInt(yIndex);
+			int sliceMaxY = yTransitions.getInt(yIndex + 1);
+			int sliceHeight = sliceMaxY - sliceMinY;
 			
+			// Sample at the midpoint of this slice
+			int sampleY = sliceMinY + (sliceHeight / 2);
 			
+			// Get data from each column at this Y level
 			Arrays.fill(mergeIds, 0);
 			Arrays.fill(mergeBlockLights, 0);
 			Arrays.fill(mergeSkyLights, 0);
+			
 			for (int i = 0; i < 4; i++)
 			{
-				mergeIds[i] = FullDataPointUtil.getId(datapointsForYSlice[i]);
-				mergeBlockLights[i] = FullDataPointUtil.getBlockLight(datapointsForYSlice[i]);
-				mergeSkyLights[i] = FullDataPointUtil.getSkyLight(datapointsForYSlice[i]);
+				// skip columns that are empty or where we have already reached the bottom
+				if (currentIndices[i] == -1)
+				{
+					continue;
+				}
+				
+				
+				LongArrayList column = inputColumns[i];
+				if (column == null)
+				{
+					continue;
+				}
+				
+				// move the index down if we've passed the current datapoint
+				while (currentIndices[i] >= 0)
+				{
+					long datapoint = column.getLong(currentIndices[i]);
+					int inputMinY = FullDataPointUtil.getBottomY(datapoint);
+					int inputMaxY = inputMinY + FullDataPointUtil.getHeight(datapoint);
+					
+					if (sampleY >= inputMaxY)
+					{
+						// Sample point is above this datapoint, move to next (lower) one
+						currentIndices[i]--;
+					}
+					else if (sampleY >= inputMinY 
+							&& sampleY < inputMaxY)
+					{
+						// Sample point is within this datapoint
+						mergeIds[i] = FullDataPointUtil.getId(datapoint);
+						mergeBlockLights[i] = FullDataPointUtil.getBlockLight(datapoint);
+						mergeSkyLights[i] = FullDataPointUtil.getSkyLight(datapoint);
+						break;
+					}
+					else
+					{
+						// Sample point is below this datapoint
+						break;
+					}
+				}
 			}
 			
 			
-			// determine the most common values for this slice
-			int id = determineMostValueInColumnSlice(mergeIds, inputDataSource.mapping);
+			
+			// Determine merged values for this slice
+			int id = determineMostCommonValueInColumnSlice(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
-				|| blockLight != lastBlockLight
-				|| skyLight != lastSkyLight)
+			// Check if we need to start a new datapoint
+			if (accumulatedHeight == 0)
 			{
-				if (height != 0)
-				{
-					try
-					{
-						long datapoint = FullDataPointUtil.encode(lastId, height, minY, lastBlockLight, lastSkyLight);
-						newColumnList.add(datapoint);
-					}
-					catch (DataCorruptedException e)
-					{
-						// shouldn't happen, (especially if validation is disabled) but just in case
-						LOGGER.warn("Skipping corrupt datapoint for pos ["+DhSectionPos.toString(inputDataSource.pos)+"] at relative position ["+x+","+z+"] with data: ID["+lastId+"], Height["+height+"], minY["+minY+"], lastBlockLight["+lastBlockLight+"], lastSkyLight["+lastSkyLight+"].");
-					}
-				}
-				
+				// first datapoint
 				lastId = id;
 				lastBlockLight = blockLight;
 				lastSkyLight = skyLight;
-				height = 0;
-				minY = blockY;
+				currentMinY = sliceMinY;
+				accumulatedHeight = sliceHeight;
+			}
+			else if (id != lastId 
+					|| blockLight != lastBlockLight 
+					|| skyLight != lastSkyLight)
+			{
+				// the data changed, create a new datapoint
+				try
+				{
+					long datapoint = FullDataPointUtil.encode(lastId, accumulatedHeight, currentMinY, lastBlockLight, lastSkyLight);
+					newColumnList.add(datapoint);
+				}
+				catch (DataCorruptedException e)
+				{
+					LOGGER.warn("Skipping corrupt datapoint for pos ["+DhSectionPos.toString(inputDataSource.pos)+"] at relative position ["+x+","+z+"] with data: ID["+lastId+"], Height["+accumulatedHeight+"], minY["+currentMinY+"], lastBlockLight["+lastBlockLight+"], lastSkyLight["+lastSkyLight+"].");
+				}
+				
+				// start the next datapoint
+				lastId = id;
+				lastBlockLight = blockLight;
+				lastSkyLight = skyLight;
+				currentMinY = sliceMinY;
+				accumulatedHeight = sliceHeight;
+			}
+			else
+			{
+				// this datapoint is the same as the last one, 
+				// just extend it's height
+				accumulatedHeight += sliceHeight;
 			}
 		}
 		
-		// add the last slice if present
-		if (height != 0)
+		
+		// add the final datapoint if needed
+		if (accumulatedHeight > 0)
 		{
 			try
 			{
-				newColumnList.add(FullDataPointUtil.encode(lastId, height, minY, lastBlockLight, lastSkyLight));
+				newColumnList.add(FullDataPointUtil.encode(lastId, accumulatedHeight, currentMinY, lastBlockLight, lastSkyLight));
 			}
 			catch (DataCorruptedException e)
 			{
-				// shouldn't happen, (especially if validation is disabled) but just in case
-				LOGGER.warn("Skipping corrupt datapoint for pos ["+DhSectionPos.toString(inputDataSource.pos)+"] at relative position ["+x+","+z+"] with data: ID["+lastId+"], Height["+height+"], minY["+minY+"], lastBlockLight["+lastBlockLight+"], lastSkyLight["+lastSkyLight+"].");
+				LOGGER.warn("Skipping corrupt datapoint for pos ["+DhSectionPos.toString(inputDataSource.pos)+"] at relative position ["+x+","+z+"] with data: ID["+lastId+"], Height["+accumulatedHeight+"], minY["+currentMinY+"], lastBlockLight["+lastBlockLight+"], lastSkyLight["+lastSkyLight+"].");
 			}
 		}
 		
 		
-		// flip the array if necessary
-		// TODO why is this sometimes necessary? What did I (James) screw up that causes the mergedInputDataArray
-		//  to sometimes be in a different order? Is it potentially related to what detail level is coming in?
+		// confirm the array is in the correct order
 		ensureDataColumnOrder(newColumnList);
 		
 		return newColumnList;
@@ -898,23 +950,8 @@ public class FullDataSourceV2
 			dataColumn.set(i, FullDataPointUtil.remap(remappedIds, dataColumn.getLong(i)));
 		}
 	}
-	private static boolean areDataColumnsDifferent(long[] oldDataArray, long[] newDataArray)
-	{
-		if (oldDataArray == null || oldDataArray.length != newDataArray.length)
-		{
-			// new data was added/removed
-			return true;
-		}
-		else
-		{
-			// check if the new column data is different
-			int oldArrayHash = Arrays.hashCode(oldDataArray);
-			int newArrayHash = Arrays.hashCode(newDataArray);
-			return (newArrayHash != oldArrayHash);
-		}
-	}
 	/** @param mapping can be included to ignore air ID's, otherwise all 4 values are treated equally */
-	private static int determineMostValueInColumnSlice(int[] sliceArray, @Nullable FullDataPointIdMap mapping)
+	private static int determineMostCommonValueInColumnSlice(int[] sliceArray, @Nullable FullDataPointIdMap mapping)
 	{
 		if (RUN_UPDATE_DEV_VALIDATION)
 		{
@@ -958,7 +995,7 @@ public class FullDataSourceV2
 			}
 		}
 		
-		// return the most common occurance
+		// return the most common occurrence
 		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
@@ -1260,7 +1297,7 @@ public class FullDataSourceV2
 	// API methods //
 	//=============//
 	
-	public void setRunApiChunkValidation(boolean runValidation) { this.runApiChunkValidation = runValidation; }
+	public void setRunApiSetterValidation(boolean runValidation) { this.runApiSetterValidation = runValidation; }
 	
 	@Override
 	public int getWidthInDataColumns() { return WIDTH; }
@@ -1271,13 +1308,13 @@ public class FullDataSourceV2
 	{
 		try
 		{
-			LodDataBuilder.correctDataColumnOrder(columnDataPoints);
-			if (this.runApiChunkValidation)
+			LodDataBuilder.putListInTopDownOrder(columnDataPoints);
+			if (this.runApiSetterValidation)
 			{
 				LodDataBuilder.validateOrThrowApiDataColumn(columnDataPoints);
 			}
 			
-			LongArrayList packedDataPoints = LodDataBuilder.convertApiDataPointListToPackedLongArray(columnDataPoints, this, 0);
+			LongArrayList packedDataPoints = LodDataBuilder.convertApiDataPointListToPackedLongArray(columnDataPoints, this, 0, true);
 			
 			// TODO there should be an "unknown" compression and generation step, or be defined via the datapoints
 			this.setSingleColumn(packedDataPoints, relX, relZ, EDhApiWorldGenerationStep.SURFACE, EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS);
@@ -1300,7 +1337,7 @@ public class FullDataSourceV2
 		{
 			long datapoint = dataColumn.getLong(i);
 			
-			DhApiTerrainDataPoint apiDataPoint = DhApiTerrainDataPointUtil.createApiDatapoint(this.levelMinY, this.mapping, DhSectionPos.getDetailLevel(this.pos), datapoint);
+			DhApiTerrainDataPoint apiDataPoint = DhApiTerrainDataPointUtil.createApiDatapoint(0, this.mapping, DhSectionPos.getDetailLevel(this.pos), datapoint);
 			apiList.add(apiDataPoint);
 		}
 		

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

@@ -157,8 +157,8 @@ public final class BufferQuad
 			return false;
 		
 		// make sure these quads share the same perpendicular axis
-		if ((mergeDirection == BufferMergeDirectionEnum.EastWest && this.y != quad.y) ||
-				(mergeDirection == BufferMergeDirectionEnum.NorthSouthOrUpDown && this.x != quad.x))
+		if ((mergeDirection == BufferMergeDirectionEnum.EastWest && this.y != quad.y)
+			|| (mergeDirection == BufferMergeDirectionEnum.NorthSouthOrUpDown && this.x != quad.x))
 		{
 			return false;
 		}

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

@@ -24,19 +24,19 @@ 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.pooling.PhantomArrayListCheckout;
-import com.seibel.distanthorizons.core.pooling.PhantomArrayListPool;
 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.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnArrayView;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
 import com.seibel.distanthorizons.coreapi.util.MathUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import org.jetbrains.annotations.NotNull;
 
 public class ColumnBox
 {
-	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
+	private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class);
 	
 	/** 
 	 * if the skylight has this value that means
@@ -46,7 +46,6 @@ public class ColumnBox
 	
 	
 	
-	
 	//=========//
 	// builder //
 	//=========//
@@ -124,7 +123,7 @@ public class ColumnBox
 					&& !isTopTransparent;
 			if (!skipTop)
 			{
-				builder.addQuadUp(minX, maxY, minZ, width, width, ColorUtil.applyShade(color, MC.getShade(EDhDirection.UP)), irisBlockMaterialId, skyLightTop, blockLight);
+				builder.addQuadUp(minX, maxY, minZ, width, width, ColorUtil.applyShade(color, MC_RENDER.getShade(EDhDirection.UP)), irisBlockMaterialId, skyLightTop, blockLight);
 			}
 		}
 		
@@ -135,7 +134,7 @@ public class ColumnBox
 					&& !isBottomTransparent;
 			if (!skipBottom)
 			{
-				builder.addQuadDown(minX, minY, minZ, width, width, ColorUtil.applyShade(color, MC.getShade(EDhDirection.DOWN)), irisBlockMaterialId, skyLightBot, blockLight);
+				builder.addQuadDown(minX, minY, minZ, width, width, ColorUtil.applyShade(color, MC_RENDER.getShade(EDhDirection.DOWN)), irisBlockMaterialId, skyLightBot, blockLight);
 			}
 		}
 		
@@ -249,10 +248,10 @@ public class ColumnBox
 	}
 	
 	private static void makeAdjVerticalQuad(
-			LodQuadBuilder builder, PhantomArrayListCheckout phantomArrayCheckout,
-			@NotNull ColumnArrayView adjColumnView, boolean adjacentIsSameDetailLevel, int caveCullingMaxY, EDhDirection direction,
-			short x, short yMin, short z, short horizontalWidth, short ySize,
-			int color, byte irisBlockMaterialId, byte blockLight)
+		LodQuadBuilder builder, PhantomArrayListCheckout phantomArrayCheckout,
+		@NotNull ColumnArrayView adjColumnView, boolean adjacentIsSameDetailLevel, int caveCullingMaxY, EDhDirection direction,
+		short x, short yMin, short z, short horizontalWidth, short ySize,
+		int color, byte irisBlockMaterialId, byte blockLight)
 	{
 		// pooled arrays
 		LongArrayList segments = phantomArrayCheckout.getLongArray(0, 0);
@@ -265,7 +264,7 @@ public class ColumnBox
 		// no adjacent data //
 		//==================//
 		
-		color = ColorUtil.applyShade(color, MC.getShade(direction));
+		color = ColorUtil.applyShade(color, MC_RENDER.getShade(direction));
 		
 		if (adjColumnView.size == 0
 			|| RenderDataPointUtil.hasZeroHeight(adjColumnView.get(0)))
@@ -311,9 +310,10 @@ public class ColumnBox
 			long adjBelowPoint = (adjIndex + 1 < adjCount) ? adjColumnView.get(adjIndex + 1) : RenderDataPointUtil.EMPTY_DATA;
 			
 			boolean adjOverVoid = !RenderDataPointUtil.doesDataPointExist(adjBelowPoint);
-			boolean adjTransparent = !adjOverVoid
-					&& RenderDataPointUtil.getAlpha(adjPoint) < 255
-					&& transparencyEnabled;
+			boolean adjTransparent = 
+				!adjOverVoid
+				&& RenderDataPointUtil.getAlpha(adjPoint) < 255
+				&& transparencyEnabled;
 			
 			byte adjSkyLight = RenderDataPointUtil.getLightSky(adjPoint);
 			byte lightToApply;
@@ -323,14 +323,14 @@ public class ColumnBox
 				// Adjacent is opaque
 				boolean adjacentCoversThis =
 					!adjacentIsSameDetailLevel
-					&& RenderDataPointUtil.getYMax(adjPoint) >= caveCullingMaxY
-					&&
-					(
-						(x == 0 && direction == EDhDirection.WEST)
-						|| (z == 0 && direction == EDhDirection.NORTH)
-						|| (x == 256 && direction == EDhDirection.EAST)
-						|| (z == 256 && direction == EDhDirection.SOUTH)
-					);
+						&& RenderDataPointUtil.getYMax(adjPoint) >= caveCullingMaxY
+						&&
+						(
+							(x == 0 && direction == EDhDirection.WEST)
+							|| (z == 0 && direction == EDhDirection.NORTH)
+							|| (x == 256 && direction == EDhDirection.EAST)
+							|| (z == 256 && direction == EDhDirection.SOUTH)
+						);
 				
 				lightToApply = adjacentCoversThis ? adjSkyLight : SKYLIGHT_COVERED;
 			}
@@ -363,10 +363,10 @@ public class ColumnBox
 		{
 			long segment = segments.getLong(i);
 			tryAddVerticalFaceWithSkyLightToBuilder(
-					builder, direction,
-					x, z, horizontalWidth,
-					color, irisBlockMaterialId, blockLight,
-					YSegmentUtil.getSkyLight(segment), inputTransparent, YSegmentUtil.getEndY(segment), YSegmentUtil.getStartY(segment)
+				builder, direction,
+				x, z, horizontalWidth,
+				color, irisBlockMaterialId, blockLight,
+				YSegmentUtil.getSkyLight(segment), inputTransparent, YSegmentUtil.getEndY(segment), YSegmentUtil.getStartY(segment)
 			);
 		}
 	}

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

@@ -107,12 +107,13 @@ public class LodBufferContainer implements AutoCloseable
 		
 		
 		// upload on MC's render thread
-		GLProxy.getInstance().queueRunningOnRenderThread(() ->
+		GLProxy.queueRunningOnRenderThread(() ->
 		{
 			try
 			{
 				// skip this event if requested
-				if (Thread.interrupted() || this.uploadFuture.isCancelled())
+				if (Thread.interrupted() 
+					|| this.uploadFuture.isCancelled())
 				{
 					throw new InterruptedException();
 				}
@@ -294,24 +295,21 @@ public class LodBufferContainer implements AutoCloseable
 	{
 		this.buffersUploaded = false;
 		
-		GLProxy.getInstance().queueRunningOnRenderThread(() ->
+		for (GLVertexBuffer buffer : this.vbos)
 		{
-			for (GLVertexBuffer buffer : this.vbos)
+			if (buffer != null)
 			{
-				if (buffer != null)
-				{
-					buffer.destroyAsync();
-				}
+				buffer.destroyAsync();
 			}
-			
-			for (GLVertexBuffer buffer : this.vbosTransparent)
+		}
+		
+		for (GLVertexBuffer buffer : this.vbosTransparent)
+		{
+			if (buffer != null)
 			{
-				if (buffer != null)
-				{
-					buffer.destroyAsync();
-				}
+				buffer.destroyAsync();
 			}
-		});
+		}
 	}
 	
 }

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

@@ -32,6 +32,7 @@ import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.util.ColorUtil;
 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.coreapi.util.MathUtil;
 import org.lwjgl.system.MemoryUtil;
@@ -44,7 +45,7 @@ import org.lwjgl.system.MemoryUtil;
 public class LodQuadBuilder
 {
 	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
-	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
+	private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class);
 	
 	@SuppressWarnings("unchecked")
 	private final ArrayList<BufferQuad>[] opaqueQuads = (ArrayList<BufferQuad>[]) new ArrayList[6];
@@ -148,8 +149,18 @@ public class LodQuadBuilder
 			throw new IllegalArgumentException("addQuadAdj() is only for adj direction! Not UP or Down!");
 		}
 		
+		
+		ArrayList<BufferQuad> quadList;
+		if (this.doTransparency && ColorUtil.getAlpha(color) < 255)
+		{
+			quadList = this.transparentQuads[dir.ordinal()];
+		}
+		else
+		{
+			quadList = this.opaqueQuads[dir.ordinal()]; 
+		}
+		
 		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()
 			&& (
 				quadList.get(quadList.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.EastWest)
@@ -361,15 +372,15 @@ public class LodQuadBuilder
 						if (quad.direction.axis.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
 								color = this.clientLevelWrapper.getDirtBlockColor();
-								color = ColorUtil.applyShade(color, MC.getShade(quad.direction));
+								color = ColorUtil.applyShade(color, MC_RENDER.getShade(quad.direction));
 							}
 						}
 					}
@@ -388,31 +399,33 @@ public class LodQuadBuilder
 	}
 	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;
-		blocklight %= 16;
-		
 		bb.putShort(x);
 		bb.putShort(y);
 		bb.putShort(z);
 		
 		short meta = 0;
-		meta |= (skylight | (blocklight << 4));
-		byte mirco = 0;
-		// mirco offset which is a xyz 2bit value
-		// 0b00 = no offset
-		// 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;
-		meta |= mirco << 8;
-		
+		{
+			skylight %= 16;
+			blocklight %= 16;
+			meta |= (short) (skylight | (blocklight << 4));
+			
+			byte mircoOffset = 0;
+			// mirco offset which is a xyz 2bit value
+			// 0b00 = no offset
+			// 0b01 = positive offset
+			// 0b11 = negative offset
+			// format is: 0b00zzyyxx
+			if (mx != 0) { mircoOffset |= (byte) (mx > 0 ? 0b01 : 0b11); }
+			if (my != 0) { mircoOffset |= (byte) (my > 0 ? 0b0100 : 0b1100); }
+			if (mz != 0) { mircoOffset |= (byte) (mz > 0 ? 0b010000 : 0b110000); }
+			meta |= (short) (mircoOffset << 8);
+		}
 		bb.putShort(meta);
+		
 		byte r = (byte) ColorUtil.getRed(color);
 		byte g = (byte) ColorUtil.getGreen(color);
 		byte b = (byte) ColorUtil.getBlue(color);
-		byte a = this.doTransparency ? (byte) ColorUtil.getAlpha(color) : (byte) 255; // TODO should this be called here or happen somewhere else?
+		byte a = this.doTransparency ? (byte) ColorUtil.getAlpha(color) : (byte) 255;
 		bb.put(r);
 		bb.put(g);
 		bb.put(b);

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

@@ -31,11 +31,9 @@ import com.seibel.distanthorizons.core.pooling.PhantomArrayListCheckout;
 import com.seibel.distanthorizons.core.pooling.PhantomArrayListPool;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPosMutable;
-import com.seibel.distanthorizons.core.render.LodQuadTree;
 import com.seibel.distanthorizons.core.util.*;
 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.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
@@ -54,11 +52,11 @@ public class FullDataToRenderDataTransformer
 	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	private static final IWrapperFactory WRAPPER_FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
-	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	
-	private static final LongOpenHashSet brokenPos = new LongOpenHashSet();
+	private static final LongOpenHashSet BROKEN_POS_SET = new LongOpenHashSet();
+	private static final PhantomArrayListPool ARRAY_LIST_POOL = new PhantomArrayListPool("Data Transformer");
 	
-	public static final PhantomArrayListPool ARRAY_LIST_POOL = new PhantomArrayListPool("Data Transformer");
+	private static HashSet<IBlockStateWrapper> snowLayerBlockStates = null;
 	
 	
 	
@@ -198,6 +196,16 @@ public class FullDataToRenderDataTransformer
 		HashSet<IBlockStateWrapper> blockStatesToIgnore = WRAPPER_FACTORY.getRendererIgnoredBlocks(levelWrapper);
 		HashSet<IBlockStateWrapper> caveBlockStatesToIgnore = WRAPPER_FACTORY.getRendererIgnoredCaveBlocks(levelWrapper);
 		
+		// build snow block cache if needed
+		if (snowLayerBlockStates == null)
+		{
+			snowLayerBlockStates = new HashSet<>();
+			// ignore snow layers 1-3, everything above should be considered a full block
+			snowLayerBlockStates.add(WRAPPER_FACTORY.deserializeBlockStateWrapperOrGetDefault("minecraft:snow_STATE_{layers:1}", levelWrapper));
+			snowLayerBlockStates.add(WRAPPER_FACTORY.deserializeBlockStateWrapperOrGetDefault("minecraft:snow_STATE_{layers:2}", levelWrapper));
+			snowLayerBlockStates.add(WRAPPER_FACTORY.deserializeBlockStateWrapperOrGetDefault("minecraft:snow_STATE_{layers:3}", levelWrapper));
+		}
+		
 		int caveCullingMaxY = Config.Client.Advanced.Graphics.Culling.caveCullingHeight.get() - levelWrapper.getMinHeight();
 		boolean caveCullingEnabled = 
 			Config.Client.Advanced.Graphics.Culling.enableCaveCulling.get()
@@ -252,9 +260,9 @@ public class FullDataToRenderDataTransformer
 			}
 			catch (IndexOutOfBoundsException e)
 			{
-				if (!brokenPos.contains(fullDataMapping.getPos()))
+				if (!BROKEN_POS_SET.contains(fullDataMapping.getPos()))
 				{
-					brokenPos.add(fullDataMapping.getPos());
+					BROKEN_POS_SET.add(fullDataMapping.getPos());
 					String levelId = levelWrapper.getDhIdentifier();
 					LOGGER.warn("Unable to get data point with id ["+id+"] " +
 							"(Max possible ID: ["+fullDataMapping.getMaxValidId()+"]) " +
@@ -324,10 +332,26 @@ public class FullDataToRenderDataTransformer
 			// non-solid block check //
 			//=======================//
 			
-			if (ignoreNonCollidingBlocks
-					&& !block.isSolid()
-					&& !block.isLiquid()
-					&& block.getOpacity() != LodUtil.BLOCK_FULLY_OPAQUE)
+			boolean ignoreNonSolidBlock =
+				ignoreNonCollidingBlocks
+				&& !block.isSolid()
+				&& !block.isLiquid()
+				&& block.getOpacity() != LodUtil.BLOCK_FULLY_OPAQUE;
+			
+			// merge snow into the block below it
+			if (snowLayerBlockStates.contains(block))
+			{
+				// sometimes a snow datapoint will be multiple blocks tall,
+				// in that case we just want to drop the top by 1
+				blockHeight -= 1;
+				if (blockHeight == 0)
+				{
+					// this snow block was entirely removed, just color the block below it
+					ignoreNonSolidBlock = true;
+				}
+			}
+			
+			if (ignoreNonSolidBlock)
 			{
 				if (colorBelowWithAvoidedBlocks)
 				{

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

@@ -74,7 +74,7 @@ public class LodDataBuilder
 		long pos = DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, sectionPosX, sectionPosZ);
 		
 		FullDataSourceV2 dataSource = FullDataSourceV2.createEmpty(pos);
-		dataSource.isEmpty = false;
+		dataSource.isEmpty = false; // this will be set to "true" if any blocks are found
 		// chunk updates always propagate up
 		dataSource.applyToParent = true;
 		
@@ -244,6 +244,15 @@ public class LodDataBuilder
 							blockLight = newBlockLight;
 							skyLight = newSkyLight;
 							lastY = y;
+							
+							
+							// mark the data source as non-empty if we find any non-air blocks
+							if (dataSource.isEmpty
+								&& newBlockState != null 
+								&& !newBlockState.isAir())
+							{
+								dataSource.isEmpty = false;
+							}
 						}
 					}
 					
@@ -261,7 +270,6 @@ public class LodDataBuilder
 			return null;
 		}
 		
-		LodUtil.assertTrue(!dataSource.isEmpty);
 		return dataSource;
 	}
 	
@@ -289,13 +297,29 @@ public class LodDataBuilder
 			for (int relBlockX = 0; relBlockX < LodUtil.CHUNK_WIDTH; relBlockX++)
 			{
 				List<DhApiTerrainDataPoint> columnDataPoints = apiChunk.getDataPoints(relBlockX, relBlockZ);
-				LodDataBuilder.correctDataColumnOrder(columnDataPoints);
+				
+				// mark the data source as non-empty if we find any non-air blocks
+				if (dataSource.isEmpty)
+				{
+					for (int i = 0; i < columnDataPoints.size(); i++)
+					{
+						DhApiTerrainDataPoint dataPoint = columnDataPoints.get(i);
+						if (dataPoint.blockStateWrapper != null
+							&& !dataPoint.blockStateWrapper.isAir())
+						{
+							dataSource.isEmpty = false;
+							break;
+						}
+					}
+				}
+				
+				LodDataBuilder.putListInTopDownOrder(columnDataPoints);
 				if (runAdditionalValidation)
 				{
 					validateOrThrowApiDataColumn(columnDataPoints);
 				}
 				
-				LongArrayList packedDataPoints = convertApiDataPointListToPackedLongArray(columnDataPoints, dataSource, apiChunk.bottomYBlockPos);
+				LongArrayList packedDataPoints = convertApiDataPointListToPackedLongArray(columnDataPoints, dataSource, apiChunk.bottomYBlockPos, runAdditionalValidation);
 				
 				// TODO add the ability for API users to define a different compression mode
 				//  or add a "unkown" compression mode
@@ -303,7 +327,6 @@ public class LodDataBuilder
 						packedDataPoints,
 						relBlockX + relSourceBlockX, relBlockZ + relSourceBlockZ,
 						EDhApiWorldGenerationStep.LIGHT, EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS);
-				dataSource.isEmpty = false;
 			}
 		}
 		return dataSource;
@@ -317,41 +340,97 @@ public class LodDataBuilder
 	
 	/** @see FullDataPointUtil */
 	public static LongArrayList convertApiDataPointListToPackedLongArray(
-			@Nullable List<DhApiTerrainDataPoint> columnDataPoints, FullDataSourceV2 dataSource,
-			int bottomYBlockPos) throws DataCorruptedException
+			@Nullable List<DhApiTerrainDataPoint> topDownColumnDataPoints, FullDataSourceV2 dataSource,
+			int bottomYBlockPos, boolean runAdditionalValidation) throws DataCorruptedException
 	{
-		// this null check does 2 nice things at the same time:
-		// if columnDataPoints is null,
-		// then packedDataPoints will be of length 0
-		// 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++)
+		if (topDownColumnDataPoints == null 
+			|| topDownColumnDataPoints.size() == 0)
 		{
-			DhApiTerrainDataPoint dataPoint = columnDataPoints.get(index);
+			return new LongArrayList(0);
+		}
+		
+		
+		
+		// array to store data
+		int size = topDownColumnDataPoints.size();
+		LongArrayList packedDataPoints = new LongArrayList(size);
+		packedDataPoints.clear();
+		
+		
+		if (runAdditionalValidation)
+		{
+			// check for missing data
+			int lastTopY = Integer.MAX_VALUE;
+			for (int i = 0; i < size; i++)
+			{
+				DhApiTerrainDataPoint apiDataPoint = topDownColumnDataPoints.get(i);
+				
+				if (lastTopY != apiDataPoint.topYBlockPos
+					// the first index won't have a lastTopY value
+					&& i != 0)
+				{
+					throw new DataCorruptedException("LOD data has a gap between ["+lastTopY+"] and ["+apiDataPoint.bottomYBlockPos+"]. Empty areas should be filled with air datapoints so light propagates correctly.");
+				}
+				lastTopY = apiDataPoint.bottomYBlockPos;
+			}
+		}
+		
+		
+		// go through data from top down
+		long lastDataPoint = FullDataPointUtil.EMPTY_DATA_POINT;
+		for (int i = 0; i < size; i++)
+		{
+			DhApiTerrainDataPoint apiDataPoint = topDownColumnDataPoints.get(i);
 			
-			int id = dataSource.mapping.addIfNotPresentAndGetId(
-					(IBiomeWrapper) (dataPoint.biomeWrapper),
-					(IBlockStateWrapper) (dataPoint.blockStateWrapper)
+			int thisId = dataSource.mapping.addIfNotPresentAndGetId(
+					(IBiomeWrapper) (apiDataPoint.biomeWrapper),
+					(IBlockStateWrapper) (apiDataPoint.blockStateWrapper)
 			);
+			int thisHeight = (apiDataPoint.topYBlockPos - apiDataPoint.bottomYBlockPos);
 			
-			packedDataPoints.set(index, FullDataPointUtil.encode(
-					id,
-					dataPoint.topYBlockPos - dataPoint.bottomYBlockPos,
-					dataPoint.bottomYBlockPos - bottomYBlockPos,
-					(byte) (dataPoint.blockLightLevel),
-					(byte) (dataPoint.skyLightLevel)
-			));
+			int lastId = FullDataPointUtil.getId(lastDataPoint);
+			byte lastBlockLight = (byte)FullDataPointUtil.getBlockLight(lastDataPoint);
+			byte lastSkyLight = (byte)FullDataPointUtil.getSkyLight(lastDataPoint);
+			
+			
+			// if the ID and light are the same, merge the height
+			if (thisId == lastId
+				&& apiDataPoint.blockLightLevel == lastBlockLight
+				&& apiDataPoint.skyLightLevel == lastSkyLight
+				// the first index should always be added to the list
+				&& i != 0 )
+			{
+				// add adjacent height
+				int lastHeight = FullDataPointUtil.getHeight(lastDataPoint);
+				int newHeight = (lastHeight + thisHeight);
+				lastDataPoint = FullDataPointUtil.setHeight(lastDataPoint, newHeight);
+				
+				// subtract bottom Y
+				int lastBottomY = FullDataPointUtil.getBottomY(lastDataPoint);
+				int newBottomY = lastBottomY - thisHeight;
+				lastDataPoint = FullDataPointUtil.setBottomY(lastDataPoint, newBottomY);
+				 
+				packedDataPoints.set(packedDataPoints.size()-1, lastDataPoint);
+			}
+			else
+			{
+				// data changed, create a new datapoint
+				long dataPoint = FullDataPointUtil.encode(
+					thisId,
+					thisHeight,
+					apiDataPoint.bottomYBlockPos - bottomYBlockPos,
+					(byte) (apiDataPoint.blockLightLevel),
+					(byte) (apiDataPoint.skyLightLevel)
+				);
+				lastDataPoint = dataPoint;
+				packedDataPoints.add(dataPoint);
+			}
 		}
 		
 		return packedDataPoints;
 	}
 	
-	/** also corrects the order if it's backwards */
-	public static void correctDataColumnOrder(List<DhApiTerrainDataPoint> dataPoints)
+	public static void putListInTopDownOrder(List<DhApiTerrainDataPoint> dataPoints)
 	{
 		// order doesn't need to be checked if there is 0 or 1 items
 		if (dataPoints.size() > 1)

core/src/main/java/com/seibel/distanthorizons/core/enums/MinecraftTextFormat.java

@@ -0,0 +1,35 @@
+package com.seibel.distanthorizons.core.enums;
+
+/**
+ * might be deprecated in the future? in that case we'll probably want a wrapper 
+ * function to handle colors for new MC versions
+ * <br><br>
+ * source: https://minecraft.wiki/w/Formatting_codes
+ */
+public class MinecraftTextFormat
+{
+	public static final String BLACK = "\u00A70";
+	public static final String DARK_BLUE = "\u00A71";
+	public static final String DARK_GREEN = "\u00A72";
+	public static final String DARK_AQUA = "\u00A73";
+	public static final String DARK_RED = "\u00A74";
+	public static final String DARK_PURPLE = "\u00A75";
+	public static final String ORANGE = "\u00A76";
+	public static final String GRAY = "\u00A77";
+	public static final String DARK_GRAY = "\u00A78";
+	public static final String BLUE = "\u00A79";
+	public static final String GREEN = "\u00A7a";
+	public static final String AQUA = "\u00A7b";
+	public static final String RED = "\u00A7c";
+	public static final String LIGHT_PURPLE = "\u00A7d";
+	public static final String YELLOW = "\u00A7e";
+	public static final String WHITE = "\u00A7f";
+	
+	public static final String OBFUSCATED = "\u00A7k";
+	public static final String BOLD = "\u00A7l";
+	public static final String STRIKETHROUGH = "\u00A7m";
+	public static final String UNDERLINE = "\u00A7n";
+	public static final String ITALIC = "\u00A7o";
+	public static final String CLEAR_FORMATTING = "\u00A7r";
+	
+}

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

@@ -96,7 +96,12 @@ public class DelayedFullDataSourceSaveCache implements AutoCloseable
 				// no data currently in the memory cache for this position
 				memoryDataSource = FullDataSourceV2.createEmpty(inputPos);
 				pair = new DataSourceSavedTimePair(memoryDataSource);
-				this.dataSourceByPosition.put(inputPos, pair);
+				DataSourceSavedTimePair oldPair = this.dataSourceByPosition.put(inputPos, pair);
+				if (oldPair != null)
+				{
+					// shouldn't happen, but just in case
+					this.handleDataSourceRemoval(oldPair.dataSource);
+				}
 			}
 			else
 			{
@@ -104,7 +109,7 @@ public class DelayedFullDataSourceSaveCache implements AutoCloseable
 			}
 			
 			// write the new data into memory
-			memoryDataSource.updateFromChunk(inputDataSource);
+			memoryDataSource.updateFromDataSource(inputDataSource);
 			// keep track of when the last time we saved something was
 			pair.updateLastWrittenTimestamp();
 		}

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

@@ -28,8 +28,8 @@ import com.seibel.distanthorizons.core.file.fullDatafile.V2.FullDataUpdatePropag
 import com.seibel.distanthorizons.core.file.structure.ISaveStructure;
 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;
+import com.seibel.distanthorizons.core.generation.tasks.DataSourceRetrievalResult;
+import com.seibel.distanthorizons.core.generation.tasks.ERetrievalResultState;
 import com.seibel.distanthorizons.core.level.IDhLevel;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
@@ -38,6 +38,7 @@ import com.seibel.distanthorizons.core.pooling.PhantomArrayListPool;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
+import com.seibel.distanthorizons.core.util.ExceptionUtil;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.threading.PriorityTaskPicker;
 import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
@@ -47,6 +48,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -66,7 +69,9 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	 * TODO this should be dynamically allocated based on CPU load
 	 *  and abilities.
 	 */
-	public static final int MAX_WORLD_GEN_REQUESTS_PER_THREAD = 20; 
+	public static final int MAX_WORLD_GEN_REQUESTS_PER_THREAD = 20;
+	
+	public static final PhantomArrayListPool ARRAY_LIST_POOL = new PhantomArrayListPool("Generated Provider");
 	
 	
 	private final AtomicReference<IFullDataSourceRetrievalQueue> worldGenQueueRef = new AtomicReference<>(null);
@@ -80,17 +85,10 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	// constructor //
 	//=============//
 	
-	public GeneratedFullDataSourceProvider(IDhLevel level, ISaveStructure saveStructure) { super(level, saveStructure); }
-	public GeneratedFullDataSourceProvider(IDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride) 
-	{
-		super(level, saveStructure, saveDirOverride);
-		
-		this.addDataSourceUpdateListener((@NotNull FullDataSourceV2 updatedData) ->
-		{
-			this.onWorldGenTaskComplete(WorldGenResult.CreateSuccess(updatedData.getPos()), null);
-		});
-		
-	}
+	public GeneratedFullDataSourceProvider(IDhLevel level, ISaveStructure saveStructure) throws SQLException, IOException 
+	{ this(level, saveStructure, null); }
+	public GeneratedFullDataSourceProvider(IDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride) throws SQLException, IOException
+	{ super(level, saveStructure, saveDirOverride); }
 	
 	
 	
@@ -119,32 +117,43 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	// events //
 	//========//
 	
-	private void onWorldGenTaskComplete(WorldGenResult genTaskResult, Throwable exception)
+	private void onWorldGenTaskComplete(@NotNull Long genPos, @Nullable DataSourceRetrievalResult genTaskResult, @Nullable Throwable exception)
 	{
-		if (exception != null)
+		try
 		{
-			// don't log shutdown exceptions
-			if (!(exception instanceof CancellationException || exception.getCause() instanceof CancellationException))
+			if (exception != null)
 			{
-				LOGGER.error("Uncaught Gen Task Exception at ["+genTaskResult.pos+"], error: ["+exception.getMessage()+"].", exception);
+				// don't log shutdown exceptions
+				if (!ExceptionUtil.isInterruptOrReject(exception))
+				{
+					LOGGER.error("Uncaught Gen Task Exception at [" + genPos + "], error: [" + exception.getMessage() + "].", exception);
+				}
+				return;
+			}
+			
+			Objects.requireNonNull(genTaskResult);
+			if (genTaskResult.state == ERetrievalResultState.SUCCESS)
+			{
+				LodUtil.assertTrue(genTaskResult.dataSource != null, "Successful retrieval object should have a datasource.");
+				
+				this.dataUpdater.updateDataSource(genTaskResult.dataSource);
+				this.fireOnGenPosSuccessListeners(genTaskResult.pos);
+				genTaskResult.dataSource.close();
+			}
+			else if (genTaskResult.state == ERetrievalResultState.REQUIRES_SPLITTING)
+			{
+				// task was split
+				LodUtil.assertTrue(genTaskResult.dataSource == null, "Split retrieval object should not have a datasource.");
+			}
+			else
+			{
+				// shouldn't happen, but just in case
+				LOGGER.warn("Unexpected gen Task state at: [" + DhSectionPos.toString(genTaskResult.pos) + "], state: [" + genTaskResult.state + "], datasource: NULL, exception: NULL.");
 			}
 		}
-		else if (genTaskResult.success)
+		catch (Exception e)
 		{
-			this.fireOnGenPosSuccessListeners(genTaskResult.pos);
-			return;
-		}
-		else
-		{
-			// generation didn't complete
-			LOGGER.debug("Gen Task Failed at " + genTaskResult.pos);
-		}
-		
-		
-		// if the generation task was split up into smaller positions, add the on-complete event to them
-		for (CompletableFuture<WorldGenResult> siblingFuture : genTaskResult.childFutures)
-		{
-			siblingFuture.whenComplete((siblingGenTaskResult, siblingEx) -> this.onWorldGenTaskComplete(siblingGenTaskResult, siblingEx));
+			LOGGER.error("Unexpected issue during onWorldGenTaskComplete, error: ["+e.getMessage()+"].", e);
 		}
 	}
 	
@@ -204,10 +213,10 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	}
 	
 	@Override
-	public boolean canQueueRetrieval() { return this.canQueueRetrieval(false); }
-	public boolean canQueueRetrieval(boolean pruneWaitingTasksAboveLimit)
+	public boolean canQueueRetrievalNow() { return this.canQueueRetrievalNow(false); }
+	public boolean canQueueRetrievalNow(boolean pruneWaitingTasksAboveLimit)
 	{
-		if (!super.canQueueRetrieval())
+		if (!super.canQueueRetrievalNow())
 		{
 			return false;
 		}
@@ -267,12 +276,16 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 		
 		
 		int availableTaskSlots = maxWorldGenQueueCount - worldGenQueue.getWaitingTaskCount();
-		if (availableTaskSlots <= 0)
+		if (availableTaskSlots == 0)
+		{
+			return false;
+		}
+		else if (availableTaskSlots < 0)
 		{
 			if (pruneWaitingTasksAboveLimit)
 			{
-				AtomicInteger tasksToCancel = new AtomicInteger(-availableTaskSlots + 1);
-				worldGenQueue.removeRetrievalRequestIf(x -> tasksToCancel.getAndDecrement() > 0);
+				AtomicInteger tasksToCancel = new AtomicInteger(availableTaskSlots * -1);
+				worldGenQueue.removeRetrievalRequestIf(taskPos -> tasksToCancel.getAndDecrement() > 0);
 			}
 			else
 			{
@@ -285,7 +298,7 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	}
 	
 	@Override
-	public CompletableFuture<WorldGenResult> queuePositionForRetrieval(Long genPos)
+	public CompletableFuture<DataSourceRetrievalResult> queuePositionForRetrieval(Long genPos)
 	{
 		IFullDataSourceRetrievalQueue worldGenQueue = this.worldGenQueueRef.get();
 		if (worldGenQueue == null)
@@ -293,13 +306,8 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 			return null;
 		}
 		
-		WorldGenTaskTracker genTaskTracker = new WorldGenTaskTracker(genPos);
-		CompletableFuture<WorldGenResult> worldGenFuture = worldGenQueue.submitRetrievalTask(genPos, (byte) (DhSectionPos.getDetailLevel(genPos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL), genTaskTracker);
-		worldGenFuture.whenComplete((genTaskResult, ex) ->
-		{
-			//LOGGER.info("gen task complete ["+DhSectionPos.toString(genPos)+"]");
-			//this.onWorldGenTaskComplete(genTaskResult, ex);
-		});
+		CompletableFuture<DataSourceRetrievalResult> worldGenFuture = worldGenQueue.submitRetrievalTask(genPos, (byte) (DhSectionPos.getDetailLevel(genPos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL));
+		worldGenFuture.whenComplete((r, e) -> this.onWorldGenTaskComplete(genPos, r, e));
 		
 		return worldGenFuture;
 	}
@@ -318,22 +326,20 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	public void clearRetrievalQueue() { this.worldGenQueueRef.set(null); }
 	
 	
-	public boolean isFullyGenerated(ByteArrayList columnGenerationSteps)
+	public boolean generationStepsAreFullyGenerated(ByteArrayList columnGenerationSteps)
 	{
 		return IntStream.range(0, columnGenerationSteps.size())
-				.noneMatch(i ->
-				{
-					byte value = columnGenerationSteps.getByte(i);
-					return value == EDhApiWorldGenerationStep.EMPTY.value
-							|| value == EDhApiWorldGenerationStep.DOWN_SAMPLED.value;
-				});
+			.noneMatch((int intValue) ->
+			{
+				byte value = columnGenerationSteps.getByte(intValue);
+				return value == EDhApiWorldGenerationStep.EMPTY.value
+					|| value == EDhApiWorldGenerationStep.DOWN_SAMPLED.value;
+			});
 	}
 	
-	public static final PhantomArrayListPool ARRAY_LIST_POOL = new PhantomArrayListPool("Generated Provider");
-	
 	
 	@Override
-	public LongArrayList getPositionsToRetrieve(Long pos)
+	public LongArrayList getPositionsToRetrieve(long pos)
 	{
 		IFullDataSourceRetrievalQueue worldGenQueue = this.worldGenQueueRef.get();
 		if (worldGenQueue == null)
@@ -349,7 +355,7 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 			{
 				ByteArrayList columnGenStepArray = checkout.getByteArray(0, FullDataSourceV2.WIDTH*FullDataSourceV2.WIDTH);
 				this.repo.getColumnGenerationStepForPos(pos, columnGenStepArray);
-				if (!columnGenStepArray.isEmpty())
+				if (columnGenStepArray.size() != 0)
 				{
 					boolean positionFullyGenerated = true;
 					
@@ -375,12 +381,11 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 		
 		
 		// this section is missing one or more columns, queue the missing ones for generation.
-		// TODO speed up this logic by only checking ungenerated columns
 		LongArrayList generationList = new LongArrayList();
 		
 		byte lowestGeneratorDetailLevel = (byte) Math.min(
-				worldGenQueue.lowestDataDetail()  + DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL,
-				DhSectionPos.getDetailLevel(pos));
+			worldGenQueue.lowestDataDetail() + DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL,
+			DhSectionPos.getDetailLevel(pos));
 		
 		DhSectionPos.forEachChildAtDetailLevel(pos, lowestGeneratorDetailLevel, (genPos) ->
 		{
@@ -468,48 +473,13 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	// helper classes //
 	//================//
 	
-	// TODO may not be needed
-	private class WorldGenTaskTracker implements IWorldGenTaskTracker
-	{
-		/** just used when debugging/troubleshooting */
-		private final long pos;
-		
-		public WorldGenTaskTracker(long pos) { this.pos = pos; }
-		
-		
-		@Override
-		public Consumer<FullDataSourceV2> getDataSourceConsumer()
-		{
-			return (dataSource) ->
-			{
-				GeneratedFullDataSourceProvider.this.delayedFullDataSourceSaveCache.writeDataSourceToMemoryAndQueueSave(dataSource);
-			};
-		}
-		
-		@Override
-		public CompletableFuture<Boolean> shouldGenerateSplitChild(long pos)
-		{
-			return GeneratedFullDataSourceProvider.this.getAsync(pos).thenApply(fullDataSource ->
-			{
-				//noinspection TryFinallyCanBeTryWithResources
-				try
-				{
-					return !GeneratedFullDataSourceProvider.this.isFullyGenerated(fullDataSource.columnGenerationSteps);
-				}
-				finally
-				{
-					fullDataSource.close();
-				}
-			});
-		}
-		
-	}
 	private CompletableFuture<Void> onDataSourceSaveAsync(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, LodUtil.MAX_MC_LIGHT);
+		int skyLight = this.level.getLevelWrapper().hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT;
+		DhLightingEngine.INSTANCE.bakeDataSourceSkyLight(fullDataSource, skyLight);
 		
 		return this.updateDataSourceAsync(fullDataSource);
 	}
@@ -521,7 +491,6 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	{
 		boolean shouldDoWorldGen();
 		
-		@Nullable
 		DhBlockPos2D getTargetPosForGeneration();
 		
 		/** Fired whenever a section has completed generating */

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

@@ -23,21 +23,25 @@ import com.google.common.cache.CacheBuilder;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.file.structure.ISaveStructure;
 import com.seibel.distanthorizons.core.generation.RemoteWorldRetrievalQueue;
+import com.seibel.distanthorizons.core.generation.tasks.DataSourceRetrievalResult;
 import com.seibel.distanthorizons.core.level.IDhLevel;
-import com.seibel.distanthorizons.core.level.WorldGenModule;
+import com.seibel.distanthorizons.core.level.LodRequestModule;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.generation.tasks.ERetrievalResultState;
 import com.seibel.distanthorizons.core.multiplayer.client.SyncOnLoadRequestQueue;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
 import java.util.Collections;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 /**
  * Only handles {@link SyncOnLoadRequestQueue} requests (IE updating existing LODs based on a timestamp).
- * Missing data is handled by {@link WorldGenModule} and {@link RemoteWorldRetrievalQueue}.
+ * Missing data is handled by {@link LodRequestModule} and {@link RemoteWorldRetrievalQueue}.
  */
 public class RemoteFullDataSourceProvider extends GeneratedFullDataSourceProvider
 {
@@ -58,7 +62,8 @@ public class RemoteFullDataSourceProvider extends GeneratedFullDataSourceProvide
 	
 	public RemoteFullDataSourceProvider(
 			IDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride, 
-			@Nullable SyncOnLoadRequestQueue syncOnLoadRequestQueue)
+			@Nullable SyncOnLoadRequestQueue syncOnLoadRequestQueue
+		) throws SQLException, IOException
 	{
 		super(level, saveStructure, saveDirOverride);
 		this.syncOnLoadRequestQueue = syncOnLoadRequestQueue;
@@ -71,7 +76,7 @@ public class RemoteFullDataSourceProvider extends GeneratedFullDataSourceProvide
 	//==================//
 	
 	@Override
-	public boolean canQueueRetrieval() { return this.canQueueRetrieval(true); }
+	public boolean canQueueRetrievalNow() { return this.canQueueRetrievalNow(true); }
 	
 	@Override
 	@Nullable
@@ -99,10 +104,20 @@ public class RemoteFullDataSourceProvider extends GeneratedFullDataSourceProvide
 		Long timestamp = this.getTimestampForPos(pos);
 		if (timestamp != null)
 		{
-			this.syncOnLoadRequestQueue.submitRequest(pos, timestamp, fullDataSource ->
-			{
-				this.updateDataSourceAsync(fullDataSource).whenComplete((result, throwable) -> fullDataSource.close());
-			});
+			this.syncOnLoadRequestQueue.submitRequest(pos, timestamp)
+				.thenAccept((DataSourceRetrievalResult result) ->
+				{
+					if (result.state == ERetrievalResultState.SUCCESS
+						&& result.dataSource != null)
+					{
+						this.updateDataSourceAsync(result.dataSource)
+							.handle((voidObj, throwable) ->
+							{
+								result.dataSource.close();
+								return null;
+							});
+					}
+				});
 		}
 		
 		return super.get(pos);

core/src/main/java/com/seibel/distanthorizons/core/file/fullDatafile/V1/FullDataSourceProviderV1.java

@@ -43,7 +43,7 @@ public class FullDataSourceProviderV1<TDhLevel extends IDhLevel>
 	// constructor //
 	//=============//
 	
-	public FullDataSourceProviderV1(TDhLevel level, File saveDir)
+	public FullDataSourceProviderV1(TDhLevel level, File saveDir) throws SQLException, IOException
 	{
 		this.level = level;
 		this.saveDir = saveDir;
@@ -52,7 +52,7 @@ public class FullDataSourceProviderV1<TDhLevel extends IDhLevel>
 			LOGGER.warn("Unable to create full data folder, file saving may fail.");
 		}
 		
-		this.repo = this.createRepo();
+		this.repo = new FullDataSourceV1Repo(AbstractDhRepo.DEFAULT_DATABASE_TYPE, new File(this.saveDir.getPath() + File.separator + ISaveStructure.DATABASE_NAME));
 	}
 	
 	
@@ -61,21 +61,6 @@ public class FullDataSourceProviderV1<TDhLevel extends IDhLevel>
 	// abstract methods //
 	//==================//
 	
-	/** When this is called the parent folders should be created */
-	protected FullDataSourceV1Repo createRepo()
-	{
-		try
-		{
-			return new FullDataSourceV1Repo(AbstractDhRepo.DEFAULT_DATABASE_TYPE, new File(this.saveDir.getPath() + File.separator + ISaveStructure.DATABASE_NAME));
-		}
-		catch (SQLException e)
-		{
-			// should only happen if there is an issue with the database (it's locked or can't be created if missing) 
-			// or the database update failed
-			throw new RuntimeException(e);
-		}
-	}
-	
 	protected FullDataSourceV1 createDataSourceFromDto(FullDataSourceV1DTO dto) throws InterruptedException, IOException, DataCorruptedException
 	{
 		FullDataSourceV1 dataSource = FullDataSourceV1.createEmpty(dto.pos);

core/src/main/java/com/seibel/distanthorizons/core/file/fullDatafile/V2/DataMigratorV1.java

@@ -14,6 +14,8 @@ import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
 import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
 
 import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
 import java.text.NumberFormat;
 import java.util.ArrayList;
 import java.util.List;
@@ -62,7 +64,8 @@ public class DataMigratorV1 implements IDebugRenderable, AutoCloseable
 	
 	public DataMigratorV1(
 			FullDataUpdaterV2 dataUpdater,
-			IDhLevel level, String levelId, File saveDir)
+			IDhLevel level, String levelId, File saveDir
+		) throws SQLException, IOException
 	{
 		this.dataUpdater = dataUpdater;
 		this.saveDir = saveDir;

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

@@ -25,7 +25,7 @@ import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSour
 import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.file.fullDatafile.IDataSourceUpdateListenerFunc;
 import com.seibel.distanthorizons.core.file.structure.ISaveStructure;
-import com.seibel.distanthorizons.core.generation.tasks.WorldGenResult;
+import com.seibel.distanthorizons.core.generation.tasks.DataSourceRetrievalResult;
 import com.seibel.distanthorizons.core.level.IDhLevel;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
@@ -48,7 +48,6 @@ import java.sql.SQLException;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Handles reading/writing {@link FullDataSourceV2} 
@@ -86,9 +85,9 @@ public class FullDataSourceProviderV2 implements IDebugRenderable, AutoCloseable
 	protected final String levelId;
 	
 	
-	private final FullDataUpdaterV2 dataUpdater;
-	private final FullDataUpdatePropagatorV2 updatePropagator;
-	private final DataMigratorV1 dataMigratorV1;
+	protected final FullDataUpdaterV2 dataUpdater;
+	protected final FullDataUpdatePropagatorV2 updatePropagator;
+	protected final DataMigratorV1 dataMigratorV1;
 	
 	
 	
@@ -96,11 +95,11 @@ public class FullDataSourceProviderV2 implements IDebugRenderable, AutoCloseable
 	// constructor //
 	//=============//
 	
-	public FullDataSourceProviderV2(IDhLevel level, ISaveStructure saveStructure) { this(level, saveStructure, null); }
-	public FullDataSourceProviderV2(IDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride) 
+	public FullDataSourceProviderV2(IDhLevel level, ISaveStructure saveStructure) throws SQLException, IOException { this(level, saveStructure, null); }
+	public FullDataSourceProviderV2(IDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride) throws SQLException, IOException
 	{
 		this.saveDir = (saveDirOverride == null) ? saveStructure.getSaveFolder(level.getLevelWrapper()) : saveDirOverride;
-		this.repo = this.createRepo();
+		this.repo = new FullDataSourceV2Repo(AbstractDhRepo.DEFAULT_DATABASE_TYPE, new File(this.saveDir.getPath() + File.separator + ISaveStructure.DATABASE_NAME));
 		this.level = level;
 		
 		this.levelId = this.level.getLevelWrapper().getDhIdentifier();
@@ -112,19 +111,6 @@ public class FullDataSourceProviderV2 implements IDebugRenderable, AutoCloseable
 		DebugRenderer.register(this, Config.Client.Advanced.Debugging.DebugWireframe.showFullDataUpdateStatus);
 		
 	}
-	private FullDataSourceV2Repo createRepo()
-	{
-		try
-		{
-			return new FullDataSourceV2Repo(AbstractDhRepo.DEFAULT_DATABASE_TYPE, new File(this.saveDir.getPath() + File.separator + ISaveStructure.DATABASE_NAME));
-		}
-		catch (SQLException e)
-		{
-			// should only happen if there is an issue with the database (it's locked or the folder path is missing) 
-			// or the database update failed
-			throw new RuntimeException(e);
-		}
-	}
 	
 	
 	
@@ -134,14 +120,14 @@ public class FullDataSourceProviderV2 implements IDebugRenderable, AutoCloseable
 	
 	public void addDataSourceUpdateListener(IDataSourceUpdateListenerFunc<FullDataSourceV2> listener)
 	{
-		synchronized (this.dataUpdater)
+		synchronized (this.dataUpdater.dateSourceUpdateListeners)
 		{
 			this.dataUpdater.dateSourceUpdateListeners.add(listener);
 		}
 	}
 	public void removeDataSourceUpdateListener(IDataSourceUpdateListenerFunc<FullDataSourceV2> listener)
 	{
-		synchronized (this.dataUpdater)
+		synchronized (this.dataUpdater.dateSourceUpdateListeners)
 		{
 			this.dataUpdater.dateSourceUpdateListeners.add(listener);
 		}
@@ -214,9 +200,10 @@ public class FullDataSourceProviderV2 implements IDebugRenderable, AutoCloseable
 				return FullDataSourceV2.createEmpty(pos);
 			}
 			
+			FullDataSourceV2 dataSource = null;
 			try
 			{
-				FullDataSourceV2 dataSource = this.createDataSourceFromDto(dto);
+				dataSource = this.createDataSourceFromDto(dto);
 				
 				// automatically create and save adjacent data if missing
 				if (dto.dataFormatVersion == FullDataSourceV2DTO.DATA_FORMAT.V1_NO_ADJACENT_DATA)
@@ -235,11 +222,45 @@ public class FullDataSourceProviderV2 implements IDebugRenderable, AutoCloseable
 				this.tryLogCorruptedDataError(DhSectionPos.toString(pos), e);
 				this.repo.deleteWithKey(pos);
 			}
+			catch (Exception e)
+			{
+				if (dataSource != null)
+				{
+					dataSource.close();
+				}
+				
+				throw e;
+			}
 		}
 		catch (InterruptedException ignore) { }
 		catch (IOException e)
 		{
-			LOGGER.warn("File read Error for pos ["+DhSectionPos.toString(pos)+"], error: "+e.getMessage(), e);
+			String message = e.getMessage();
+			if (CORRUPT_DATA_ERRORS_LOGGED.add(message))
+			{
+				LOGGER.warn("File read Error for pos [" + DhSectionPos.toString(pos) + "], this error message will only be logged once, error: [" + message + "].", e);
+			}
+		}
+		catch (IllegalStateException e)
+		{	
+			String message = e.getMessage();
+			if (CORRUPT_DATA_ERRORS_LOGGED.add(message))
+			{
+				LOGGER.warn("Incorrectly formatted data for: [" + DhSectionPos.toString(pos) + "], this error message will only be logged once, error: [" + message + "].", e);
+			}
+		}
+		catch (Exception e)
+		{
+			String message = e.getMessage();
+			if (message == null)
+			{
+				message = "NULL";
+			}
+			
+			if (CORRUPT_DATA_ERRORS_LOGGED.add(message))
+			{
+				LOGGER.warn("Unexpected error getting: [" + DhSectionPos.toString(pos) + "], this error message will only be logged once, error: [" + message + "].", e);
+			}
 		}
 		
 		// an error occurred
@@ -353,7 +374,7 @@ public class FullDataSourceProviderV2 implements IDebugRenderable, AutoCloseable
 	 * to the beginning of your override.
 	 * Otherwise, parent retrieval limits will be ignored.
 	 */
-	public boolean canQueueRetrieval()
+	public boolean canQueueRetrievalNow()
 	{
 		// Retrieval shouldn't happen while an unknown number of
 		// legacy data sources are present.
@@ -362,15 +383,15 @@ public class FullDataSourceProviderV2 implements IDebugRenderable, AutoCloseable
 	}
 	
 	/** 
-	 * @return null if this provider can't generate any positions and
+	 * @return null if this provider can't generate any positions or
 	 * an empty array if all positions were generated 
 	 */
 	@Nullable
-	public LongArrayList getPositionsToRetrieve(Long pos) { return null; }
+	public LongArrayList getPositionsToRetrieve(long pos) { return null; }
 		
-	/** @return true if the position was queued, false if not */
+	/** @return null if the position couldn't be queued */
 	@Nullable
-	public CompletableFuture<WorldGenResult> queuePositionForRetrieval(Long genPos) { return null; }
+	public CompletableFuture<DataSourceRetrievalResult> queuePositionForRetrieval(Long genPos) { return null; }
 	
 	/** does nothing if the given position isn't present in the queue */
 	public void removeRetrievalRequestIf(DhSectionPos.ICancelablePrimitiveLongConsumer removeIf) { }

core/src/main/java/com/seibel/distanthorizons/core/file/fullDatafile/V2/FullDataUpdatePropagatorV2.java

@@ -82,6 +82,7 @@ public class FullDataUpdatePropagatorV2 implements IDebugRenderable, AutoCloseab
 	}
 	
 	
+	
 	//================//
 	// parent updates //
 	//================//
@@ -203,7 +204,7 @@ public class FullDataUpdatePropagatorV2 implements IDebugRenderable, AutoCloseab
 													// can return null when the file handler is being shut down
 													if (childDataSource != null)
 													{
-														parentDataSource.updateFromChunk(childDataSource);
+														parentDataSource.updateFromDataSource(childDataSource);
 													}
 												}
 											}
@@ -213,6 +214,8 @@ public class FullDataUpdatePropagatorV2 implements IDebugRenderable, AutoCloseab
 											}
 											finally
 											{
+												this.provider.repo.setApplyToParent(childPos, false);
+												
 												childReadLock.unlock();
 												this.dataUpdater.lockedPosSet.remove(childPos);
 											}
@@ -224,11 +227,7 @@ public class FullDataUpdatePropagatorV2 implements IDebugRenderable, AutoCloseab
 											parentDataSource.applyToParent = true;
 										}
 										
-										this.dataUpdater.updateDataSource(parentDataSource, false);
-										for (Long childPos : updatePosByParentPos.get(parentUpdatePos))
-										{
-											this.provider.repo.setApplyToParent(childPos, false);
-										}
+										this.dataUpdater.updateDataSource(parentDataSource);
 									}
 								}
 							}
@@ -321,7 +320,7 @@ public class FullDataUpdatePropagatorV2 implements IDebugRenderable, AutoCloseab
 													// will return null if the file handler is shutting down
 													if (childDataSource != null)
 													{
-														childDataSource.updateFromChunk(parentDataSource);
+														childDataSource.updateFromDataSource(parentDataSource);
 														
 														// don't propagate child updates past the bottom of the tree
 														if (DhSectionPos.getDetailLevel(childPos) != DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL)
@@ -329,7 +328,7 @@ public class FullDataUpdatePropagatorV2 implements IDebugRenderable, AutoCloseab
 															childDataSource.applyToChildren = true;
 														}
 														
-														this.dataUpdater.updateDataSource(childDataSource, false);
+														this.dataUpdater.updateDataSource(childDataSource);
 													}
 												}
 											}
@@ -339,12 +338,12 @@ public class FullDataUpdatePropagatorV2 implements IDebugRenderable, AutoCloseab
 											}
 											finally
 											{
+												this.provider.repo.setApplyToChild(parentUpdatePos, false);
+												
 												childWriteLock.unlock();
 												this.dataUpdater.lockedPosSet.remove(childPos);
 											}
 										}
-										
-										this.provider.repo.setApplyToChild(parentUpdatePos, false);
 									}
 								}
 							}

core/src/main/java/com/seibel/distanthorizons/core/file/fullDatafile/V2/FullDataUpdaterV2.java

@@ -63,7 +63,7 @@ public class FullDataUpdaterV2 implements IDebugRenderable, AutoCloseable
 	
 	/**
 	 * Can be used if you don't want to lock the current thread
-	 * Otherwise the sync version {@link FullDataUpdaterV2#updateDataSource(FullDataSourceV2, boolean)} may be a better choice.
+	 * Otherwise the sync version {@link FullDataUpdaterV2#updateDataSource(FullDataSourceV2)} may be a better choice.
 	 */
 	public CompletableFuture<Void> updateDataSourceAsync(@NotNull FullDataSourceV2 inputDataSource)
 	{
@@ -86,7 +86,7 @@ public class FullDataUpdaterV2 implements IDebugRenderable, AutoCloseable
 			{
 				try
 				{
-					this.updateDataSource(inputDataSource, true);
+					this.updateDataSource(inputDataSource);
 				}
 				catch (Exception e)
 				{
@@ -107,7 +107,7 @@ public class FullDataUpdaterV2 implements IDebugRenderable, AutoCloseable
 	}
 	
 	/** After this method returns the inputData will be written to file. */
-	public void updateDataSource(@NotNull FullDataSourceV2 inputData, boolean lockOnUpdatePos)
+	public void updateDataSource(@NotNull FullDataSourceV2 inputData)
 	{
 		if (this.isShutdownRef.get())
 		{
@@ -117,27 +117,22 @@ public class FullDataUpdaterV2 implements IDebugRenderable, AutoCloseable
 		
 		long updatePos = inputData.getPos();
 		
-		boolean methodLocked = false;
 		// a lock is necessary to prevent two threads from writing to the same position at once,
 		// if that happens only the second update will apply and the LOD will end up with hole(s)
 		ReentrantLock updateLock = this.updateLockProvider.getLock(updatePos);
 		
 		try
 		{
-			if (lockOnUpdatePos)
-			{
-				methodLocked = true;
-				updateLock.lock();
-				this.lockedPosSet.add(updatePos);
-			}
+			updateLock.lock();
+			this.lockedPosSet.add(updatePos);
 			
 			
 			// get or create the data source
 			try (FullDataSourceV2 recipientDataSource = this.provider.get(updatePos))
 			{
-				if (recipientDataSource != null)
+				if (recipientDataSource != null) // will be null if the repo was shut down
 				{
-					boolean dataModified = recipientDataSource.updateFromChunk(inputData);
+					boolean dataModified = recipientDataSource.updateFromDataSource(inputData);
 					if (dataModified)
 					{
 						// save the updated data to the database
@@ -150,11 +145,14 @@ public class FullDataUpdaterV2 implements IDebugRenderable, AutoCloseable
 						}
 						
 						
-						for (IDataSourceUpdateListenerFunc<FullDataSourceV2> listener : this.dateSourceUpdateListeners)
+						synchronized (this.dateSourceUpdateListeners)
 						{
-							if (listener != null)
+							for (IDataSourceUpdateListenerFunc<FullDataSourceV2> listener : this.dateSourceUpdateListeners)
 							{
-								listener.OnDataSourceUpdated(recipientDataSource);
+								if (listener != null)
+								{
+									listener.OnDataSourceUpdated(recipientDataSource);
+								}
 							}
 						}
 					}
@@ -167,11 +165,8 @@ public class FullDataUpdaterV2 implements IDebugRenderable, AutoCloseable
 		}
 		finally
 		{
-			if (methodLocked)
-			{
-				updateLock.unlock();
-				this.lockedPosSet.remove(updatePos);
-			}
+			updateLock.unlock();
+			this.lockedPosSet.remove(updatePos);
 		}
 	}
 	

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

@@ -24,12 +24,13 @@ import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiW
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.level.IDhLevel;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.util.ExceptionUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.worldGeneration.IBatchGeneratorEnvironmentWrapper;
 import com.seibel.distanthorizons.coreapi.interfaces.dependencyInjection.IOverrideInjector;
 import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiDistantGeneratorMode;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
-import com.seibel.distanthorizons.core.wrapperInterfaces.worldGeneration.AbstractBatchGenerationEnvironmentWrapper;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.util.concurrent.CompletableFuture;
@@ -42,10 +43,10 @@ import java.util.function.Consumer;
  */
 public class BatchGenerator implements IDhApiWorldGenerator
 {
-	private static final IWrapperFactory FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
+	private static final IWrapperFactory WRAPPER_FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
 	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
-	public AbstractBatchGenerationEnvironmentWrapper generationEnvironment;
+	public IBatchGeneratorEnvironmentWrapper generationEnvironment;
 	public IDhLevel targetDhLevel;
 	
 	
@@ -57,7 +58,7 @@ public class BatchGenerator implements IDhApiWorldGenerator
 	public BatchGenerator(IDhLevel targetDhLevel)
 	{
 		this.targetDhLevel = targetDhLevel;
-		this.generationEnvironment = FACTORY.createBatchGenerator(targetDhLevel);
+		this.generationEnvironment = WRAPPER_FACTORY.createBatchGenerator(targetDhLevel);
 		LOGGER.info("Batch Chunk Generator initialized");
 	}
 	
@@ -83,26 +84,26 @@ public class BatchGenerator implements IDhApiWorldGenerator
 	
 	
 	
-	
 	//===================//
 	// generator methods //
 	//===================//
 	
 	@Override
 	public CompletableFuture<Void> generateChunks(
-			int chunkPosMinX, int chunkPosMinZ, int generationRequestChunkWidthCount, byte targetDataDetail, EDhApiDistantGeneratorMode generatorMode,
-			ExecutorService worldGeneratorThreadPool, Consumer<Object[]> resultConsumer)
+			int chunkPosMinX,
+			int chunkPosMinZ,
+			int chunkWidthCount,
+			byte targetDataDetail,
+			EDhApiDistantGeneratorMode generatorMode,
+			ExecutorService worldGeneratorThreadPool,
+			Consumer<Object[]> resultConsumer)
 	{
-		EDhApiWorldGenerationStep targetStep = null;
+		EDhApiWorldGenerationStep targetStep;
 		switch (generatorMode)
 		{
-			case PRE_EXISTING_ONLY: // Only load in existing chunks. Note: this requires the biome generation step in order for biomes to be properly initialized.
-			//case BIOME_ONLY: // No blocks. Require fake height in LodBuilder
-				targetStep = EDhApiWorldGenerationStep.BIOMES; 
+			case PRE_EXISTING_ONLY: // Only load in existing chunks.
+				targetStep = EDhApiWorldGenerationStep.EMPTY; // special logic
 				break;
-			//case BIOME_ONLY_SIMULATE_HEIGHT:
-			//	targetStep = EDhApiWorldGenerationStep.NOISE; // Stone only. Requires a fake surface
-			//	break;
 			case SURFACE:
 				targetStep = EDhApiWorldGenerationStep.SURFACE;
 				break;
@@ -112,20 +113,27 @@ public class BatchGenerator implements IDhApiWorldGenerator
 			case INTERNAL_SERVER:
 				targetStep = EDhApiWorldGenerationStep.LIGHT;
 				break;
+				
+			default:
+				throw new IllegalArgumentException("no target step defined for generator mode: ["+generatorMode+"].");
 		}
 		
 		// the consumer needs to be wrapped like this because the API can't use DH core objects (and IChunkWrapper can't be easily put into the API project)
 		Consumer<IChunkWrapper> consumerWrapper = (chunkWrapper) -> resultConsumer.accept(new Object[]{chunkWrapper});
 		try
 		{
-			return this.generationEnvironment.generateChunks(
-					chunkPosMinX, chunkPosMinZ, generationRequestChunkWidthCount, 
+			return this.generationEnvironment.queueGenEvent(
+					chunkPosMinX, chunkPosMinZ, chunkWidthCount, 
 					generatorMode, targetStep, 
 					worldGeneratorThreadPool, consumerWrapper);
 		}
 		catch (Exception e)
 		{
-			if (!LodUtil.isInterruptOrReject(e)) LOGGER.error("Error starting future for chunk generation", e);
+			if (!ExceptionUtil.isInterruptOrReject(e))
+			{
+				LOGGER.error("Error starting future for chunk generation, error: ["+e.getMessage()+"].", e);
+			}
+			
 			CompletableFuture<Void> future = new CompletableFuture<>();
 			future.completeExceptionally(e);
 			return future;
@@ -144,9 +152,10 @@ public class BatchGenerator implements IDhApiWorldGenerator
 	@Override
 	public void close()
 	{
-		LOGGER.info(BatchGenerator.class.getSimpleName() + " shutting down...");
-		this.generationEnvironment.stop();
+		LOGGER.info("["+BatchGenerator.class.getSimpleName()+"] shutting down...");
+		this.generationEnvironment.close();
 	}
 	
 	
+	
 }

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

@@ -118,15 +118,19 @@ public class DhLightingEngine
 	 * @param centerChunk the chunk we want to apply lighting to
 	 * @param nearbyChunkList should also contain centerChunk
 	 * @param maxSkyLight should be a value between 0 and 15
+	 * 
+	 * @return the number of light positions iterated over, can be used for profiling.
 	 */
-	private void lightChunk(
+	private int lightChunk(
 			@NotNull IChunkWrapper centerChunk, @NotNull ArrayList<IChunkWrapper> nearbyChunkList, 
 			int maxSkyLight, boolean updateBlockLight, boolean updateSkyLight)
 	{
 		DhChunkPos centerChunkPos = centerChunk.getChunkPos();
 		AdjacentChunkHolder adjacentChunkHolder = new AdjacentChunkHolder(centerChunk);
 		
-		
+		// how many positions we've walked over, can be used for profiling/debugging
+		int posIterations = 0;
+			
 		// try-finally to handle the stableArray resources
 		StableLightPosStack blockLightWorldPosQueue = null;
 		StableLightPosStack skyLightWorldPosQueue = null;
@@ -154,14 +158,15 @@ public class DhLightingEngine
 			// and get any necessary info from them
 			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);
-				if (chunk != null && requestedAdjacentPositions.contains(chunk.getChunkPos()))
+				IChunkWrapper neighborChunk = nearbyChunkList.get(chunkIndex);
+				if (neighborChunk != null 
+					&& requestedAdjacentPositions.contains(neighborChunk.getChunkPos()))
 				{
 					// remove the newly found position
-					requestedAdjacentPositions.remove(chunk.getChunkPos());
+					requestedAdjacentPositions.remove(neighborChunk.getChunkPos());
 					
 					// add the adjacent chunk
-					adjacentChunkHolder.add(chunk);
+					adjacentChunkHolder.add(neighborChunk);
 					
 					// get and set the adjacent chunk's initial block lights
 					final DhBlockPosMutable relLightBlockPos = PRIMARY_BLOCK_POS_REF.get();
@@ -174,19 +179,19 @@ public class DhLightingEngine
 					
 					if (updateBlockLight)
 					{
-						ArrayList<DhBlockPos> blockLightPosList = chunk.getWorldBlockLightPosList();
+						ArrayList<DhBlockPos> blockLightPosList = neighborChunk.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);
+							IBlockStateWrapper blockState = neighborChunk.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);
+							neighborChunk.setDhBlockLight(relLightBlockPos.getX(), relLightBlockPos.getY(), relLightBlockPos.getZ(), lightValue);
 						}
 					}
 					
@@ -198,23 +203,24 @@ public class DhLightingEngine
 					
 					// get and set the adjacent chunk's initial skylights,
 					// if the dimension has skylights
-					if (updateSkyLight && maxSkyLight > 0)
+					if (updateSkyLight 
+						&& maxSkyLight > 0)
 					{
-						IMutableBlockPosWrapper mcBlockPos = chunk.getMutableBlockPosWrapper();
+						IMutableBlockPosWrapper mcBlockPos = neighborChunk.getMutableBlockPosWrapper();
 						IBlockStateWrapper previousBlockState = null;
 						
-						int maxY = chunk.getMaxNonEmptyHeight();
-						int minY = chunk.getInclusiveMinBuildHeight();
+						int maxY = neighborChunk.getMaxNonEmptyHeight();
+						int minY = neighborChunk.getInclusiveMinBuildHeight();
 						
 						// get the adjacent chunk's sky lights
 						for (int relX = 0; relX < LodUtil.CHUNK_WIDTH; relX++) // relative block pos
 						{
 							for (int relZ = 0; relZ < LodUtil.CHUNK_WIDTH; relZ++)
 							{
-								// set each pos' sky light all the way down until an 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 = previousBlockState = chunk.getBlockState(relX, y, relZ, mcBlockPos, previousBlockState);
+									IBlockStateWrapper block = previousBlockState = neighborChunk.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
@@ -223,12 +229,12 @@ public class DhLightingEngine
 									
 									
 									// add sky light to the queue
-									DhBlockPos skyLightPos = new DhBlockPos(chunk.getMinBlockX() + relX, y, chunk.getMinBlockZ() + relZ);
+									DhBlockPos skyLightPos = new DhBlockPos(neighborChunk.getMinBlockX() + relX, y, neighborChunk.getMinBlockZ() + relZ);
 									skyLightWorldPosQueue.push(skyLightPos.getX(), skyLightPos.getY(), skyLightPos.getZ(), maxSkyLight);
 									
 									// set the chunk's sky light
 									skyLightPos.mutateToChunkRelativePos(relLightBlockPos);
-									chunk.setDhSkyLight(relLightBlockPos.getX(), relLightBlockPos.getY(), relLightBlockPos.getZ(), maxSkyLight);
+									neighborChunk.setDhSkyLight(relLightBlockPos.getX(), relLightBlockPos.getY(), relLightBlockPos.getZ(), maxSkyLight);
 								}
 							}
 						}
@@ -243,17 +249,18 @@ public class DhLightingEngine
 				}
 			}
 			
+			
+			
 			// block light
 			if (updateBlockLight)
 			{
 				// done to prevent a rare issue where the light values are incorrectly set to -1
-				// TODO why could that happen?
 				centerChunk.clearDhBlockLighting();
 				
-				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);
+				posIterations += 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
@@ -261,10 +268,10 @@ public class DhLightingEngine
 			{
 				centerChunk.clearDhSkyLighting();
 				
-				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);
+				posIterations += 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)
@@ -286,10 +293,12 @@ public class DhLightingEngine
 		{
 			centerChunk.setIsDhSkyLightCorrect(true);
 		}
+		
+		return posIterations;
 	}
 	
 	/** Applies each {@link LightPos} from the queue to the given set of {@link IChunkWrapper}'s. */
-	private void propagateChunkLightPosList(
+	private int propagateChunkLightPosList(
 			StableLightPosStack lightPosQueue, AdjacentChunkHolder adjacentChunkHolder,
 			IGetLightFunc getLightFunc, ISetLightFunc setLightFunc,
 			boolean propagatingBlockLights)
@@ -300,88 +309,124 @@ public class DhLightingEngine
 		final DhBlockPosMutable neighbourBlockPos = PRIMARY_BLOCK_POS_REF.get();
 		final DhBlockPosMutable relNeighbourBlockPos = SECONDARY_BLOCK_POS_REF.get();
 		
+		// it doesn't matter what chunk we get the mutable block pos from
 		IMutableBlockPosWrapper mcBlockPos = null;
+		for (int i = 0; i < adjacentChunkHolder.chunkArray.length; i++)
+		{
+			IChunkWrapper chunkWrapper = adjacentChunkHolder.chunkArray[i];
+			if (chunkWrapper != null)
+			{
+				mcBlockPos = chunkWrapper.getMutableBlockPosWrapper();
+				break;
+			}
+		}
+		if (mcBlockPos == null)
+		{
+			LodUtil.assertNotReach("How did we try to light a chunk with no chunks?");
+		}
+		
 		IBlockStateWrapper previousBlockState = null;
 		
-		// update each light position
-		while (!lightPosQueue.isEmpty())
+		
+		int iterations = 0;
+		
+		// update each light level
+		for (int currentLightLevel = LodUtil.MAX_MC_LIGHT; currentLightLevel >= LodUtil.MIN_MC_LIGHT; currentLightLevel--)
 		{
-			// since we don't care about the order the positions are processed,
-			// we can grab the last position instead of the first for a slight performance increase (this way the array doesn't need to be shifted over every loop)
-			lightPosQueue.popMutate(lightPos);
+			// Walking down from the top light level to the bottom can reduce iterating over
+			// the same positions multiple times.
+			// At best this seems to behave at roughly 2x the speed of just blindly putting light pos 
+			// in a queue and at worse slightly faster than the blind queue.
 			
-			int lightValue = lightPos.lightValue;
+			lightPos.lightValue = currentLightLevel;
 			
-			
-			// propagate the lighting in each cardinal direction, IE: -x, +x, -y, +y, -z, +z
-			for (EDhDirection direction : EDhDirection.ALL) // since this is an array instead of an ArrayList this advanced for-loop shouldn't cause any GC issues
+			// update each light position
+			while (!lightPosQueue.isLightLevelEmpty(currentLightLevel))
 			{
-				lightPos.mutateOffset(direction, neighbourBlockPos);
-				neighbourBlockPos.mutateToChunkRelativePos(relNeighbourBlockPos);
+				// since we don't care about the order the positions are processed,
+				// we can grab the last position instead of the first for a slight performance increase (this way the array doesn't need to be shifted over every loop)
+				lightPosQueue.popMutate(lightPos, currentLightLevel);
+				iterations++;
+				
+				int lightValue = lightPos.lightValue;
 				
 				
-				// only continue if the light position is inside one of our chunks
-				IChunkWrapper neighbourChunk = adjacentChunkHolder.getByBlockPos(neighbourBlockPos.getX(), neighbourBlockPos.getZ());
-				if (neighbourChunk == null)
+				// propagate the lighting in each cardinal direction, IE: -x, +x, -y, +y, -z, +z
+				for (EDhDirection direction : EDhDirection.ALL) // since this is an array instead of an ArrayList this advanced for-loop shouldn't cause any GC issues
 				{
-					// the light pos is outside our generator's range, ignore it
-					continue;
-				}
-				
-				if (relNeighbourBlockPos.getY() < neighbourChunk.getMinNonEmptyHeight()
-					|| relNeighbourBlockPos.getY() >= neighbourChunk.getExclusiveMaxBuildHeight())
-				{
-					// the light pos is outside the chunk's min/max height,
-					// this can happen if given a chunk that hasn't finished generating
-					continue;
-				}
-				
-				
-				int currentBlockLight = getLightFunc.getLight(neighbourChunk, relNeighbourBlockPos);
-				if (currentBlockLight >= (lightValue - 1))
-				{
-					// short circuit for when the light value at this position
-					// is already greater-than what we could set it
-					continue;
-				}
-				
-				
-				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)
-				{
-					// this position is darker than the new light value, update/set it
-					setLightFunc.setLight(neighbourChunk, relNeighbourBlockPos, targetLevel);
+					lightPos.mutateOffset(direction, neighbourBlockPos);
+					neighbourBlockPos.mutateToChunkRelativePos(relNeighbourBlockPos);
 					
-					// 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.getX(), neighbourBlockPos.getY(), neighbourBlockPos.getZ(), targetLevel);
+					
+					// only continue if the light position is inside one of our chunks
+					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.getY() < neighbourChunk.getMinNonEmptyHeight()
+						|| relNeighbourBlockPos.getY() >= neighbourChunk.getExclusiveMaxBuildHeight())
+					{
+						// the light pos is outside the chunk's min/max height,
+						// this can happen if given a chunk that hasn't finished generating
+						continue;
+					}
+					
+					
+					int currentBlockLight = getLightFunc.getLight(neighbourChunk, relNeighbourBlockPos);
+					if (currentBlockLight >= (lightValue - 1))
+					{
+						// short circuit for when the light value at this position
+						// is already greater-than what we could set it
+						continue;
+					}
+					
+					
+					IBlockStateWrapper neighbourBlockState = neighbourChunk.getBlockState(relNeighbourBlockPos, mcBlockPos, previousBlockState);
+					previousBlockState = neighbourBlockState;
+					
+					// Math.max(1, ...) is used so that the propagated light level always drops by at least 1, preventing infinite cycles.
+					int targetLightLevel = lightValue - Math.max(1, neighbourBlockState.getOpacity());
+					if (targetLightLevel > currentBlockLight)
+					{
+						// this position is darker than the new light value, update/set it
+						setLightFunc.setLight(neighbourChunk, relNeighbourBlockPos, targetLightLevel);
+						
+						// 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.getX(), neighbourBlockPos.getY(), neighbourBlockPos.getZ(), targetLightLevel);
+					}
 				}
 			}
 		}
 		
+		for (int currentLightLevel = LodUtil.MAX_MC_LIGHT; currentLightLevel >= LodUtil.MIN_MC_LIGHT; currentLightLevel--)
+		{
+			if (!lightPosQueue.isLightLevelEmpty(currentLightLevel))
+			{
+				LodUtil.assertNotReach("Non empty light pos queue for light level ["+currentLightLevel+"] after light engine running");
+			}
+		}
 		
-		// can be enable if troubleshooting lighting issues
-		if (RENDER_BLOCK_LIGHT_WIREFRAME && propagatingBlockLights)
+		
+		
+		// can be enabled if troubleshooting lighting issues
+		if (RENDER_BLOCK_LIGHT_WIREFRAME 
+			&& propagatingBlockLights)
 		{
 			RenderDhLightValuesAsWireframe(adjacentChunkHolder, true);
 		}
-		else if (RENDER_SKY_LIGHT_WIREFRAME && !propagatingBlockLights)
+		else if (RENDER_SKY_LIGHT_WIREFRAME 
+			&& !propagatingBlockLights)
 		{
 			RenderDhLightValuesAsWireframe(adjacentChunkHolder, false);
 		}
 		
 		
 		// propagation complete
+		return iterations;
 	}
 	
 	
@@ -462,7 +507,7 @@ public class DhLightingEngine
 							point = FullDataPointUtil.setSkyLight(point, skylight);
 							dataPoints.set(index, point);
 							// now for the propagation.
-							recursivelyLightAdjacentDataPoints(dataSource, airIDs, x, z, point);
+							this.recursivelyLightAdjacentDataPoints(dataSource, airIDs, x, z, point);
 						}
 					}
 				}
@@ -596,7 +641,7 @@ public class DhLightingEngine
 						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?
+							continue;
 						}
 						else
 						{
@@ -610,7 +655,7 @@ public class DhLightingEngine
 								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);
+								this.recursivelyLightAdjacentDataPoints(chunk, airIDs, adjacentX, adjacentZ, adjacentDataPoint);
 							}
 						}
 					}
@@ -735,16 +780,24 @@ public class DhLightingEngine
 		private static final Queue<StableLightPosStack> lightArrayCache = new ArrayDeque<>();
 		
 		/** the index of the last item in the array, -1 if empty */
-		private int index = -1;
+		private int[] indexByLightLevel = new int[LodUtil.MAX_MC_LIGHT + 1];
 
-		/** x, y, z, and lightValue. */
-		public static final int INTS_PER_LIGHT_POS = 4;
+		/** x, y, z */
+		public static final int INTS_PER_LIGHT_POS = 3;
 		
-		/**
-		 * When tested with a normal 1.20 world James saw a maximum of 36,709 block and 2,355 sky lights,
-		 * so 40,000 should be a good starting point that can contain most lighting tasks.
-		 */
-		private final IntArrayList lightPositions = new IntArrayList(40_000 * INTS_PER_LIGHT_POS);
+		private final IntArrayList[] lightPositionsByLightLevel = new IntArrayList[LodUtil.MAX_MC_LIGHT + 1];
+		
+		
+		public StableLightPosStack()
+		{
+			for (int i = 0; i < this.lightPositionsByLightLevel.length; i++)
+			{
+				// When tested with a normal 1.20 world James saw a maximum of 36,709 block and 2,355 sky lights,
+				// so 40,000 should be a good starting point that can contain most lighting tasks.
+				this.lightPositionsByLightLevel[i] = new IntArrayList(40_000 * INTS_PER_LIGHT_POS);
+				this.indexByLightLevel[i] = -1;
+			}
+		}
 		
 		
 		
@@ -791,45 +844,56 @@ public class DhLightingEngine
 		// stack methods //
 		//===============//
 		
-		public boolean isEmpty() { return this.index == -1; }
-		public int size() { return this.index+1; }
+		public boolean isLightLevelEmpty(int lightLevel) { return this.indexByLightLevel[lightLevel] == -1; }
+		//public int size() { return this.index+1; }
 		
-		public void push(int blockX, int blockY, int blockZ, int lightValue)
+		public void push(int blockX, int blockY, int blockZ, int lightLevel)
 		{
-			this.index++;
-			int subIndex = this.index * INTS_PER_LIGHT_POS;
-			if (subIndex < this.lightPositions.size())
+			IntArrayList lightPositions = this.lightPositionsByLightLevel[lightLevel];
+			
+			this.indexByLightLevel[lightLevel]++;
+			int subIndex = this.indexByLightLevel[lightLevel] * INTS_PER_LIGHT_POS;
+			if (subIndex < lightPositions.size())
 			{
-				this.lightPositions.set(subIndex, blockX);
-				this.lightPositions.set(subIndex + 1, blockY);
-				this.lightPositions.set(subIndex + 2, blockZ);
-				this.lightPositions.set(subIndex + 3, lightValue);
+				lightPositions.set(subIndex, blockX);
+				lightPositions.set(subIndex + 1, blockY);
+				lightPositions.set(subIndex + 2, blockZ);
 			}
 			else
 			{
 				// add a new pos
-				this.lightPositions.add(blockX);
-				this.lightPositions.add(blockY);
-				this.lightPositions.add(blockZ);
-				this.lightPositions.add(lightValue);
+				lightPositions.add(blockX);
+				lightPositions.add(blockY);
+				lightPositions.add(blockZ);
 			}
 		}
 		
 		/** mutates the given {@link LightPos} to match the next {@link LightPos} in the queue. */
-		public void popMutate(LightPos pos)
+		public void popMutate(LightPos pos, int lightLevel)
 		{
-			int subIndex = this.index * INTS_PER_LIGHT_POS;
+			int subIndex = this.indexByLightLevel[lightLevel] * INTS_PER_LIGHT_POS;
+			IntArrayList lightPositions = this.lightPositionsByLightLevel[lightLevel];
 			
-			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);
+			pos.setX(lightPositions.getInt(subIndex));
+			pos.setY(lightPositions.getInt(subIndex + 1));
+			pos.setZ(lightPositions.getInt(subIndex + 2));
 			
-			this.index--;
+			this.indexByLightLevel[lightLevel]--;
 		}
 		
 		@Override
-		public String toString() { return this.index + "/" + (this.lightPositions.size() / INTS_PER_LIGHT_POS); }
+		public String toString() 
+		{ 
+			StringBuilder builder = new StringBuilder();
+			
+			for (int i = 0; i < this.indexByLightLevel.length; i++)
+			{
+				builder.append("light: ").append(i)
+					.append(" size: ").append(this.indexByLightLevel[i]).append("/").append(this.lightPositionsByLightLevel[i].size() / INTS_PER_LIGHT_POS).append("\n");
+			}
+			
+			return builder.toString();
+		}
 		
 	}
 	

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

@@ -19,13 +19,11 @@
 
 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.generation.tasks.DataSourceRetrievalResult;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.LodQuadTree;
 import com.seibel.distanthorizons.core.util.objects.RollingAverage;
-import org.jetbrains.annotations.Nullable;
 
 import java.io.Closeable;
 import java.util.List;
@@ -92,7 +90,7 @@ public interface IFullDataSourceRetrievalQueue extends Closeable
 	 */
 	void removeRetrievalRequestIf(DhSectionPos.ICancelablePrimitiveLongConsumer removeIf);
 	
-	CompletableFuture<WorldGenResult> submitRetrievalTask(long pos, byte requiredDataDetail, IWorldGenTaskTracker tracker);
+	CompletableFuture<DataSourceRetrievalResult> submitRetrievalTask(long pos, byte requiredDataDetail);
 	
 	
 	

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

@@ -5,13 +5,17 @@ import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.RemovalCause;
 import com.seibel.distanthorizons.core.api.internal.SharedApi;
 import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.file.fullDatafile.GeneratedFullDataSourceProvider;
+import com.seibel.distanthorizons.core.generation.tasks.DataSourceRetrievalResult;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.generation.tasks.ERetrievalResultState;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.util.FormatUtil;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.objects.RollingAverage;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.Nullable;
@@ -28,6 +32,8 @@ public class PregenManager
 {
 	protected static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
+	private static final IMinecraftSharedWrapper MC_SERVER = SingletonInjector.INSTANCE.get(IMinecraftSharedWrapper.class);
+	
 	private final AtomicReference<PregenState> pregenFuture = new AtomicReference<>();
 	
 	
@@ -51,6 +57,7 @@ public class PregenManager
 			pregenState.completeExceptionally(new IllegalStateException("Pregen is already running."));
 			return pregenState;
 		}
+		
 		pregenState.whenComplete((result, throwable) -> {
 			this.pregenFuture.set(null);
 		});
@@ -104,7 +111,7 @@ public class PregenManager
 					}
 					
 					long timeSincePreviousTaskFinish = System.currentTimeMillis() - this.lastTaskFinishTime.getAndSet(System.currentTimeMillis());
-					this.averageTaskCompletionIntervalMs.addValue(timeSincePreviousTaskFinish);
+					this.averageTaskCompletionIntervalMs.add(timeSincePreviousTaskFinish);
 					
 					PregenState.this.fillPendingQueue();
 				})
@@ -143,20 +150,22 @@ public class PregenManager
 				this.fullDataSourceProvider.getAsync(nextSectionPos)
 					.thenAccept(fullDataSource -> 
 				{
-					if (this.fullDataSourceProvider.isFullyGenerated(fullDataSource.columnGenerationSteps))
+					if (this.fullDataSourceProvider.generationStepsAreFullyGenerated(fullDataSource.columnGenerationSteps))
 					{
 						this.pendingGenerations.invalidate(fullDataSource.getPos());
 					}
 					else
 					{
-						this.fullDataSourceProvider.queuePositionForRetrieval(fullDataSource.getPos()).thenAccept(result -> {
-							if (!result.success)
+						this.fullDataSourceProvider.queuePositionForRetrieval(fullDataSource.getPos())
+							.whenComplete((DataSourceRetrievalResult result, Throwable throwable) ->
 							{
-								LOGGER.warn("Failed to generate section " + DhSectionPos.toString(result.pos));
-							}
-							
-							this.pendingGenerations.invalidate(result.pos);
-						});
+								if (throwable != null)
+								{
+									LOGGER.warn("Failed to generate section " + DhSectionPos.toString(result.pos));
+								}
+								
+								this.pendingGenerations.invalidate(result.pos);
+							});
 					}
 					
 					fullDataSource.close();

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

@@ -1,8 +1,8 @@
 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.generation.tasks.DataSourceRetrievalResult;
+import com.seibel.distanthorizons.core.generation.tasks.ERetrievalResultState;
 import com.seibel.distanthorizons.core.level.DhClientLevel;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.multiplayer.client.AbstractFullDataNetworkRequestQueue;
@@ -11,12 +11,11 @@ import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
 import com.seibel.distanthorizons.core.util.LodUtil;
+import com.seibel.distanthorizons.core.util.WorldGenUtil;
 import com.seibel.distanthorizons.core.util.objects.RollingAverage;
 import com.seibel.distanthorizons.core.logging.DhLogger;
+import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
 import java.util.concurrent.*;
 
 public class RemoteWorldRetrievalQueue extends AbstractFullDataNetworkRequestQueue implements IFullDataSourceRetrievalQueue, IDebugRenderable
@@ -53,46 +52,28 @@ public class RemoteWorldRetrievalQueue extends AbstractFullDataNetworkRequestQue
 	public byte highestDataDetail() { return LodUtil.BLOCK_DETAIL_LEVEL; }
 	
 	@Override
-	public CompletableFuture<WorldGenResult> submitRetrievalTask(long sectionPos, byte requiredDataDetail, IWorldGenTaskTracker tracker)
+	public CompletableFuture<DataSourceRetrievalResult> submitRetrievalTask(long sectionPos, byte requiredDataDetail)
 	{
 		long generationStartMsTime = System.currentTimeMillis();
 		
 		
-		return super.submitRequest(sectionPos, fullDataSource -> {
-					Objects.requireNonNull(tracker.getDataSourceConsumer()).accept(fullDataSource);
-					fullDataSource.close();
-				})
-				.thenApply(requestResult ->
-				{
-					long totalGenTimeInMs = System.currentTimeMillis() - generationStartMsTime;
-					
-					int chunkWidth = DhSectionPos.getChunkWidth(sectionPos);
-					int chunkCount = chunkWidth * chunkWidth;
-					double timePerChunk = (double)totalGenTimeInMs / (double)chunkCount;
-					this.rollingAverageChunkGenTimeInMs.addValue(timePerChunk);
-					
-					switch (requestResult)
-					{
-						case SUCCEEDED:
-							return WorldGenResult.CreateSuccess(sectionPos);
-						case FAILED:
-							return WorldGenResult.CreateFail();
-						case REQUIRES_SPLITTING:
-							List<CompletableFuture<WorldGenResult>> childFutures = new ArrayList<>(4);
-							DhSectionPos.forEachChild(sectionPos, childPos -> {
-								tracker.shouldGenerateSplitChild(childPos).thenAccept(shouldGenerate -> {
-									if (shouldGenerate)
-									{
-										childFutures.add(this.submitRetrievalTask(childPos, requiredDataDetail, tracker));
-									}
-								});
-							});
-							return WorldGenResult.CreateSplit(childFutures);
-					}
-					
-					LodUtil.assertNotReach("Unexpected and unhandled request response result: ["+requestResult+"]");
-					return WorldGenResult.CreateFail();
-				});
+		CompletableFuture<DataSourceRetrievalResult> future = super.submitRequest(sectionPos, /* client timestamp */null);
+		future.thenAccept((DataSourceRetrievalResult result) -> 
+		{
+			if (result.state == ERetrievalResultState.SUCCESS)
+			{
+				long totalGenTimeInMs = System.currentTimeMillis() - generationStartMsTime;
+
+				int chunkWidth = DhSectionPos.getChunkWidth(sectionPos);
+				int chunkCount = chunkWidth * chunkWidth;
+				double timePerChunk = (double) totalGenTimeInMs / (double) chunkCount;
+
+				// only add the time on successes
+				// it won't be a perfect estimate but fails will often come back faster, skewing the time faster
+				this.rollingAverageChunkGenTimeInMs.add(timePerChunk);
+			}
+		});
+		return future;
 	}
 	
 	@Override
@@ -108,14 +89,16 @@ public class RemoteWorldRetrievalQueue extends AbstractFullDataNetworkRequestQue
 	@Override
 	protected int getRequestRateLimit() { return this.networkState.sessionConfig.getGenerationRequestRateLimit(); }
 	@Override
-	protected boolean isSectionAllowedToGenerate(long sectionPos, DhBlockPos2D targetPos)
+	protected boolean sectionInAllowedGenerationRadius(long sectionPos, DhBlockPos2D targetPos)
 	{
-		if (this.networkState.sessionConfig.getGenerationBoundsRadius() > 0)
+		if (this.networkState.sessionConfig.getGenerationMaxChunkRadius() > 0)
 		{
-			if (DhSectionPos.getChebyshevSignedBlockDistance(sectionPos, new DhBlockPos2D(
-					this.networkState.sessionConfig.getGenerationBoundsX(),
-					this.networkState.sessionConfig.getGenerationBoundsZ()
-			)) > this.networkState.sessionConfig.getGenerationBoundsRadius())
+			boolean posInRange = WorldGenUtil.isPosInWorldGenRange(
+				sectionPos,
+				this.networkState.sessionConfig.getGenerationCenterChunkX(), this.networkState.sessionConfig.getGenerationCenterChunkZ(),
+				this.networkState.sessionConfig.getGenerationMaxChunkRadius()
+				);
+			if (!posInRange)
 			{
 				return false;
 			}
@@ -124,12 +107,13 @@ public class RemoteWorldRetrievalQueue extends AbstractFullDataNetworkRequestQue
 		return DhSectionPos.getChebyshevSignedBlockDistance(sectionPos, targetPos) <= this.networkState.sessionConfig.getMaxGenerationRequestDistance() * 16;
 	}
 	@Override
-	protected boolean onBeforeRequest(long sectionPos, CompletableFuture<ERequestResult> future)
+	protected boolean onBeforeRequest(long sectionPos, CompletableFuture<DataSourceRetrievalResult> future)
 	{
-		if (DhSectionPos.getDetailLevel(sectionPos) > DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL
-				&& !Config.Server.Experimental.enableNSizedGeneration.get())
+		// split up large requests if N-sized gen isn't enabled
+		if (!Config.Server.Experimental.enableNSizedGeneration.get()
+			&& DhSectionPos.getDetailLevel(sectionPos) > DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL)
 		{
-			future.complete(ERequestResult.REQUIRES_SPLITTING);
+			future.complete(DataSourceRetrievalResult.CreateSplit());
 			return false;
 		}
 		

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

@@ -26,11 +26,8 @@ import com.seibel.distanthorizons.api.objects.data.DhApiChunk;
 import com.seibel.distanthorizons.api.objects.data.IDhApiFullDataSource;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
-import com.seibel.distanthorizons.core.generation.tasks.IWorldGenTaskTracker;
-import com.seibel.distanthorizons.core.generation.tasks.InProgressWorldGenTaskGroup;
-import com.seibel.distanthorizons.core.generation.tasks.WorldGenResult;
-import com.seibel.distanthorizons.core.generation.tasks.WorldGenTask;
-import com.seibel.distanthorizons.core.generation.tasks.WorldGenTaskGroup;
+import com.seibel.distanthorizons.core.generation.tasks.DataSourceRetrievalResult;
+import com.seibel.distanthorizons.core.generation.tasks.DataSourceRetrievalTask;
 import com.seibel.distanthorizons.core.level.IDhServerLevel;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
@@ -40,6 +37,7 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.transformers.LodDataBuilder;
 import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
 import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
+import com.seibel.distanthorizons.core.util.ExceptionUtil;
 import com.seibel.distanthorizons.core.util.LodUtil.AssertFailureException;
 import com.seibel.distanthorizons.core.util.ThreadUtil;
 import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
@@ -51,37 +49,25 @@ import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
 import com.seibel.distanthorizons.core.world.DhApiWorldProxy;
 import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
-import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.awt.*;
 import java.util.*;
 import java.util.List;
 import java.util.concurrent.*;
-import java.util.function.Consumer;
 
 public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDebugRenderable
 {
 	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	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;
 	private final IDhServerLevel level;
 	
 	/** contains the positions that need to be generated */
-	private final ConcurrentHashMap<Long, WorldGenTask> waitingTasks = new ConcurrentHashMap<>();
-	
-	private final ConcurrentHashMap<Long, InProgressWorldGenTaskGroup> inProgressGenTasksByLodPos = new ConcurrentHashMap<>();
+	private final ConcurrentHashMap<Long, DataSourceRetrievalTask> waitingTasks = new ConcurrentHashMap<>();
+	private final ConcurrentHashMap<Long, DataSourceRetrievalTask> inProgressGenTasksByLodPos = new ConcurrentHashMap<>();
 	
 	/** largest numerical detail level allowed */
 	public final byte lowestDataDetail;
@@ -106,13 +92,14 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 	private int estimatedRemainingChunkCount = 0;
 	
 	private final RollingAverage rollingAverageChunkGenTimeInMs = new RollingAverage(Runtime.getRuntime().availableProcessors() * 500);
-	public RollingAverage getRollingAverageChunkGenTimeInMs() { return this.rollingAverageChunkGenTimeInMs; }
+	@Override public RollingAverage getRollingAverageChunkGenTimeInMs() { return this.rollingAverageChunkGenTimeInMs; }
 	
 	
 	
-	//==============//
-	// constructors //
-	//==============//
+	//=============//
+	// constructor //
+	//=============//
+	///region constructor
 	
 	public WorldGenerationQueue(IDhApiWorldGenerator generator, IDhServerLevel level)
 	{
@@ -126,20 +113,31 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		LOGGER.info("Created world gen queue");
 	}
 	
+	///endregion constructor
 	
 	
-	//=================//
-	// world generator //
-	// task handling   //
-	//=================//
+	
+	//===============//
+	// task handling //
+	//===============//
+	///region task handling
 	
 	@Override
-	public CompletableFuture<WorldGenResult> submitRetrievalTask(long pos, byte requiredDataDetail, IWorldGenTaskTracker tracker)
+	public CompletableFuture<DataSourceRetrievalResult> submitRetrievalTask(long pos, byte requiredDataDetail)
 	{
 		// the generator is shutting down, don't add new tasks
 		if (this.generatorClosingFuture != null)
 		{
-			return CompletableFuture.completedFuture(WorldGenResult.CreateFail());
+			CompletableFuture<DataSourceRetrievalResult> f = new CompletableFuture<>();
+			f.completeExceptionally(new CancellationException());
+			return f;
+		}
+		
+		// use the existing task if present
+		DataSourceRetrievalTask existingGenTask = this.waitingTasks.get(pos);
+		if (existingGenTask != null)
+		{
+			return existingGenTask.future;
 		}
 		
 		
@@ -153,13 +151,12 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 			requiredDataDetail = this.lowestDataDetail;
 		}
 		
-		// Assert that the data at least can fill in 1 single ChunkSizedFullDataAccessor
+		// the request should be at least chunk-sized
 		LodUtil.assertTrue(DhSectionPos.getDetailLevel(pos) > requiredDataDetail + LodUtil.CHUNK_DETAIL_LEVEL);
 		
-		
-		CompletableFuture<WorldGenResult> future = new CompletableFuture<>();
-		this.waitingTasks.put(pos, new WorldGenTask(pos, requiredDataDetail, tracker, future));
-		return future;
+		DataSourceRetrievalTask genTask = new DataSourceRetrievalTask(pos, requiredDataDetail);
+		this.waitingTasks.put(pos, genTask);
+		return genTask.future;
 	}
 	
 	@Override
@@ -169,11 +166,17 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		{
 			if (removeIf.accept(genPos))
 			{
-				this.waitingTasks.remove(genPos);
+				DataSourceRetrievalTask removedTask = this.waitingTasks.remove(genPos);
+				if (removedTask != null)
+				{
+					// cancel tasks so any waiting future steps can be triggered
+					removedTask.future.cancel(true);
+				}
 			}
 		});
 	}
 	
+	///endregion task handling
 	
 	
 	
@@ -218,7 +221,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 				while (!this.isGeneratorBusy()
 						&& taskStarted)
 				{
-					taskStarted = this.startNextWorldGenTask(this.generationTargetPos);
+					taskStarted = this.tryStartNextWorldGenTask(this.generationTargetPos);
 				}
 			}
 			catch (Exception e)
@@ -240,15 +243,15 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 			return true;
 		}
 		
+		// queue more tasks if any of the threads are available
 		int worldGenThreadCount = Math.max(Config.Common.MultiThreading.numberOfThreads.get(), 1);
-		int maxWorldGenTaskCount = worldGenThreadCount * MAX_QUEUED_TASKS_PER_THREAD;
-		return executor.getQueueSize() > maxWorldGenTaskCount;
+		return this.inProgressGenTasksByLodPos.size() > worldGenThreadCount;
 	}
 	/**
 	 * @param targetPos the position to center the generation around
 	 * @return false if no tasks were found to generate
 	 */
-	private boolean startNextWorldGenTask(DhBlockPos2D targetPos)
+	private boolean tryStartNextWorldGenTask(DhBlockPos2D targetPos)
 	{
 		if (this.waitingTasks.isEmpty())
 		{
@@ -256,260 +259,155 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		}
 		
 		
+		// find the closest task
+		TaskDistancePair closestTaskPair = this.waitingTasks.reduceEntries(1024,
+			// get the target distance for each task
+			(Map.Entry<Long, DataSourceRetrievalTask> entry) ->
+			{ 
+				DataSourceRetrievalTask task = entry.getValue();
+				int distance = DhSectionPos.getCenterBlockPos(task.pos).chebyshevDist(targetPos);
+				return new TaskDistancePair(entry.getValue(), distance);
+			},
+			// find the closest task
+			(TaskDistancePair aTaskPair, TaskDistancePair bTaskPair) ->
+			{
+				return (aTaskPair.dist < bTaskPair.dist) ? aTaskPair : bTaskPair;
+			});
 		
-		Mapper closestTaskMap = this.waitingTasks.reduceEntries(1024,
-				entry -> new Mapper(entry.getValue(), DhSectionPos.getSectionBBoxPos(entry.getValue().pos).getCenterBlockPos().toPos2D().chebyshevDist(targetPos.toPos2D())),
-				(aMapper, bMapper) -> aMapper.dist < bMapper.dist ? aMapper : bMapper);
-		
-		if (closestTaskMap == null)
+		if (closestTaskPair == null)
 		{
-			// FIXME concurrency issue
+			// the waitingTasks was modified while this check was running
 			return false;
 		}
-		
-		WorldGenTask closestTask = closestTaskMap.task;
+		DataSourceRetrievalTask closestTask = closestTaskPair.task;
 		
 		// remove the task we found, we are going to start it and don't want to run it multiple times
 		this.waitingTasks.remove(closestTask.pos, closestTask);
 		
 		// do we need to modify this task to generate it?
-		if (this.canGeneratePos(closestTask.pos))
+		if (this.canGenerateDetailLevel(DhSectionPos.getDetailLevel(closestTask.pos)))
 		{
 			// detail level is correct for generation, start generation
 			
-			WorldGenTaskGroup closestTaskGroup = new WorldGenTaskGroup(closestTask.pos, (byte)(closestTask.pos - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL));
-			closestTaskGroup.worldGenTasks.add(closestTask);
-			
-			if (!this.inProgressGenTasksByLodPos.containsKey(closestTask.pos))
+			DataSourceRetrievalTask existingTask = this.inProgressGenTasksByLodPos.get(closestTask.pos);
+			if (existingTask == null)
 			{
 				// no task exists for this position, start one
-				InProgressWorldGenTaskGroup newTaskGroup = new InProgressWorldGenTaskGroup(closestTaskGroup);
-				boolean taskStarted = this.tryStartingWorldGenTaskGroup(newTaskGroup);
-				if (!taskStarted)
-				{
-					//LOGGER.trace("Unable to start task: "+closestTask.pos+", skipping. Task position may have already been generated.");
-				}
+				this.startWorldGenTaskGroup(closestTask);
 			}
 			else
 			{
-				// TODO replace the previous inProgress task if one exists
-				// Note: Due to concurrency reasons, even if the currently running task is compatible with 
-				// 		   the newly selected task, we cannot use it,
-				//         as some chunks may have already been written into.
+				// shouldn't normally happen, but if
+				// we somehow queued the same task twice:
+				// merge the two futures so they both complete
 				
-				//LOGGER.trace("A task already exists for this position, todo: "+closestTask.pos);
+				existingTask.future.thenApply((DataSourceRetrievalResult result)->
+				{
+					closestTask.future.complete(result);
+					return closestTask.future; // return value ignored
+				});
+				existingTask.future.exceptionally((Throwable throwable)->
+				{
+					closestTask.future.completeExceptionally(throwable);
+					return null; // return value ignored
+				});
 			}
-			
-			// a task has been started
-			return true;
 		}
 		else
 		{
 			// detail level is too high (if the detail level was too low, the generator would've ignored the request),
 			// split up the task
 			
-			
-			// split up the task and add each one to the tree
-			LinkedList<CompletableFuture<WorldGenResult>> childFutures = new LinkedList<>();
-			long sectionPos = closestTask.pos;
-			WorldGenTask finalClosestTask = closestTask;
-			DhSectionPos.forEachChild(sectionPos, (childDhSectionPos) ->
-			{
-				CompletableFuture<WorldGenResult> newFuture = new CompletableFuture<>();
-				childFutures.add(newFuture);
-				
-				WorldGenTask newGenTask = new WorldGenTask(childDhSectionPos, DhSectionPos.getDetailLevel(childDhSectionPos), finalClosestTask.taskTracker, newFuture);
-				this.waitingTasks.put(newGenTask.pos, newGenTask);
-			});
-			
-			// send the child futures to the future recipient, to notify them of the new tasks
-			closestTask.future.complete(WorldGenResult.CreateSplit(childFutures));
-			
-			// return true so we attempt to generate again
-			return true;
+			closestTask.future.complete(DataSourceRetrievalResult.CreateSplit());
 		}
-	}
-	/** @return true if the task was started, false otherwise */
-	private boolean tryStartingWorldGenTaskGroup(InProgressWorldGenTaskGroup newTaskGroup)
-	{
-		byte taskDetailLevel = newTaskGroup.group.dataDetail;
-		long taskPos = newTaskGroup.group.pos;
-		LodUtil.assertTrue(taskDetailLevel >= this.highestDataDetail && taskDetailLevel <= this.lowestDataDetail);
 		
-		int generationRequestChunkWidthCount = BitShiftUtil.powerOfTwo(DhSectionPos.getDetailLevel(taskPos) - taskDetailLevel - 4); // minus 4 is equal to dividing by 16 to convert to chunk scale
+		
+		// a task has been started or queued,
+		// queue another task
+		return true;
+	}
+	private boolean canGenerateDetailLevel(byte taskDetailLevel)
+	{
+		byte requestedDetailLevel = (byte) (taskDetailLevel - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL);
+		return (this.highestDataDetail <= requestedDetailLevel && requestedDetailLevel <= this.lowestDataDetail);
+	}
+	private void startWorldGenTaskGroup(DataSourceRetrievalTask worldGenTask)
+	{
+		long taskPos = worldGenTask.pos;
+		LodUtil.assertTrue(
+			worldGenTask.requestDetailLevel >= this.highestDataDetail 
+			&& worldGenTask.requestDetailLevel <= this.lowestDataDetail,
+			"World gen task started that isn't within the range that the generator can create.");
 		
 		long generationStartMsTime = System.currentTimeMillis();
-		CompletableFuture<Void> generationFuture = this.startGenerationEvent(taskPos, taskDetailLevel, generationRequestChunkWidthCount, newTaskGroup.group::consumeDataSource);
+		CompletableFuture<FullDataSourceV2> generationFuture = this.startGenerationEvent(worldGenTask);
+		
+		// calculate generation speed
 		generationFuture.thenRun(() -> 
 		{
 			long totalGenTimeInMs = System.currentTimeMillis() - generationStartMsTime;
-			int chunkCount = generationRequestChunkWidthCount * generationRequestChunkWidthCount;
+			int chunkCount = worldGenTask.widthInChunks * worldGenTask.widthInChunks;
 			double timePerChunk = (double)totalGenTimeInMs / (double)chunkCount;
-			this.rollingAverageChunkGenTimeInMs.addValue(timePerChunk);
+			this.rollingAverageChunkGenTimeInMs.add(timePerChunk);
 		});
 		
-		newTaskGroup.genFuture = generationFuture;
-		LodUtil.assertTrue(newTaskGroup.genFuture != null);
-		
-		newTaskGroup.genFuture.whenComplete((voidObj, exception) ->
+		generationFuture.handle((FullDataSourceV2 fullDataSource, Throwable exception) ->
 		{
 			try
 			{
 				if (exception != null)
 				{
 					// don't log the shutdown exceptions
-					if (!LodUtil.isInterruptOrReject(exception))
+					if (!ExceptionUtil.isInterruptOrReject(exception))
 					{
 						LOGGER.error("Error generating data for pos: " + DhSectionPos.toString(taskPos), exception);
 					}
 					
-					newTaskGroup.group.worldGenTasks.forEach(worldGenTask -> worldGenTask.future.complete(WorldGenResult.CreateFail()));
+					LodUtil.assertTrue(fullDataSource == null);
+					worldGenTask.future.completeExceptionally(exception);
 				}
 				else
 				{
-					newTaskGroup.group.worldGenTasks.forEach(worldGenTask -> worldGenTask.future.complete(WorldGenResult.CreateSuccess(taskPos)));
+					boolean taskRemoved = this.inProgressGenTasksByLodPos.remove(taskPos, worldGenTask);
+					LodUtil.assertTrue(taskRemoved, "Unable to find in progress generator task with position ["+DhSectionPos.toString(taskPos)+"]");
+					
+					worldGenTask.future.complete(DataSourceRetrievalResult.CreateSuccess(taskPos, fullDataSource));
 				}
-				boolean worked = this.inProgressGenTasksByLodPos.remove(taskPos, newTaskGroup);
-				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 at pos: ["+DhSectionPos.toString(taskPos)+"].", e);
+				worldGenTask.future.completeExceptionally(e);
 			}
 			finally
 			{
 				this.tryQueueNewWorldGenRequestsAsync();
 			}
+			
+			return null;
 		});
-		
-		this.inProgressGenTasksByLodPos.put(taskPos, newTaskGroup);
-		return true;
 	}
-	private CompletableFuture<Void> startGenerationEvent(
-		long requestPos, 
-		byte targetDataDetail,
-		int generationRequestChunkWidthCount,
-		Consumer<FullDataSourceV2> dataSourceConsumer
-		)
+	private CompletableFuture<FullDataSourceV2> startGenerationEvent(DataSourceRetrievalTask task)
 	{
-		DhChunkPos chunkPosMin = new DhChunkPos(DhSectionPos.getSectionBBoxPos(requestPos).getCornerBlockPos());
+		this.inProgressGenTasksByLodPos.put(task.pos, task);
+		
+		DhChunkPos chunkPosMin = new DhChunkPos(new DhBlockPos2D(DhSectionPos.getMinCornerBlockX(task.pos), DhSectionPos.getMinCornerBlockZ(task.pos)));
 		
 		EDhApiDistantGeneratorMode generatorMode = Config.Common.WorldGenerator.distantGeneratorMode.get();
 		EDhApiWorldGeneratorReturnType returnType = this.generator.getReturnType();
 		switch (returnType) 
 		{
 			case VANILLA_CHUNKS: 
-			{
-				return this.generator.generateChunks(
-					chunkPosMin.getX(), chunkPosMin.getZ(),
-					generationRequestChunkWidthCount,
-					targetDataDetail,
-					generatorMode,
-					ThreadPoolUtil.getWorldGenExecutor(),
-					(Object[] generatedObjectArray) -> 
-					{
-						try
-						{
-							IChunkWrapper chunkWrapper = WRAPPER_FACTORY.createChunkWrapper(generatedObjectArray);
-							
-							// TODO light data should be pulled (if possible) from the ChunkAccess object itself via ChunkFileReader.readLight
-							// but this should work for now
-							ArrayList<IChunkWrapper> nearbyChunkList = new ArrayList<IChunkWrapper>();
-							nearbyChunkList.add(chunkWrapper);
-							DhLightingEngine.INSTANCE.bakeChunkBlockLighting(chunkWrapper, nearbyChunkList, this.level.getLevelWrapper().hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT);
-							
-							try (FullDataSourceV2 dataSource = LodDataBuilder.createFromChunk(this.level.getLevelWrapper(), chunkWrapper))
-							{
-								LodUtil.assertTrue(dataSource != null);
-								dataSourceConsumer.accept(dataSource);
-							}
-						}
-						catch (ClassCastException e)
-						{
-							LOGGER.error("World generator return type incorrect. Error: [" + e.getMessage() + "]. World generator disabled.", e);
-							Config.Common.WorldGenerator.enableDistantGeneration.set(false);
-						}
-						catch (Exception e)
-						{
-							LOGGER.error("Unexpected world generator error. Error: [" + e.getMessage() + "]. World generator disabled.", e);
-							Config.Common.WorldGenerator.enableDistantGeneration.set(false);
-						}
-					}
-				);
+			{	
+				return this.startVanillaChunkGenerationEvent(task, chunkPosMin, generatorMode);
 			}
 			case API_CHUNKS: 
 			{
-				return this.generator.generateApiChunks(
-					chunkPosMin.getX(), chunkPosMin.getZ(),
-					generationRequestChunkWidthCount,
-					targetDataDetail,
-					generatorMode,
-					ThreadPoolUtil.getWorldGenExecutor(),
-					(DhApiChunk dataPoints) ->
-					{
-						try(FullDataSourceV2 dataSource = LodDataBuilder.createFromApiChunkData(dataPoints, this.generator.runApiValidation()))
-						{
-							dataSourceConsumer.accept(dataSource);
-						}
-						catch (DataCorruptedException | IllegalArgumentException e)
-						{
-							LOGGER.error("World generator returned a corrupt chunk. Error: [" + e.getMessage() + "]. World generator disabled.", e);
-							Config.Common.WorldGenerator.enableDistantGeneration.set(false);
-						}
-						catch (ClassCastException e)
-						{
-							LOGGER.error("World generator return type incorrect. Error: [" + e.getMessage() + "]. World generator disabled.", e);
-							Config.Common.WorldGenerator.enableDistantGeneration.set(false);
-						}
-					}
-				);
+				return this.startApiChunkGenerationEvent(task, chunkPosMin, generatorMode);
 			}
 			case API_DATA_SOURCES:
 			{
-				// done to reduce GC overhead
-				FullDataSourceV2 pooledDataSource = FullDataSourceV2.createEmpty(requestPos);
-				// set here so the API user doesn't have to pass in this value anywhere themselves
-				pooledDataSource.setRunApiChunkValidation(this.generator.runApiValidation());
-				
-				// only apply to children if we aren't at the bottom of the tree
-				
-				pooledDataSource.applyToChildren = DhSectionPos.getDetailLevel(pooledDataSource.getPos()) > DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL;
-				pooledDataSource.applyToParent = DhSectionPos.getDetailLevel(pooledDataSource.getPos()) < DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL + 12;
-				
-				
-				return this.generator.generateLod(
-						chunkPosMin.getX(), chunkPosMin.getZ(),
-						DhSectionPos.getX(requestPos), DhSectionPos.getZ(requestPos),
-						(byte) (DhSectionPos.getDetailLevel(requestPos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL),
-						pooledDataSource,
-						generatorMode,
-						ThreadPoolUtil.getWorldGenExecutor(),
-						(IDhApiFullDataSource apiDataSource) ->
-						{
-							try
-							{
-								FullDataSourceV2 fullDataSource = (FullDataSourceV2) apiDataSource;
-								try
-								{
-									dataSourceConsumer.accept(fullDataSource);
-								}
-								finally
-								{
-									fullDataSource.close();
-								}
-							}
-							catch (IllegalArgumentException e)
-							{
-								LOGGER.error("World generator returned a corrupt data source. Error: [" + e.getMessage() + "]. World generator disabled.", e);
-								Config.Common.WorldGenerator.enableDistantGeneration.set(false);
-							}
-							catch (ClassCastException e)
-							{
-								LOGGER.error("World generator return type incorrect. Error: [" + e.getMessage() + "]. World generator disabled.", e);
-								Config.Common.WorldGenerator.enableDistantGeneration.set(false);
-							}
-						}
-				);
+				return this.startApiDataSourceGenerationEvent(task, chunkPosMin, generatorMode);
 			}
 			default: 
 			{
@@ -518,30 +416,181 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 			}
 		}
 	}
+	private CompletableFuture<FullDataSourceV2> startVanillaChunkGenerationEvent(
+		DataSourceRetrievalTask task, DhChunkPos chunkPosMin, EDhApiDistantGeneratorMode generatorMode)
+	{
+		final CompletableFuture<FullDataSourceV2> returnFuture = new CompletableFuture<>();
+		
+		ArrayList<IChunkWrapper> generatedChunks = new ArrayList<>(task.widthInChunks * task.widthInChunks);
+		
+		CompletableFuture<Void> chunkGenFuture = this.generator.generateChunks(
+			chunkPosMin.getX(), chunkPosMin.getZ(),
+			task.widthInChunks,
+			task.requestDetailLevel,
+			generatorMode,
+			ThreadPoolUtil.getWorldGenExecutor(),
+			(Object[] generatedObjectArray) ->
+			{
+				try
+				{
+					IChunkWrapper chunkWrapper = WRAPPER_FACTORY.createChunkWrapper(generatedObjectArray);
+					generatedChunks.add(chunkWrapper);
+				}
+				catch (ClassCastException e)
+				{
+					LOGGER.error("World generator return type incorrect. Error: [" + e.getMessage() + "]. World generator disabled.", e);
+					Config.Common.WorldGenerator.enableDistantGeneration.set(false);
+				}
+				catch (Exception e)
+				{
+					LOGGER.error("Unexpected world generator error. Error: [" + e.getMessage() + "]. World generator disabled.", e);
+					Config.Common.WorldGenerator.enableDistantGeneration.set(false);
+				}
+			}
+		);
+		
+		chunkGenFuture.exceptionally((throwable) ->
+		{
+			returnFuture.completeExceptionally(throwable);
+			return null;
+		});
+		chunkGenFuture.thenRun(() ->
+		{
+			FullDataSourceV2 requestedDataSource = FullDataSourceV2.createEmpty(task.pos);
+			
+			// process chunks //
+			for (int i = 0; i < generatedChunks.size(); i++)
+			{
+				IChunkWrapper chunkWrapper = generatedChunks.get(i);
+				
+				// only light the chunk here if necessary,
+				// lighting before this point is preferred but for legacy API use this
+				// check should be done
+				if (!chunkWrapper.isDhBlockLightingCorrect())
+				{
+					ArrayList<IChunkWrapper> nearbyChunkList = new ArrayList<>();
+					nearbyChunkList.add(chunkWrapper);
+					byte maxSkyLight = this.level.getLevelWrapper().hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT;
+					DhLightingEngine.INSTANCE.bakeChunkBlockLighting(chunkWrapper, nearbyChunkList, maxSkyLight);
+				}
+				
+				try (FullDataSourceV2 generatedDataSource = LodDataBuilder.createFromChunk(this.level.getLevelWrapper(), chunkWrapper))
+				{
+					LodUtil.assertTrue(generatedDataSource != null);
+					requestedDataSource.updateFromDataSource(generatedDataSource);
+				}
+			}
+			
+			DhLightingEngine.INSTANCE.bakeDataSourceSkyLight(requestedDataSource, LodUtil.MAX_MC_LIGHT);
+			returnFuture.complete(requestedDataSource);
+		});
+		
+		return returnFuture;
+	}
+	private CompletableFuture<FullDataSourceV2> startApiChunkGenerationEvent(
+		DataSourceRetrievalTask task,  DhChunkPos chunkPosMin, EDhApiDistantGeneratorMode generatorMode)
+	{
+		final CompletableFuture<FullDataSourceV2> returnFuture = new CompletableFuture<>();
+		
+		ArrayList<DhApiChunk> generatedChunks = new ArrayList<>(task.widthInChunks * task.widthInChunks);
+		
+		CompletableFuture<Void> chunkGenFuture = this.generator.generateApiChunks(
+			chunkPosMin.getX(), chunkPosMin.getZ(),
+			task.widthInChunks,
+			task.requestDetailLevel,
+			generatorMode,
+			ThreadPoolUtil.getWorldGenExecutor(),
+			(DhApiChunk apiChunk) -> { generatedChunks.add(apiChunk); }
+		);
+		
+		
+		chunkGenFuture.exceptionally((throwable) ->
+		{
+			returnFuture.completeExceptionally(throwable);
+			return null;
+		});
+		chunkGenFuture.thenRun(() ->
+		{
+			FullDataSourceV2 requestedDataSource = FullDataSourceV2.createEmpty(task.pos);
+			
+			for (int i = 0; i < generatedChunks.size(); i++)
+			{
+				DhApiChunk apiChunk = generatedChunks.get(i);
+				
+				try(FullDataSourceV2 generatedDataSource = LodDataBuilder.createFromApiChunkData(apiChunk, this.generator.runApiValidation()))
+				{
+					requestedDataSource.updateFromDataSource(generatedDataSource);
+				}
+				catch (DataCorruptedException | IllegalArgumentException e)
+				{
+					LOGGER.error("World generator returned a corrupt API chunk. Error: [" + e.getMessage() + "]. World generator disabled.", e);
+					Config.Common.WorldGenerator.enableDistantGeneration.set(false);
+				}
+			}
+			
+			returnFuture.complete(requestedDataSource);
+		});
+		
+		return returnFuture;
+	}
+	private CompletableFuture<FullDataSourceV2> startApiDataSourceGenerationEvent(
+		DataSourceRetrievalTask task, DhChunkPos chunkPosMin, EDhApiDistantGeneratorMode generatorMode)
+	{
+		final CompletableFuture<FullDataSourceV2> returnFuture = new CompletableFuture<>();
+		
+		
+		// done to reduce GC overhead
+		FullDataSourceV2 pooledDataSource = FullDataSourceV2.createEmpty(task.pos);
+		// set here so the API user doesn't have to pass in this value anywhere themselves
+		pooledDataSource.setRunApiSetterValidation(this.generator.runApiValidation());
+		
+		// only apply to children if we aren't at the bottom of the tree
+		pooledDataSource.applyToChildren = DhSectionPos.getDetailLevel(pooledDataSource.getPos()) > DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL;
+		pooledDataSource.applyToParent = DhSectionPos.getDetailLevel(pooledDataSource.getPos()) < DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL + 12; // TODO what does this 12 reference?
+		
+		CompletableFuture<Void> lodGenFuture = this.generator.generateLod(
+			chunkPosMin.getX(), chunkPosMin.getZ(),
+			DhSectionPos.getX(task.pos), DhSectionPos.getZ(task.pos),
+			(byte) (DhSectionPos.getDetailLevel(task.pos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL),
+			pooledDataSource,
+			generatorMode,
+			ThreadPoolUtil.getWorldGenExecutor(),
+			(IDhApiFullDataSource apiDataSource) -> { }
+		);
+		
+		
+		lodGenFuture.exceptionally((throwable) ->
+		{
+			returnFuture.completeExceptionally(throwable);
+			pooledDataSource.close();
+			return null;
+		});
+		lodGenFuture.thenRun(() ->
+		{
+			returnFuture.complete(pooledDataSource);
+		});
+		
+		return returnFuture;
+	}
 	
 	
 	
 	//===================//
 	// getters / setters //
 	//===================//
+	///region getters/setters
 	
 	@Override public int getWaitingTaskCount() { return this.waitingTasks.size(); }
 	@Override public int getInProgressTaskCount() { return this.inProgressGenTasksByLodPos.size(); }
 	
-	@Override
-	public byte lowestDataDetail() { return this.lowestDataDetail; }
-	@Override
-	public byte highestDataDetail() { return this.highestDataDetail; }
+	@Override public byte lowestDataDetail() { return this.lowestDataDetail; }
+	@Override public byte highestDataDetail() { return this.highestDataDetail; }
 	
-	@Override
-	public int getEstimatedRemainingTaskCount() { return this.estimatedRemainingTaskCount; }
-	@Override
-	public void setEstimatedRemainingTaskCount(int newEstimate) { this.estimatedRemainingTaskCount = newEstimate; }
+	@Override public int getEstimatedRemainingTaskCount() { return this.estimatedRemainingTaskCount; }
+	@Override public void setEstimatedRemainingTaskCount(int newEstimate) { this.estimatedRemainingTaskCount = newEstimate; }
 	
-	@Override
-	public int getRetrievalEstimatedRemainingChunkCount() { return this.estimatedRemainingChunkCount; }
-	@Override
-	public void setRetrievalEstimatedRemainingChunkCount(int newEstimate) { this.estimatedRemainingChunkCount = newEstimate; }
+	@Override public int getRetrievalEstimatedRemainingChunkCount() { return this.estimatedRemainingChunkCount; }
+	@Override public void setRetrievalEstimatedRemainingChunkCount(int newEstimate) { this.estimatedRemainingChunkCount = newEstimate; }
 	
 	@Override 
 	public void addDebugMenuStringsToList(List<String> messageList) { }
@@ -559,13 +608,55 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		return chunkCount;
 	}
 	
+	///endregion getters/setters
+	
+	
+	
+	//=======//
+	// debug //
+	//=======//
+	///region debug
+	
+	@Override
+	public void debugRender(DebugRenderer renderer)
+	{
+		int levelMinY = this.level.getLevelWrapper().getMinHeight();
+		int levelMaxY = this.level.getLevelWrapper().getMaxHeight();
+		
+		// show the wireframe a bit lower than world max height,
+		// since most worlds don't render all the way up to the max height
+		int levelHeightRange = (levelMaxY - levelMinY);
+		int maxY = levelMaxY - (levelHeightRange / 2);
+		
+		
+		// blue - queued
+		this.waitingTasks.keySet().forEach((Long pos) -> 
+		{ 
+			renderer.renderBox(
+				new DebugRenderer.Box(pos, levelMinY, maxY, 0.05f, Color.blue)
+			); 
+		});
+		
+		// red - in progress
+		this.inProgressGenTasksByLodPos.forEach((Long pos, DataSourceRetrievalTask task) -> 
+		{ 
+			renderer.renderBox(
+				new DebugRenderer.Box(pos, levelMinY, maxY, 0.05f, Color.red)
+			); 
+		});
+	}
+	
+	///endregion debug
+	
 	
 	
 	//==========//
 	// shutdown //
 	//==========//
+	///region shutdown
 	
-	@Override public CompletableFuture<Void> startClosingAsync(boolean cancelCurrentGeneration, boolean alsoInterruptRunning)
+	@Override
+	public CompletableFuture<Void> startClosingAsync(boolean cancelCurrentGeneration, boolean alsoInterruptRunning)
 	{
 		LOGGER.info("Closing world gen queue");
 		this.queueingThread.shutdownNow();
@@ -573,32 +664,32 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		
 		// stop and remove any in progress tasks
 		ArrayList<CompletableFuture<Void>> inProgressTasksCancelingFutures = new ArrayList<>(this.inProgressGenTasksByLodPos.size());
-		this.inProgressGenTasksByLodPos.values().forEach(runningTaskGroup ->
+		this.inProgressGenTasksByLodPos.values().forEach((DataSourceRetrievalTask genTask) ->
 		{
-			CompletableFuture<Void> genFuture = runningTaskGroup.genFuture; // Do this to prevent it getting swapped out
-			if (genFuture == null)
-			{
-				// genFuture's shouldn't be null, but sometimes they are...
-				LOGGER.info("Null gen future: "+runningTaskGroup.group.pos);
-				return;
-			}
-			
+			CompletableFuture<DataSourceRetrievalResult> genFuture = genTask.future;
 			
 			if (cancelCurrentGeneration)
 			{
 				genFuture.cancel(alsoInterruptRunning);
 			}
 			
-			inProgressTasksCancelingFutures.add(genFuture.handle((voidObj, exception) ->
+			inProgressTasksCancelingFutures.add(genFuture.handle((DataSourceRetrievalResult result, Throwable throwable) ->
 			{
-				if (exception instanceof CompletionException)
+				if (throwable instanceof CompletionException)
 				{
-					exception = exception.getCause();
+					throwable = throwable.getCause();
 				}
 				
-				if (!UncheckedInterruptedException.isInterrupt(exception) && !(exception instanceof CancellationException))
+				if (!UncheckedInterruptedException.isInterrupt(throwable)
+					&& !(throwable instanceof CancellationException))
 				{
-					LOGGER.error("Error when terminating data generation for section " + runningTaskGroup.group.pos, exception);
+					LOGGER.error("Error when terminating data generation for pos: ["+DhSectionPos.toString(genTask.pos)+"], error: ["+throwable.getMessage()+"].", throwable);
+				}
+				
+				if (result != null 
+					&& result.dataSource != null)
+				{
+					result.dataSource.close();
 				}
 				
 				return null;
@@ -623,13 +714,17 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		
 		LOGGER.info("Shutting down world generator thread pool...");
 		
-		AbstractExecutorService executor = ThreadPoolUtil.getWorldGenExecutor();
+		PriorityTaskPicker.Executor executor = ThreadPoolUtil.getWorldGenExecutor();
 		if (executor != null)
 		{
-			List<Runnable> tasks = executor.shutdownNow();
-			LOGGER.info("World generator thread pool shutdown with [" + tasks.size() + "] incomplete tasks.");
+			int queueSize = executor.getQueueSize();
+			executor.clearQueue();
+			LOGGER.info("World generator thread pool shutdown with [" + queueSize + "] incomplete tasks.");
 		}
 		
+		this.inProgressGenTasksByLodPos.values().forEach((inProgressWorldGenTaskGroup) -> inProgressWorldGenTaskGroup.future.cancel(true));
+		this.waitingTasks.values().forEach((worldGenTask) -> worldGenTask.future.cancel(true));
+		
 		
 		this.generator.close();
 		DebugRenderer.unregister(this, Config.Client.Advanced.Debugging.DebugWireframe.showWorldGenQueue);
@@ -648,62 +743,22 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		LOGGER.info("Finished closing " + WorldGenerationQueue.class.getSimpleName());
 	}
 	
-	
-	
-	//=======//
-	// debug //
-	//=======//
-	
-	@Override
-	public void debugRender(DebugRenderer renderer)
-	{
-		int levelMinY = this.level.getLevelWrapper().getMinHeight();
-		int levelMaxY = this.level.getLevelWrapper().getMaxHeight();
-		
-		// show the wireframe a bit lower than world max height,
-		// since most worlds don't render all the way up to the max height
-		int levelHeightRange = (levelMaxY - levelMinY);
-		int maxY = levelMaxY - (levelHeightRange / 2);
-		
-		
-		// blue - queued
-		this.waitingTasks.keySet().forEach((pos) -> 
-		{ 
-			renderer.renderBox(
-					new DebugRenderer.Box(pos, levelMinY, maxY, 0.05f, Color.blue)); 
-		});
-		
-		// red - in progress
-		this.inProgressGenTasksByLodPos.forEach((pos, t) -> 
-		{ 
-			renderer.renderBox(
-					new DebugRenderer.Box(pos, levelMinY, maxY, 0.05f, Color.red)); 
-		});
-	}
-	
-	
-	
-	//================//
-	// helper methods //
-	//================//
-	
-	private boolean canGeneratePos(long taskPos)
-	{
-		byte requestedDetailLevel = (byte) (DhSectionPos.getDetailLevel(taskPos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL);
-		return (this.highestDataDetail <= requestedDetailLevel && requestedDetailLevel <= this.lowestDataDetail);
-	}
+	///endregion shutdown
 	
 	
 	
 	//================//
 	// helper classes //
 	//================//
+	///region helper classes
 	
-	private static class Mapper
+	/** Used during task starting to determine the closest task */
+	private static class TaskDistancePair
 	{
-		public final WorldGenTask task;
+		public final DataSourceRetrievalTask task;
 		public final int dist;
-		public Mapper(WorldGenTask task, int dist)
+		
+		public TaskDistancePair(DataSourceRetrievalTask task, int dist)
 		{
 			this.task = task;
 			this.dist = dist;
@@ -711,4 +766,8 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		
 	}
 	
+	///endregion helper classes
+	
+	
+	
 }

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

@@ -20,20 +20,33 @@
 package com.seibel.distanthorizons.core.generation.tasks;
 
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
-
-import javax.annotation.Nullable;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
+import org.jetbrains.annotations.Nullable;
 
 /**
- * @author Leetom
- * @version 2022-11-25
+ * @see DataSourceRetrievalTask
  */
-public interface IWorldGenTaskTracker
+public class DataSourceRetrievalResult
 {
+	public final ERetrievalResultState state;
+	/** the position that was generated, will be null if nothing was generated */
+	public final long pos;
 	@Nullable
-	Consumer<FullDataSourceV2> getDataSourceConsumer();
+	public final FullDataSourceV2 dataSource;
+	
+	
+	
+	//==============//
+ 	// constructors //
+	//==============//
+	
+	public static DataSourceRetrievalResult CreateSplit() { return new DataSourceRetrievalResult(ERetrievalResultState.REQUIRES_SPLITTING, 0, null); }
+	public static DataSourceRetrievalResult CreateSuccess(long pos, FullDataSourceV2 generatedDataSource) { return new DataSourceRetrievalResult(ERetrievalResultState.SUCCESS, pos, generatedDataSource); }
+	private DataSourceRetrievalResult(ERetrievalResultState state, long pos, @Nullable FullDataSourceV2 dataSource)
+	{
+		this.state = state;
+		this.pos = pos;
+		this.dataSource = dataSource;
+	}
 	
-	CompletableFuture<Boolean> shouldGenerateSplitChild(long pos);
 	
 }

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

@@ -19,29 +19,37 @@
 
 package com.seibel.distanthorizons.core.generation.tasks;
 
-import com.seibel.distanthorizons.core.file.fullDatafile.GeneratedFullDataSourceProvider;
+import com.seibel.distanthorizons.core.pos.DhSectionPos;
+import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
 
 import java.util.concurrent.CompletableFuture;
 
 /**
- * @author Leetom
- * @version 2022-11-25
+ * @see DataSourceRetrievalResult
  */
-public final class WorldGenTask
+public final class DataSourceRetrievalTask
 {
 	public final long pos;
-	public final byte dataDetailLevel;
-	public final IWorldGenTaskTracker taskTracker;
-	public final CompletableFuture<WorldGenResult> future;
+	/** 
+	 * Usually the same as {@link DataSourceRetrievalTask#pos}, but
+	 * can differ if the task needs something different.
+	 */
+	public final byte requestDetailLevel;
+	public final int widthInChunks;
+	
+	public final CompletableFuture<DataSourceRetrievalResult> future = new CompletableFuture<>();
 	
 	
 	
-	public WorldGenTask(long pos, byte dataDetail, IWorldGenTaskTracker taskTracker, CompletableFuture<WorldGenResult> future)
+	//=============//
+ 	// constructor //
+	//=============//
+	
+	public DataSourceRetrievalTask(long pos, byte dataDetail)
 	{
-		this.dataDetailLevel = dataDetail;
 		this.pos = pos;
-		this.taskTracker = taskTracker;
-		this.future = future;
+		this.requestDetailLevel = dataDetail;
+		this.widthInChunks = BitShiftUtil.powerOfTwo(DhSectionPos.getDetailLevel(this.pos) - this.requestDetailLevel - 4); // minus 4 is equal to dividing by 16 to convert to chunk scale 
 	}
 	
 }

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

@@ -0,0 +1,13 @@
+package com.seibel.distanthorizons.core.generation.tasks;
+
+/**
+ * SUCCESS <br>
+ * REQUIRES_SPLITTING <br>
+ * 
+ * @see DataSourceRetrievalResult
+ */
+public enum ERetrievalResultState
+{
+	SUCCESS,
+	REQUIRES_SPLITTING,
+}

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

@@ -1,51 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU 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.generation.tasks;
-
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.concurrent.CompletableFuture;
-
-public class WorldGenResult
-{
-	/** true if terrain was generated */
-	public final boolean success;
-	/** the position that was generated, will be null if nothing was generated */
-	public final long pos;
-	/** if a position is too high detail for world generator to handle it, these futures are for its 4 children positions after being split up. */
-	public final LinkedList<CompletableFuture<WorldGenResult>> childFutures = new LinkedList<>();
-	
-	
-	public static WorldGenResult CreateSplit(Collection<CompletableFuture<WorldGenResult>> siblingFutures) { return new WorldGenResult(false, 0, siblingFutures); }
-	public static WorldGenResult CreateFail() { return new WorldGenResult(false, 0, null); }
-	public static WorldGenResult CreateSuccess(long pos) { return new WorldGenResult(true, pos, null); }
-	private WorldGenResult(boolean success, long pos, Collection<CompletableFuture<WorldGenResult>> childFutures)
-	{
-		this.success = success;
-		this.pos = pos;
-		
-		if (childFutures != null)
-		{
-			this.childFutures.addAll(childFutures);
-		}
-	}
-	
-	
-}

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

@@ -1,67 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU 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.generation.tasks;
-
-import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
-
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.function.Consumer;
-
-/**
- * @author Leetom
- * @version 2022-11-25
- */
-@Deprecated // TODO look into how these are used and if they should continue to be used
-public final class WorldGenTaskGroup
-{
-	public final long pos;
-	public byte dataDetail;
-	/** Only accessed by the generator polling thread */
-	public final LinkedList<WorldGenTask> worldGenTasks = new LinkedList<>();
-	
-	
-	
-	public WorldGenTaskGroup(long pos, byte dataDetail)
-	{
-		this.pos = pos;
-		this.dataDetail = dataDetail;
-	}
-	
-	public void consumeDataSource(FullDataSourceV2 dataSource)
-	{
-		Iterator<WorldGenTask> tasks = this.worldGenTasks.iterator();
-		while (tasks.hasNext())
-		{
-			WorldGenTask task = tasks.next();
-			Consumer<FullDataSourceV2> dataSourceConsumer = task.taskTracker.getDataSourceConsumer();
-			if (dataSourceConsumer == null)
-			{
-				tasks.remove();
-				task.future.complete(WorldGenResult.CreateFail());
-			}
-			else
-			{
-				dataSourceConsumer.accept(dataSource);
-			}
-		}
-	}
-	
-}

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

@@ -23,6 +23,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV2DTO;
 import com.seibel.distanthorizons.core.sql.repo.FullDataSourceV2Repo;
+import com.seibel.distanthorizons.core.util.NativeDialogUtil;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import com.seibel.distanthorizons.core.jar.gui.BaseJFrame;
 import com.seibel.distanthorizons.core.jar.gui.cusomJObject.JBox;
@@ -31,7 +32,6 @@ import com.seibel.distanthorizons.core.jar.installer.WebDownloader;
 import org.apache.logging.log4j.LogManager;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.apache.logging.log4j.core.LoggerContext;
-import org.lwjgl.util.tinyfd.TinyFileDialogs;
 
 import javax.swing.*;
 import java.awt.*;
@@ -216,7 +216,7 @@ public class JarMain
 			{
 				repo = new FullDataSourceV2Repo(FullDataSourceV2Repo.DEFAULT_DATABASE_TYPE, dbFile);
 			}
-			catch (SQLException e)
+			catch (SQLException | IOException e)
 			{
 				LOGGER.error("Failed to initialize connection with database: ["+exportFile.getAbsolutePath()+"], error: ["+e.getMessage()+"].", e);
 				return;
@@ -441,7 +441,7 @@ public class JarMain
 		installMod.addActionListener(e -> {
 			if (minecraftDirPop.getSelectedFile() == null)
 			{
-				TinyFileDialogs.tinyfd_messageBox(ModInfo.READABLE_NAME, "Please select your install directory", "ok", "warning", false);
+				NativeDialogUtil.showDialog(ModInfo.READABLE_NAME, "Please select your install directory", "ok", "warning");
 				return;
 			}
 			
@@ -455,11 +455,11 @@ public class JarMain
 								ModInfo.NAME + "-" + ModrinthGetter.releaseNames.get(downloadID.get()) + ".jar"
 						).toFile());
 				
-				TinyFileDialogs.tinyfd_messageBox(ModInfo.READABLE_NAME, "Installation done. \nYou can now close the installer", "ok", "info", false);
+				NativeDialogUtil.showDialog(ModInfo.READABLE_NAME, "Installation done. \nYou can now close the installer", "ok", "info");
 			}
 			catch (Exception f)
 			{
-				TinyFileDialogs.tinyfd_messageBox(ModInfo.READABLE_NAME, "Download failed. Check your internet connection \nStacktrace: " + f.getMessage(), "error", "info", false);
+				NativeDialogUtil.showDialog(ModInfo.READABLE_NAME, "Download failed. Check your internet connection \nStacktrace: " + f.getMessage(), "error", "info");
 			}
 		});
 		frame.add(installMod);

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

@@ -104,7 +104,7 @@ public class JarUtils
 	 */
 	public static InputStream accessFile(String resource)
 	{
-		final ClassLoader loader = Thread.currentThread().getContextClassLoader();
+		final ClassLoader loader = JarUtils.class.getClassLoader();
 		// this is the path within the jar file
 		InputStream input = loader.getResourceAsStream(resource);
 		if (input == null)

core/src/main/java/com/seibel/distanthorizons/core/jar/installer/GitlabGetter.java

@@ -49,7 +49,7 @@ public class GitlabGetter
 	/** Commit sha; Commit info */
 	private static final Map<String, Config> commitInfo = new HashMap<>();
 	/** Pipeline ID; Pipeline info */
-	private static final Map<Integer, ArrayList<Config>> pipelineInfo = new HashMap<>();
+	private static final Map<Number, ArrayList<Config>> pipelineInfo = new HashMap<>();
 	
 	/** Uses our projectID to init this */
 	public GitlabGetter()
@@ -88,7 +88,7 @@ public class GitlabGetter
 		return commitInfo.get(commit);
 	}
 	
-	public ArrayList<Config> getPipelineInfo(int pipeline)
+	public ArrayList<Config> getPipelineInfo(Number pipeline)
 	{
 		if (!pipelineInfo.containsKey(pipeline))
 		{
@@ -111,9 +111,10 @@ public class GitlabGetter
 	/**
 	 * Gets all the Minecraft download links to a pipeline ID
 	 * 
+	 * @param pipelineID Uses {@link Number} instead of a specific value due to the possibility of receiving Integer or Long
 	 * @return Minecraft version; Download URL
 	 */
-	public Map<String, URL> getDownloads(int pipelineID)
+	public Map<String, URL> getDownloads(Number pipelineID)
 	{
 		Map<String, URL> downloads = new HashMap<>();
 		ArrayList<Config> currentPipelineInfo = this.getPipelineInfo(pipelineID);

core/src/main/java/com/seibel/distanthorizons/core/jar/updater/SelfUpdater.java

@@ -29,12 +29,12 @@ import com.seibel.distanthorizons.core.jar.installer.ModrinthGetter;
 import com.seibel.distanthorizons.core.jar.installer.WebDownloader;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.logging.f3.F3Screen;
+import com.seibel.distanthorizons.core.util.NativeDialogUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import com.seibel.distanthorizons.coreapi.util.StringUtil;
 import com.seibel.distanthorizons.coreapi.util.jar.DeleteOnUnlock;
 import com.seibel.distanthorizons.core.logging.DhLogger;
-import org.lwjgl.util.tinyfd.TinyFileDialogs;
 
 import javax.swing.*;
 import java.awt.*;
@@ -174,7 +174,7 @@ public class SelfUpdater
 		
 		if (!GitlabGetter.INSTANCE.getDownloads(pipeline.get("id")).containsKey(mcVersion))
 		{
-			LOGGER.warn("Minecraft version ["+ mcVersion +"] is not findable on Gitlab, findable versions are ["+ StringUtil.join(",", GitlabGetter.INSTANCE.getDownloads(pipeline.get("id")).keySet().toArray()) +"].");
+			LOGGER.warn("Minecraft version ["+ mcVersion +"] is not findable on Gitlab, findable versions are ["+ StringUtil.join(", ", GitlabGetter.INSTANCE.getDownloads(pipeline.get("id")).keySet().toArray()) +"].");
 			return false;
 		}
 		
@@ -258,14 +258,13 @@ public class SelfUpdater
 			
 			deleteOldJarOnJvmShutdown = true;
 			
-			// TODO one of these messages contains something TinyFd doesn't like, find it and fix it
-			String successMessage = "Distant Horizons successfully updated. It will apply on game's relaunch"; 
+			String successMessage = "Distant Horizons successfully updated. It will apply on game`s relaunch"; 
 			LOGGER.info(successMessage);
 			new Thread(() -> 
 			{
 				try
 				{
-					TinyFileDialogs.tinyfd_messageBox(ModInfo.READABLE_NAME, successMessage, "ok", "info", false);
+					NativeDialogUtil.showDialog(ModInfo.READABLE_NAME, successMessage, "ok", "info");
 				}
 				catch (Exception ignore) { }
 			}).start();
@@ -288,7 +287,7 @@ public class SelfUpdater
 			LOGGER.error(failMessage, e);
 			try
 			{
-				TinyFileDialogs.tinyfd_messageBox(ModInfo.READABLE_NAME, failMessage, "ok", "error", false);
+				NativeDialogUtil.showDialog(ModInfo.READABLE_NAME, failMessage, "ok", "error");
 			}
 			catch (Exception ignore) { }
 			
@@ -386,7 +385,7 @@ public class SelfUpdater
 			{
 				try
 				{
-					TinyFileDialogs.tinyfd_messageBox(ModInfo.READABLE_NAME, successMessage, "ok", "info", false);
+					NativeDialogUtil.showDialog(ModInfo.READABLE_NAME, successMessage, "ok", "info");
 				}
 				catch (Exception ignore) { }
 			}).start();
@@ -424,7 +423,7 @@ public class SelfUpdater
 			LOGGER.error(failMessage, e);
 			try
 			{
-				TinyFileDialogs.tinyfd_messageBox(ModInfo.READABLE_NAME, failMessage, "ok", "error", false);
+				NativeDialogUtil.showDialog(ModInfo.READABLE_NAME, failMessage, "ok", "error");
 			}
 			catch (Exception ignore) { }
 			

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

@@ -55,6 +55,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.awt.*;
 import java.io.File;
+import java.io.IOException;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -106,9 +107,9 @@ public abstract class AbstractDhLevel implements IDhLevel
 		{
 			newChunkHashRepo = new ChunkHashRepo(AbstractDhRepo.DEFAULT_DATABASE_TYPE, databaseFile);
 		}
-		catch (SQLException e)
+		catch (SQLException | IOException e)
 		{
-			LOGGER.error("Unable to create [ChunkHashRepo], error: ["+e.getMessage()+"].", e);
+			LOGGER.fatal("Unable to create ["+ChunkHashRepo.class.getSimpleName()+"], error: ["+e.getMessage()+"].", e);
 		}
 		this.chunkHashRepo = newChunkHashRepo;
 		
@@ -119,9 +120,9 @@ public abstract class AbstractDhLevel implements IDhLevel
 		{
 			newBeaconBeamRepo = new BeaconBeamRepo(AbstractDhRepo.DEFAULT_DATABASE_TYPE, databaseFile);
 		}
-		catch (SQLException e)
+		catch (SQLException | IOException e)
 		{
-			LOGGER.error("Unable to create [BeaconBeamRepo], error: ["+e.getMessage()+"].", e);
+			LOGGER.error("Unable to create ["+BeaconBeamRepo.class.getSimpleName()+"], error: ["+e.getMessage()+"].", e);
 		}
 		this.beaconBeamRepo = newBeaconBeamRepo;
 	}
@@ -191,23 +192,30 @@ public abstract class AbstractDhLevel implements IDhLevel
 		return this.updateDataSourcesAsync(fullDataSource)
 			.thenRun(() -> 
 			{
-				HashSet<DhChunkPos> updatedChunkPosSet = this.updatedChunkPosSetBySectionPos.remove(fullDataSource.getPos());
-				if (updatedChunkPosSet != null)
+				try
 				{
-					for (DhChunkPos chunkPos : updatedChunkPosSet)
+					HashSet<DhChunkPos> updatedChunkPosSet = this.updatedChunkPosSetBySectionPos.remove(fullDataSource.getPos());
+					if (updatedChunkPosSet != null)
 					{
-						// 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)
+						for (DhChunkPos chunkPos : updatedChunkPosSet)
 						{
-							this.chunkHashRepo.save(new ChunkHashDTO(chunkPos, chunkHash));
-						}
-						
-						ApiEventInjector.INSTANCE.fireAllEvents(
+							// 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.getX(), chunkPos.getZ()));
+						}
 					}
 				}
+				catch (Exception e)
+				{
+					LOGGER.error("Unexpected issue after onDataSourceSaveAsync, error: ["+e.getMessage()+"].", e);
+				}
 			});
 	}
 	

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

@@ -21,6 +21,7 @@ import com.seibel.distanthorizons.core.network.messages.requests.CancelMessage;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.util.LodUtil;
+import com.seibel.distanthorizons.core.util.WorldGenUtil;
 import com.seibel.distanthorizons.core.util.math.Vec3d;
 import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IServerPlayerWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
@@ -29,6 +30,8 @@ import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.NotNull;
 
 import javax.annotation.Nullable;
+import java.io.IOException;
+import java.sql.SQLException;
 import java.util.List;
 import java.util.concurrent.*;
 
@@ -48,23 +51,27 @@ public abstract class AbstractDhServerLevel extends AbstractDhLevel implements I
 	 */
 	protected final ConcurrentLinkedQueue<IServerPlayerWrapper> worldGenPlayerCenteringQueue = new ConcurrentLinkedQueue<>();
 	
-	private final FullDataSourceRequestHandler requestHandler = new FullDataSourceRequestHandler(this);
+	private final FullDataSourceRequestHandler requestHandler;
+	
 	
 	
 	//=============//
 	// constructor //
 	//=============//
 	
-	public AbstractDhServerLevel(ISaveStructure saveStructure, IServerLevelWrapper serverLevelWrapper, ServerPlayerStateManager serverPlayerStateManager)
-	{
-		this(saveStructure, serverLevelWrapper, serverPlayerStateManager, true);
-	}
+	public AbstractDhServerLevel(
+		ISaveStructure saveStructure, 
+		IServerLevelWrapper serverLevelWrapper, 
+		ServerPlayerStateManager serverPlayerStateManager
+		) throws SQLException, IOException
+	{ this(saveStructure, serverLevelWrapper, serverPlayerStateManager, true); }
+	
 	public AbstractDhServerLevel(
 			ISaveStructure saveStructure,
 			IServerLevelWrapper serverLevelWrapper,
 			ServerPlayerStateManager serverPlayerStateManager,
 			boolean runRepoReliantSetup
-		)
+		) throws SQLException, IOException
 	{
 		if (saveStructure.getSaveFolder(serverLevelWrapper).mkdirs())
 		{
@@ -81,6 +88,7 @@ public abstract class AbstractDhServerLevel extends AbstractDhLevel implements I
 		LOGGER.info("Started "+this.getClass().getSimpleName()+" for ["+serverLevelWrapper+"] at ["+saveStructure+"].");
 		
 		this.serverPlayerStateManager = serverPlayerStateManager;
+		this.requestHandler = new FullDataSourceRequestHandler(this);
 	}
 	
 	
@@ -89,24 +97,17 @@ public abstract class AbstractDhServerLevel extends AbstractDhLevel implements I
 	// ticks //
 	//=======//
 	
-	@Override
-	public void serverTick()
-	{
-		this.requestHandler.tick();
-	}
-	
 	@Override
 	public boolean shouldDoWorldGen()
 	{ return Config.Common.WorldGenerator.enableDistantGeneration.get() && !this.worldGenPlayerCenteringQueue.isEmpty(); }
 	
 	@Override
-	@Nullable
 	public DhBlockPos2D getTargetPosForGeneration()
 	{
 		IServerPlayerWrapper firstPlayer = this.worldGenPlayerCenteringQueue.peek();
 		if (firstPlayer == null)
 		{
-			return null;
+			return DhBlockPos2D.ZERO;
 		}
 		
 		// Put first player in back before removing from front, so it can be removed by other thread without blocking
@@ -118,9 +119,6 @@ public abstract class AbstractDhServerLevel extends AbstractDhLevel implements I
 		return new DhBlockPos2D((int) position.x, (int) position.z);
 	}
 	
-	@Override 
-	public void worldGenTick() { this.serverside.worldGenModule.worldGenTick(); }
-	
 	
 	
 	//==================//
@@ -149,16 +147,15 @@ public abstract class AbstractDhServerLevel extends AbstractDhLevel implements I
 					return;
 				}
 				
-				if (Config.Server.generationBoundsRadius.get() > 0)
+				boolean posInRange = WorldGenUtil.isPosInWorldGenRange(
+					message.sectionPos,
+					Config.Common.WorldGenerator.generationCenterChunkX.get(), Config.Common.WorldGenerator.generationCenterChunkZ.get(),
+					Config.Common.WorldGenerator.generationMaxChunkRadius.get()
+				);
+				if (!posInRange)
 				{
-					if (DhSectionPos.getChebyshevSignedBlockDistance(message.sectionPos, new DhBlockPos2D(
-							serverPlayerState.sessionConfig.getGenerationBoundsX(),
-							serverPlayerState.sessionConfig.getGenerationBoundsZ()
-					)) > Config.Server.generationBoundsRadius.get())
-					{
-						message.sendResponse(new RequestOutOfRangeException("Section out of allowed bounds"));
-						return;
-					}
+					message.sendResponse(new RequestOutOfRangeException("Section out of allowed bounds"));
+					return;
 				}
 				
 				if (!Config.Server.Experimental.enableNSizedGeneration.get() && DhSectionPos.getDetailLevel(message.sectionPos) != DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL)
@@ -297,7 +294,7 @@ public abstract class AbstractDhServerLevel extends AbstractDhLevel implements I
 	public void addDebugMenuStringsToList(List<String> messageList)
 	{
 		this.serverside.fullDataFileHandler.addDebugMenuStringsToList(messageList);
-		this.serverside.worldGenModule.addDebugMenuStringsToList(messageList);
+		this.serverside.lodRequestModule.addDebugMenuStringsToList(messageList);
 	}
 	
 	
@@ -330,7 +327,10 @@ public abstract class AbstractDhServerLevel extends AbstractDhLevel implements I
 	{
 		super.close();
 		this.serverside.close();
+		this.requestHandler.close();
 		LOGGER.info("Closed DHLevel for [" + this.getLevelWrapper() + "].");
 	}
 	
+	
+	
 }

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

@@ -49,6 +49,8 @@ import org.jetbrains.annotations.Nullable;
 import javax.annotation.CheckForNull;
 import java.awt.*;
 import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
 import java.util.*;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -83,7 +85,7 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 					.asMap()
 	);
 	
-	public final WorldGenModule worldGenModule;
+	public final LodRequestModule lodRequestModule;
 	
 	@Nullable
 	private final SyncOnLoadRequestQueue syncOnLoadRequestQueue;
@@ -94,9 +96,18 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	// constructor //
 	//=============//
 	
-	public DhClientLevel(ISaveStructure saveStructure, IClientLevelWrapper clientLevelWrapper, @Nullable ClientNetworkState networkState) 
+	public DhClientLevel(
+		ISaveStructure saveStructure, 
+		IClientLevelWrapper clientLevelWrapper, 
+		@Nullable ClientNetworkState networkState
+		) throws SQLException, IOException
 	{ this(saveStructure, clientLevelWrapper, null, networkState); }
-	public DhClientLevel(ISaveStructure saveStructure, IClientLevelWrapper clientLevelWrapper, @Nullable File fullDataSaveDirOverride, @Nullable ClientNetworkState networkState)
+	public DhClientLevel(
+		ISaveStructure saveStructure, 
+		IClientLevelWrapper clientLevelWrapper, 
+		@Nullable File fullDataSaveDirOverride, 
+		@Nullable ClientNetworkState networkState
+		) throws SQLException, IOException
 	{
 		File saveFolder = saveStructure.getSaveFolder(clientLevelWrapper);
 		File pre23Folder = saveStructure.getPre23SaveFolder(clientLevelWrapper);
@@ -131,7 +142,7 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 		}
 		
 		this.remoteDataSourceProvider = new RemoteFullDataSourceProvider(this, saveStructure, fullDataSaveDirOverride, this.syncOnLoadRequestQueue);
-		this.worldGenModule = new WorldGenModule(this, this.remoteDataSourceProvider, () -> new WorldGenState(this, networkState));
+		this.lodRequestModule = new LodRequestModule(this,this, this.remoteDataSourceProvider, () -> new LodRequestState(this, networkState));
 		
 		this.clientside = new ClientLevelModule(this);
 		
@@ -236,14 +247,8 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	}
 	
 	@Override
-	@Nullable
 	public DhBlockPos2D getTargetPosForGeneration() { return new DhBlockPos2D(MC_CLIENT.getPlayerBlockPos()); }
 	
-	@Override
-	public void worldGenTick() { this.worldGenModule.worldGenTick(); }
-	
-	public void startRenderer() { this.clientside.startRenderer(); }
-	
 	
 	
 	//===========//
@@ -253,13 +258,6 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	@Override
 	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);
 	}
 	
@@ -325,7 +323,7 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 		
 		
 		// world gen
-		this.worldGenModule.addDebugMenuStringsToList(messageList);
+		this.lodRequestModule.addDebugMenuStringsToList(messageList);
 		if (this.syncOnLoadRequestQueue != null)
 		{
 			assert this.networkState != null;
@@ -348,9 +346,9 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	@Override
 	public void close()
 	{
-		if (this.worldGenModule != null)
+		if (this.lodRequestModule != null)
 		{
-			this.worldGenModule.close();
+			this.lodRequestModule.close();
 		}
 		
 		if (this.networkEventSource != null)
@@ -371,11 +369,11 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	// helper classes //
 	//================//
 	
-	private static class WorldGenState extends WorldGenModule.AbstractWorldGenState
+	private static class LodRequestState extends LodRequestModule.AbstractLodRequestState
 	{
-		WorldGenState(DhClientLevel level, ClientNetworkState networkState)
+		LodRequestState(DhClientLevel clientLevel, ClientNetworkState networkState)
 		{
-			this.worldGenerationQueue = new RemoteWorldRetrievalQueue(networkState, level);
+			this.retrievalQueue = new RemoteWorldRetrievalQueue(networkState, clientLevel);
 		}
 	}
 	

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

@@ -33,6 +33,8 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapp
 import org.jetbrains.annotations.Nullable;
 
 import java.awt.*;
+import java.io.IOException;
+import java.sql.SQLException;
 import java.util.List;
 
 /** The level used for a singleplayer world */
@@ -48,7 +50,11 @@ public class DhClientServerLevel extends AbstractDhServerLevel implements IDhCli
 	// constructor //
 	//=============//
 	
-	public DhClientServerLevel(ISaveStructure saveStructure, IServerLevelWrapper serverLevelWrapper, ServerPlayerStateManager serverPlayerStateManager)
+	public DhClientServerLevel(
+		ISaveStructure saveStructure, 
+		IServerLevelWrapper serverLevelWrapper, 
+		ServerPlayerStateManager serverPlayerStateManager
+		) throws SQLException, IOException
 	{
 		super(saveStructure, serverLevelWrapper, serverPlayerStateManager, false);
 		
@@ -126,14 +132,6 @@ public class DhClientServerLevel extends AbstractDhServerLevel implements IDhCli
 	public void onWorldGenTaskComplete(long pos)
 	{
 		super.onWorldGenTaskComplete(pos);
-		
-		DebugRenderer.makeParticle(
-				new DebugRenderer.BoxParticle(
-						new DebugRenderer.Box(pos, 128f, 156f, 0.09f, Color.red.darker()),
-						0.2, 32f
-				)
-		);
-		
 		this.clientside.reloadPos(pos);
 	}
 	

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

@@ -27,6 +27,8 @@ import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRend
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.sql.SQLException;
 import java.util.List;
 
 public class DhServerLevel extends AbstractDhServerLevel
@@ -35,10 +37,12 @@ public class DhServerLevel extends AbstractDhServerLevel
 	// constructor //
 	//=============//
 	
-	public DhServerLevel(ISaveStructure saveStructure, IServerLevelWrapper serverLevelWrapper, ServerPlayerStateManager serverPlayerStateManager)
-	{
-		super(saveStructure, serverLevelWrapper, serverPlayerStateManager);
-	}
+	public DhServerLevel(
+		ISaveStructure saveStructure, 
+		IServerLevelWrapper serverLevelWrapper, 
+		ServerPlayerStateManager serverPlayerStateManager
+		) throws SQLException, IOException
+	{ super(saveStructure, serverLevelWrapper, serverPlayerStateManager); }
 	
 	
 	
@@ -52,7 +56,7 @@ public class DhServerLevel extends AbstractDhServerLevel
 		return true; //todo;
 	}
 	@Override
-	public @Nullable DhBlockPos2D getTargetPosForGeneration()
+	public DhBlockPos2D getTargetPosForGeneration()
 	{
 		DhBlockPos2D targetPos = super.getTargetPosForGeneration();
 		if (targetPos == null)

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

@@ -56,9 +56,6 @@ import java.util.concurrent.CompletableFuture;
  */
 public interface IDhLevel extends AutoCloseable, GeneratedFullDataSourceProvider.IOnWorldGenCompleteListener
 {
-	@Deprecated
-	void worldGenTick();
-	
 	/**
 	 * May return either a client or server level wrapper. <br>
 	 * Should not return null

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

@@ -23,8 +23,6 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapp
 
 public interface IDhServerLevel extends IDhLevel
 {
-    void serverTick();
-	
     IServerLevelWrapper getServerLevelWrapper();
 	
 }

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

@@ -45,18 +45,18 @@ import java.util.function.Supplier;
 
 /**
  * Handles both single-player/server-side world gen and client side LOD requests.
- * TODO rename
  */
-public class WorldGenModule implements Closeable
+public class LodRequestModule implements Closeable
 {
 	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	private final GeneratedFullDataSourceProvider.IOnWorldGenCompleteListener onWorldGenCompleteListener;
+	private final ThreadPoolExecutor tickerThread;
 	
 	private final GeneratedFullDataSourceProvider dataSourceProvider;
-	private final Supplier<? extends AbstractWorldGenState> worldGenStateSupplier;
+	private final Supplier<? extends AbstractLodRequestState> worldGenStateSupplier;
 	
-	private final AtomicReference<AbstractWorldGenState> worldGenStateRef = new AtomicReference<>();
+	private final AtomicReference<AbstractLodRequestState> lodRequestStateRef = new AtomicReference<>();
 	
 	
 	
@@ -64,59 +64,41 @@ public class WorldGenModule implements Closeable
 	// constructor //
 	//=============//
 	
-	public WorldGenModule(
+	public LodRequestModule(
+			IDhLevel level,
 			GeneratedFullDataSourceProvider.IOnWorldGenCompleteListener onWorldGenCompleteListener,
 			GeneratedFullDataSourceProvider dataSourceProvider,
-			Supplier<? extends AbstractWorldGenState> worldGenStateSupplier
+			Supplier<? extends AbstractLodRequestState> worldGenStateSupplier
 		)
 	{
 		this.onWorldGenCompleteListener = onWorldGenCompleteListener;
 		this.dataSourceProvider = dataSourceProvider;
 		this.worldGenStateSupplier = worldGenStateSupplier;
-	}
-	
-	
-	
-	//===================//
-	// world gen control //
-	//===================//
-	
-	public void startWorldGen(GeneratedFullDataSourceProvider dataFileHandler, AbstractWorldGenState newWgs)
-	{
-		// create the new world generator
-		if (!this.worldGenStateRef.compareAndSet(null, newWgs))
-		{
-			LOGGER.warn("Failed to start world gen due to concurrency");
-			newWgs.closeAsync(false);
-		}
-		dataFileHandler.addWorldGenCompleteListener(this.onWorldGenCompleteListener);
-		dataFileHandler.setWorldGenerationQueue(newWgs.worldGenerationQueue);
-	}
-	
-	public void stopWorldGen(GeneratedFullDataSourceProvider dataFileHandler)
-	{
-		AbstractWorldGenState worldGenState = this.worldGenStateRef.get();
-		if (worldGenState == null)
-		{
-			LOGGER.warn("Attempted to stop world gen when it was not running");
-			return;
-		}
 		
-		// shut down the world generator
-		while (!this.worldGenStateRef.compareAndSet(worldGenState, null))
+		String levelId = level.getLevelWrapper().getDhIdentifier();
+		this.tickerThread = ThreadUtil.makeSingleDaemonThreadPool("Request Module Ticker ["+levelId+"]");
+		this.tickerThread.execute(this::tickLoop);
+	}
+	
+	
+	
+	//=========//
+	// ticking //
+	//=========//
+	
+	private void tickLoop()
+	{
+		try
 		{
-			worldGenState = this.worldGenStateRef.get();
-			if (worldGenState == null)
+			while (!Thread.interrupted())
 			{
-				return;
+				Thread.sleep(20);
+				this.tick();
 			}
 		}
-		dataFileHandler.clearRetrievalQueue();
-		worldGenState.closeAsync(true).join(); //TODO: Make it async.
-		dataFileHandler.removeWorldGenCompleteListener(this.onWorldGenCompleteListener);
+		catch (InterruptedException ignore) { }
 	}
-	
-	public void worldGenTick()
+	private void tick()
 	{
 		boolean shouldDoWorldGen = this.onWorldGenCompleteListener.shouldDoWorldGen();
 		// if the world is read only don't generate anything
@@ -136,13 +118,13 @@ public class WorldGenModule implements Closeable
 		
 		if (this.isWorldGenRunning())
 		{
-			AbstractWorldGenState worldGenState = this.worldGenStateRef.get();
-			if (worldGenState != null)
+			AbstractLodRequestState lodRequestState = this.lodRequestStateRef.get();
+			if (lodRequestState != null)
 			{
 				DhBlockPos2D targetPosForGeneration = this.onWorldGenCompleteListener.getTargetPosForGeneration();
 				if (targetPosForGeneration != null)
 				{
-					worldGenState.startGenerationQueueAndSetTargetPos(targetPosForGeneration);
+					lodRequestState.startRequestQueueAndSetTargetPos(targetPosForGeneration);
 				}
 			}
 		}
@@ -150,6 +132,48 @@ public class WorldGenModule implements Closeable
 	
 	
 	
+	//===================//
+	// world gen control //
+	//===================//
+	
+	public void startWorldGen(GeneratedFullDataSourceProvider dataFileHandler, AbstractLodRequestState newWgs)
+	{
+		// create the new world generator
+		if (!this.lodRequestStateRef.compareAndSet(null, newWgs))
+		{
+			LOGGER.warn("Failed to start world gen due to concurrency");
+			newWgs.closeAsync(false);
+		}
+		
+		dataFileHandler.addWorldGenCompleteListener(this.onWorldGenCompleteListener);
+		dataFileHandler.setWorldGenerationQueue(newWgs.retrievalQueue);
+	}
+	
+	public void stopWorldGen(GeneratedFullDataSourceProvider dataFileHandler)
+	{
+		AbstractLodRequestState worldGenState = this.lodRequestStateRef.get();
+		if (worldGenState == null)
+		{
+			LOGGER.warn("Attempted to stop world gen when it was not running");
+			return;
+		}
+		
+		// shut down the world generator
+		while (!this.lodRequestStateRef.compareAndSet(worldGenState, null))
+		{
+			worldGenState = this.lodRequestStateRef.get();
+			if (worldGenState == null)
+			{
+				return;
+			}
+		}
+		dataFileHandler.clearRetrievalQueue();
+		worldGenState.closeAsync(true).join(); //TODO: Make it async.
+		dataFileHandler.removeWorldGenCompleteListener(this.onWorldGenCompleteListener);
+	}
+	
+	
+	
 	//=======================//
 	// base method overrides //
 	//=======================//
@@ -157,13 +181,15 @@ public class WorldGenModule implements Closeable
 	@Override
 	public void close()
 	{
+		this.tickerThread.shutdownNow();
+		
 		// shutdown the world-gen
-		AbstractWorldGenState worldGenState = this.worldGenStateRef.get();
+		AbstractLodRequestState worldGenState = this.lodRequestStateRef.get();
 		if (worldGenState != null)
 		{
-			while (!this.worldGenStateRef.compareAndSet(worldGenState, null))
+			while (!this.lodRequestStateRef.compareAndSet(worldGenState, null))
 			{
-				worldGenState = this.worldGenStateRef.get();
+				worldGenState = this.lodRequestStateRef.get();
 				if (worldGenState == null)
 				{
 					break;
@@ -183,12 +209,12 @@ public class WorldGenModule implements Closeable
 	// getters //
 	//=========//
 	
-	public boolean isWorldGenRunning() { return this.worldGenStateRef.get() != null; }
+	public boolean isWorldGenRunning() { return this.lodRequestStateRef.get() != null; }
 	
 	/** 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();
+		AbstractLodRequestState worldGenState = this.lodRequestStateRef.get();
 		if (worldGenState == null)
 		{
 			return;
@@ -196,9 +222,9 @@ public class WorldGenModule implements Closeable
 		
 		
 		// estimated tasks
-		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.getRetrievalEstimatedRemainingChunkCount());
+		String waitingCountStr = F3Screen.NUMBER_FORMAT.format(worldGenState.retrievalQueue.getWaitingTaskCount());
+		String inProgressCountStr = F3Screen.NUMBER_FORMAT.format(worldGenState.retrievalQueue.getInProgressTaskCount());
+		String totalCountEstimateStr = F3Screen.NUMBER_FORMAT.format(worldGenState.retrievalQueue.getRetrievalEstimatedRemainingChunkCount());
 		String message = "World Gen/Import Tasks: "+waitingCountStr+"/"+totalCountEstimateStr+" (in progress "+inProgressCountStr+")";
 		
 		// estimated chunks/sec
@@ -210,7 +236,7 @@ public class WorldGenModule implements Closeable
 		
 		messageList.add(message);
 		
-		worldGenState.worldGenerationQueue.addDebugMenuStringsToList(messageList);
+		worldGenState.retrievalQueue.addDebugMenuStringsToList(messageList);
 	}
 	
 	
@@ -220,40 +246,22 @@ public class WorldGenModule implements Closeable
 	//================//
 	
 	/** Handles the {@link IFullDataSourceRetrievalQueue} and any other necessary world gen information. */
-	public static abstract class AbstractWorldGenState
+	public static abstract class AbstractLodRequestState
 	{
 		/** static so we only send the disable message once per session */
 		private static long firstProgressMessageSentMs = 0;
 		
-		public IFullDataSourceRetrievalQueue worldGenerationQueue;
+		public IFullDataSourceRetrievalQueue retrievalQueue;
 		
 		private static final ThreadPoolExecutor PROGRESS_UPDATER_THREAD = ThreadUtil.makeSingleDaemonThreadPool("World Gen Progress Updater");
 		private boolean progressUpdateThreadRunning = false;
 		
 		
-		CompletableFuture<Void> closeAsync(boolean doInterrupt)
-		{
-			// this should stop the updater thread
-			this.progressUpdateThreadRunning = false;
-			
-			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 */
-		public void startGenerationQueueAndSetTargetPos(DhBlockPos2D targetPosForGeneration) 
+		/** @param targetPosForRequest the position that world generation should be centered around */
+		public void startRequestQueueAndSetTargetPos(DhBlockPos2D targetPosForRequest) 
 		{ 
-			this.worldGenerationQueue.startAndSetTargetPos(targetPosForGeneration);
+			this.retrievalQueue.startAndSetTargetPos(targetPosForRequest);
 			this.startProgressUpdateThread();
 		}
 		private void startProgressUpdateThread()
@@ -286,8 +294,8 @@ public class WorldGenModule implements Closeable
 		private void sendRetrievalProgress()
 		{
 			// format the remaining chunks
-			int remainingChunkCount = this.worldGenerationQueue.getRetrievalEstimatedRemainingChunkCount();
-			remainingChunkCount += this.worldGenerationQueue.getQueuedChunkCount();
+			int remainingChunkCount = this.retrievalQueue.getRetrievalEstimatedRemainingChunkCount();
+			remainingChunkCount += this.retrievalQueue.getQueuedChunkCount();
 			String remainingChunkCountStr = F3Screen.NUMBER_FORMAT.format(remainingChunkCount);
 			
 			String message = "DH is generating chunks. " + remainingChunkCountStr + " left.";
@@ -350,7 +358,7 @@ public class WorldGenModule implements Closeable
 		/** @return -1 if this method isn't supported or available */
 		public double getEstimatedChunksPerSecond()
 		{
-			RollingAverage avg = this.worldGenerationQueue.getRollingAverageChunkGenTimeInMs();
+			RollingAverage avg = this.retrievalQueue.getRollingAverageChunkGenTimeInMs();
 			if (avg == null)
 			{
 				return -1;
@@ -373,6 +381,27 @@ public class WorldGenModule implements Closeable
 			return chunksPerSecond;
 		}
 		
+		
+		CompletableFuture<Void> closeAsync(boolean doInterrupt)
+		{
+			// this should stop the updater thread
+			this.progressUpdateThreadRunning = false;
+			
+			return this.retrievalQueue.startClosingAsync(true, doInterrupt)
+					.exceptionally(e ->
+							{
+								LOGGER.error("Error during first stage of generation queue shutdown, Error: ["+e.getMessage()+"].", e);
+								return null;
+							}
+					).thenRun(this.retrievalQueue::close)
+					.exceptionally(e ->
+					{
+						LOGGER.error("Error during second stage of generation queue shutdown, Error: ["+e.getMessage()+"].", e);
+						return null;
+					});
+		}
+		
+		
 	}
 	
 	

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

@@ -28,6 +28,9 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.coreapi.DependencyInjection.WorldGeneratorInjector;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 
+import java.io.IOException;
+import java.sql.SQLException;
+
 public class ServerLevelModule implements AutoCloseable
 {
 	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
@@ -36,7 +39,7 @@ public class ServerLevelModule implements AutoCloseable
 	public final ISaveStructure saveStructure;
 	public final GeneratedFullDataSourceProvider fullDataFileHandler;
 	
-	public final WorldGenModule worldGenModule;
+	public final LodRequestModule lodRequestModule;
 	
 	
 	
@@ -44,12 +47,12 @@ public class ServerLevelModule implements AutoCloseable
 	// constructor //
 	//=============//
 	
-	public ServerLevelModule(IDhServerLevel parentServerLevel, ISaveStructure saveStructure)
+	public ServerLevelModule(IDhServerLevel parentServerLevel, ISaveStructure saveStructure) throws SQLException, IOException
 	{
 		this.parentServerLevel = parentServerLevel;
 		this.saveStructure = saveStructure;
 		this.fullDataFileHandler = new GeneratedFullDataSourceProvider(parentServerLevel, saveStructure);
-		this.worldGenModule = new WorldGenModule(this.parentServerLevel, this.fullDataFileHandler, () -> new ServerLevelModule.WorldGenState(this.parentServerLevel));
+		this.lodRequestModule = new LodRequestModule(this.parentServerLevel, this.parentServerLevel, this.fullDataFileHandler, () -> new LodRequestState(this.parentServerLevel));
 	}
 	
 	
@@ -62,7 +65,7 @@ public class ServerLevelModule implements AutoCloseable
 	public void close()
 	{
 		// shutdown the world-gen
-		this.worldGenModule.close();
+		this.lodRequestModule.close();
 		this.fullDataFileHandler.close();
 	}
 	
@@ -72,9 +75,9 @@ public class ServerLevelModule implements AutoCloseable
 	// helper classes //
 	//================//
 	
-	public static class WorldGenState extends WorldGenModule.AbstractWorldGenState
+	public static class LodRequestState extends LodRequestModule.AbstractLodRequestState
 	{
-		WorldGenState(IDhServerLevel level)
+		LodRequestState(IDhServerLevel level)
 		{
 			IDhApiWorldGenerator worldGenerator = WorldGeneratorInjector.INSTANCE.get(level.getLevelWrapper());
 			if (worldGenerator == null)
@@ -85,7 +88,7 @@ public class ServerLevelModule implements AutoCloseable
 				// since core world generator's should have the lowest override priority
 				WorldGeneratorInjector.INSTANCE.bind(level.getLevelWrapper(), worldGenerator);
 			}
-			this.worldGenerationQueue = new WorldGenerationQueue(worldGenerator, level);
+			this.retrievalQueue = new WorldGenerationQueue(worldGenerator, level);
 		}
 		
 	}

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

@@ -24,6 +24,7 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.config.listeners.IConfigListener;
 import com.seibel.distanthorizons.core.config.types.ConfigEntry;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
+import com.seibel.distanthorizons.core.enums.MinecraftTextFormat;
 import com.seibel.distanthorizons.core.util.ThreadUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.coreapi.ModInfo;
@@ -276,7 +277,7 @@ public class DhLogger implements IConfigListener
 			
 			if (mc_client != null)
 			{
-				mc_client.logToChat(level, msgStr);
+				this.logToChat(level, msgStr);
 				messageLogged = true;
 			}
 		}
@@ -296,6 +297,41 @@ public class DhLogger implements IConfigListener
 	}
 	private static boolean loggingLevelIsLessSpecificThan(Level thisLoggingLevel, Level requestedLogLevel)
 	{ return thisLoggingLevel.intLevel() >= requestedLogLevel.intLevel(); }
+	/** Sends the given message to chat with a formatted prefix and color based on the log level. */
+	private void logToChat(Level logLevel, String message)
+	{
+		String prefix = "[" + ModInfo.READABLE_NAME + "] ";
+		if (logLevel == Level.ERROR)
+		{
+			prefix += MinecraftTextFormat.DARK_RED;
+		}
+		else if (logLevel == Level.WARN)
+		{
+			prefix += MinecraftTextFormat.ORANGE;
+		}
+		else if (logLevel == Level.INFO)
+		{
+			prefix += MinecraftTextFormat.AQUA;
+		}
+		else if (logLevel == Level.DEBUG)
+		{
+			prefix += MinecraftTextFormat.GREEN;
+		}
+		else if (logLevel == Level.TRACE)
+		{
+			prefix += MinecraftTextFormat.DARK_GRAY;
+		}
+		else
+		{
+			prefix += MinecraftTextFormat.WHITE;
+		}
+		
+		prefix += MinecraftTextFormat.BOLD + "" + MinecraftTextFormat.WHITE;
+		prefix += logLevel.name();
+		prefix += MinecraftTextFormat.CLEAR_FORMATTING + " ";
+		
+		mc_client.sendChatMessage(prefix + message);
+	}
 	
 	
 	

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

@@ -6,6 +6,7 @@ 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.generation.tasks.DataSourceRetrievalResult;
 import com.seibel.distanthorizons.core.level.DhClientLevel;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
@@ -33,9 +34,7 @@ import java.awt.*;
 import java.util.*;
 import java.util.List;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Consumer;
 
 public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRenderable, AutoCloseable
 {
@@ -58,7 +57,7 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 	
 	private volatile CompletableFuture<Void> closingFuture = null;
 	
-	protected final ConcurrentMap<Long, RequestQueueEntry> waitingTasksBySectionPos = new ConcurrentHashMap<>();
+	protected final ConcurrentMap<Long, NetRequestTask> 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>
@@ -74,16 +73,6 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 	
 	private final SupplierBasedRateLimiter<Void> rateLimiter = new SupplierBasedRateLimiter<>(this::getRequestRateLimit);
 	
-	private final Set<Long> succeededPositions = Collections.newSetFromMap(CacheBuilder.newBuilder()
-			.expireAfterWrite(20, TimeUnit.MINUTES)
-			.<Long, Boolean>build()
-			.asMap());
-	
-	private final Set<Long> requiresSplittingPositions = Collections.newSetFromMap(CacheBuilder.newBuilder()
-			.expireAfterWrite(20, TimeUnit.MINUTES)
-			.<Long, Boolean>build()
-			.asMap());
-	
 	
 	
 	//=============//
@@ -108,8 +97,8 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 	//==================//
 	
 	protected abstract int getRequestRateLimit();
-	protected abstract boolean isSectionAllowedToGenerate(long sectionPos, DhBlockPos2D targetPos);
-	protected abstract boolean onBeforeRequest(long sectionPos, CompletableFuture<ERequestResult> future);
+	protected abstract boolean sectionInAllowedGenerationRadius(long sectionPos, DhBlockPos2D targetPos);
+	protected abstract boolean onBeforeRequest(long sectionPos, CompletableFuture<DataSourceRetrievalResult> future);
 	
 	protected abstract String getQueueName();
 	
@@ -119,74 +108,57 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 	// request submitting //
 	//====================//
 	
-	public CompletableFuture<ERequestResult> submitRequest(long sectionPos, Consumer<FullDataSourceV2> dataSourceConsumer)
-	{ return this.submitRequest(sectionPos, null, dataSourceConsumer); }
-	public CompletableFuture<ERequestResult> submitRequest(long sectionPos, @Nullable Long clientTimestamp, Consumer<FullDataSourceV2> dataSourceConsumer)
+	public CompletableFuture<DataSourceRetrievalResult> submitRequest(long sectionPos, @Nullable Long clientTimestamp)
 	{
-		if (this.succeededPositions.contains(sectionPos))
+		NetRequestTask requestEntry = this.waitingTasksBySectionPos.compute(sectionPos, (Long pos, NetRequestTask existingNetTask) ->
 		{
-			return CompletableFuture.completedFuture(ERequestResult.FAILED);
-		}
-		
-		if (this.requiresSplittingPositions.contains(sectionPos))
-		{
-			return CompletableFuture.completedFuture(ERequestResult.REQUIRES_SPLITTING);
-		}
-		
-		AtomicBoolean added = new AtomicBoolean(false);
-		RequestQueueEntry entry = this.waitingTasksBySectionPos.compute(sectionPos, (pos, existingQueueEntry) ->
-		{
-			if (existingQueueEntry != null)
+			// ignore already queued tasks
+			if (existingNetTask != null)
 			{
-				return existingQueueEntry;
+				return existingNetTask;
 			}
 			
-			RequestQueueEntry newEntry = new RequestQueueEntry(dataSourceConsumer, clientTimestamp);
-			newEntry.future.whenComplete((requestResult, throwable) ->
+			
+			NetRequestTask newRequestEntry = new NetRequestTask(pos, clientTimestamp);
+			newRequestEntry.future.whenComplete((DataSourceRetrievalResult requestResult, Throwable throwable) ->
 			{
-				this.waitingTasksBySectionPos.remove(sectionPos);
+				this.waitingTasksBySectionPos.remove(pos);
 				
-				switch (requestResult)
+				if (throwable != null)
 				{
-					case SUCCEEDED:
-						this.finishedRequests.incrementAndGet();
-						this.succeededPositions.add(pos);
-						return;
-					case REQUIRES_SPLITTING:
-						this.requiresSplittingPositions.add(sectionPos);
-						return;
-					case FAILED:
+					if (!(throwable instanceof CancellationException))
+					{
 						this.failedRequests.incrementAndGet();
-						return;
-					default:
-						if (throwable != null && !(throwable instanceof CancellationException))
-						{
-							this.failedRequests.incrementAndGet();
-						}
+					}
+					return;
+				}
+				
+				switch (requestResult.state)
+				{
+					case SUCCESS:
+						this.finishedRequests.incrementAndGet();
+						break;
+					case REQUIRES_SPLITTING:
 						break;
 				}
 			});
 			
-			added.set(true);
-			return newEntry;
+			return newRequestEntry;
 		});
 		
-		if (!added.get())
-		{
-			return CompletableFuture.completedFuture(ERequestResult.FAILED);
-		}
-		
-		return entry.future;
+		return requestEntry.future;
 	}
 	
 	public synchronized boolean tick(DhBlockPos2D targetPos)
 	{
-		if (DhApiWorldProxy.INSTANCE.worldLoaded() && DhApiWorldProxy.INSTANCE.getReadOnly())
+		if (DhApiWorldProxy.INSTANCE.worldLoaded() 
+			&& DhApiWorldProxy.INSTANCE.getReadOnly())
 		{
 			return false;
 		}
 		
-		if (this.closingFuture != null || !this.networkState.isReady())
+		if (this.closingFuture != null 
+			|| !this.networkState.isReady())
 		{
 			return false;
 		}
@@ -209,145 +181,132 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 	}
 	private void sendNextRequest(DhBlockPos2D targetPos)
 	{
-		Map.Entry<Long, RequestQueueEntry> mapEntry = this.waitingTasksBySectionPos.entrySet().stream()
-				.filter(task -> task.getValue().networkDataSourceFuture == null)
-				.min(Comparator.comparingInt(x -> DhSectionPos.getChebyshevSignedBlockDistance(x.getKey(), targetPos)))
-				.orElse(null);
+		Map.Entry<Long, NetRequestTask> nearestMapEntry = this.waitingTasksBySectionPos
+			.entrySet().stream()
+			.filter(task -> task.getValue().networkDataSourceFuture == null)
+			.min(Comparator.comparingInt(mapEntry -> DhSectionPos.getChebyshevSignedBlockDistance(mapEntry.getKey(), targetPos)))
+			.orElse(null);
 		
-		if (mapEntry == null)
+		if (nearestMapEntry == null)
 		{
 			this.pendingTasksSemaphore.release();
 			return;
 		}
 		
-		long sectionPos = mapEntry.getKey();
-		RequestQueueEntry entry = mapEntry.getValue();
+		long requestPos = nearestMapEntry.getKey();
+		NetRequestTask requestTask = nearestMapEntry.getValue();
 		
-		if (!this.isSectionAllowedToGenerate(sectionPos, targetPos))
+		if (!this.sectionInAllowedGenerationRadius(requestPos, targetPos))
 		{
-			entry.future.cancel(false);
+			requestTask.future.cancel(false);
 			this.pendingTasksSemaphore.release();
 			return;
 		}
 		
-		if (!this.onBeforeRequest(sectionPos, entry.future))
+		if (!this.onBeforeRequest(requestPos, requestTask.future))
 		{
 			this.pendingTasksSemaphore.release();
 			return;
 		}
 		
-		Long offsetEntryTimestamp = entry.updateTimestamp != null
-				? entry.updateTimestamp + this.networkState.getServerTimeOffset()
+		Long offsetEntryTimestamp = requestTask.updateTimestamp != null
+				? requestTask.updateTimestamp + this.networkState.getServerTimeOffset()
 				: null;
 		
-		CompletableFuture<FullDataSourceResponseMessage> dataSourceFuture = this.networkState.getSession().sendRequest(
-				new FullDataSourceRequestMessage(this.level.getLevelWrapper(), sectionPos, offsetEntryTimestamp),
+		CompletableFuture<FullDataSourceResponseMessage> dataSourceNetworkFuture = this.networkState.getSession().sendRequest(
+				new FullDataSourceRequestMessage(this.level.getLevelWrapper(), requestPos, offsetEntryTimestamp),
 				FullDataSourceResponseMessage.class
 		);
-		entry.networkDataSourceFuture = dataSourceFuture;
-		dataSourceFuture.handle((response, throwable) ->
+		requestTask.networkDataSourceFuture = dataSourceNetworkFuture;
+		
+		Executor networkCompressionExecutor = ThreadPoolUtil.getNetworkCompressionExecutor();
+		if (networkCompressionExecutor == null)
 		{
-			this.pendingTasksSemaphore.release();
-			
-			try
-			{
-				if (throwable != null)
-				{
-					throw throwable;
-				}
-				
-				if (response.payload != null)
-				{
-					FullDataSourceV2DTO dataSourceDto = this.networkState.fullDataPayloadReceiver.decodeDataSource(response.payload);
-					
-					// set application flags based on the received detail level,
-					// this is needed so the data sources propagate correctly
-					dataSourceDto.applyToChildren = DhSectionPos.getDetailLevel(dataSourceDto.pos) > DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL;
-					dataSourceDto.applyToParent = DhSectionPos.getDetailLevel(dataSourceDto.pos) < DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL + 12;
-					
-					AbstractExecutorService executor = ThreadPoolUtil.getNetworkCompressionExecutor();
-					if (executor == null)
-					{
-						LOGGER.warn("Unable to handle FullDataPayload - getNetworkCompressionExecutor() is null");
-						dataSourceDto.close();
-						return null;
-					}
-					
-					CompletableFuture.runAsync(() ->
-					{
-						try
-						{
-							this.level.updateBeaconBeamsForSectionPos(dataSourceDto.pos, response.payload.beaconBeams);
-							
-							FullDataSourceV2 fullDataSource = dataSourceDto.createDataSource(this.level.getLevelWrapper(), null);
-							entry.dataSourceConsumer.accept(fullDataSource);
-						}
-						catch (Exception e)
-						{
-							throw new RuntimeException(e);
-						}
-						finally
-						{
-							dataSourceDto.close();
-						}
-					}, executor);
-				}
-				else
-				{
-					LodUtil.assertTrue(this.changedOnly, "Received empty data source response for not changes-only request");
-				}
-			}
-			catch (SectionRequiresSplittingException ignored)
-			{
-				return entry.future.complete(ERequestResult.REQUIRES_SPLITTING);
-			}
-			catch (SessionClosedException | CancellationException ignored)
-			{
-				return entry.future.cancel(false);
-			}
-			catch (RequestRejectedException e)
-			{
-				LOGGER.info("Request rejected by the server: " + e.getMessage());
-				return entry.future.complete(ERequestResult.FAILED);
-			}
-			catch (RateLimitedException e)
-			{
-				LOGGER.info("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 (RequestOutOfRangeException e)
-			{
-				LOGGER.debug("Out of range, re-queueing task [" + DhSectionPos.toString(sectionPos) + "]: " + e.getMessage());
-				
-				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(ERequestResult.FAILED);
-				}
-			}
-			
-			return entry.future.complete(ERequestResult.SUCCEEDED);
-		});
+			return;
+		}
+		
+		dataSourceNetworkFuture.handleAsync((FullDataSourceResponseMessage response, Throwable throwable) ->
+		{
+			this.handleNetResponse(requestTask, response, throwable);
+			return null;
+		}, networkCompressionExecutor);
+	}
+	private void handleNetResponse(NetRequestTask requestTask, FullDataSourceResponseMessage response, Throwable throwable)
+	{
+		this.pendingTasksSemaphore.release();
+		
+		try
+		{
+			if (throwable != null)
+			{
+				throw throwable;
+			}
+			
+			if (response.payload == null)
+			{
+				LodUtil.assertTrue(this.changedOnly, "Received empty data source response for not changes-only request");
+				return;
+			}
+			
+			
+			try(FullDataSourceV2DTO dataSourceDto = this.networkState.fullDataPayloadReceiver.decodeDataSource(response.payload))
+			{
+				// set application flags based on the received detail level,
+				// this is needed so the data sources propagate correctly
+				dataSourceDto.applyToChildren = DhSectionPos.getDetailLevel(dataSourceDto.pos) > DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL;
+				dataSourceDto.applyToParent = DhSectionPos.getDetailLevel(dataSourceDto.pos) < DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL + 12;
+				
+				
+				this.level.updateBeaconBeamsForSectionPos(dataSourceDto.pos, response.payload.beaconBeams);
+				
+				FullDataSourceV2 fullDataSource = dataSourceDto.createDataSource(this.level.getLevelWrapper(), null);
+				requestTask.future.complete(DataSourceRetrievalResult.CreateSuccess(dataSourceDto.pos, fullDataSource));
+			}
+		}
+		catch (SectionRequiresSplittingException ignored)
+		{
+			requestTask.future.complete(DataSourceRetrievalResult.CreateSplit());
+		}
+		catch (SessionClosedException | CancellationException ignored)
+		{
+			requestTask.future.cancel(false);
+		}
+		catch (RequestRejectedException e)
+		{
+			LOGGER.info("Request rejected by the server, message: [" + e.getMessage() + "].");
+			requestTask.future.completeExceptionally(e);
+		}
+		catch (RateLimitedException e)
+		{
+			LOGGER.info("Rate limited by server, re-queueing task [" + DhSectionPos.toString(requestTask.pos) + "], message: [" + e.getMessage() + "].");
+			
+			// Skip all requests for 1 second
+			this.rateLimiter.acquireAll();
+			
+			requestTask.networkDataSourceFuture = null;
+		}
+		catch (RequestOutOfRangeException e)
+		{
+			LOGGER.debug("Out of range, re-queueing task [" + DhSectionPos.toString(requestTask.pos) + "], message: [" + e.getMessage() + "].");
+			
+			requestTask.networkDataSourceFuture = null;
+		}
+		catch (Throwable e)
+		{
+			requestTask.retryAttempts--;
+			LOGGER.error("Unexpected error: ["+e.getMessage()+"] while fetching full data source, attempts left: ["+requestTask.retryAttempts+"] / ["+MAX_RETRY_ATTEMPTS+"]", e);
+			
+			// Retry logic
+			if (requestTask.retryAttempts > 0)
+			{
+				requestTask.networkDataSourceFuture = null;
+			}
+			else
+			{
+				requestTask.future.completeExceptionally(e);
+			}
+		}
 	}
-	
 	
 	
 	
@@ -357,22 +316,30 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 	
 	public void removeRetrievalRequestIf(DhSectionPos.ICancelablePrimitiveLongConsumer removeIf)
 	{
-		for (Map.Entry<Long, RequestQueueEntry> mapEntry : (Iterable<? extends Map.Entry<Long, RequestQueueEntry>>) this.waitingTasksBySectionPos.entrySet().stream()
-				.sorted(Comparator.comparingInt((Map.Entry<Long, RequestQueueEntry> entry) -> DhSectionPos.getChebyshevSignedBlockDistance(entry.getKey(), Objects.requireNonNull(this.level.getTargetPosForGeneration()))).reversed())
-				::iterator)
+		// remove tasks furthest
+		Iterator<Map.Entry<Long, NetRequestTask>> farestTaskIterator = this.waitingTasksBySectionPos
+			.entrySet().stream()
+			.sorted(Comparator.comparingInt((Map.Entry<Long, NetRequestTask> entry) ->
+			{
+				Long pos = entry.getKey();
+				DhBlockPos2D targetPos = this.level.getTargetPosForGeneration();
+				return DhSectionPos.getChebyshevSignedBlockDistance(pos, targetPos);
+			}).reversed())
+			.iterator();
+		
+		while (farestTaskIterator.hasNext())
 		{
+			Map.Entry<Long, NetRequestTask> mapEntry = farestTaskIterator.next();
 			long pos = mapEntry.getKey();
-			RequestQueueEntry entry = mapEntry.getValue();
+			NetRequestTask 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);
 				}
+				entry.future.cancel(false);
 			}
 		}
 	}
@@ -400,7 +367,7 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 			
 			do
 			{
-				for (RequestQueueEntry entry : this.waitingTasksBySectionPos.values())
+				for (NetRequestTask entry : this.waitingTasksBySectionPos.values())
 				{
 					entry.future.cancel(alsoInterruptRunning);
 					if (entry.networkDataSourceFuture != null && entry.networkDataSourceFuture.cancel(alsoInterruptRunning))
@@ -438,13 +405,31 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 			return;
 		}
 		
-		for (Map.Entry<Long, RequestQueueEntry> mapEntry : this.waitingTasksBySectionPos.entrySet())
+		DhBlockPos2D targetPos = this.level.getTargetPosForGeneration();
+		for (Map.Entry<Long, NetRequestTask> mapEntry : this.waitingTasksBySectionPos.entrySet())
 		{
-			renderer.renderBox(new DebugRenderer.Box(mapEntry.getKey(), -32f, 64f, 0.05f,
-					mapEntry.getValue().networkDataSourceFuture != null ? Color.red
-							: this.isSectionAllowedToGenerate(mapEntry.getKey(), Objects.requireNonNull(this.level.getTargetPosForGeneration())) ? Color.gray
-							: Color.darkGray
-			));
+			long pos = mapEntry.getKey();
+			NetRequestTask task = mapEntry.getValue();
+			
+			Color color;
+			if (task.networkDataSourceFuture != null)
+			{
+				color = Color.RED;
+			}
+			else
+			{
+				boolean taskInAllowedGenRadius = this.sectionInAllowedGenerationRadius(pos, targetPos);
+				if (taskInAllowedGenRadius)
+				{
+					color = Color.GRAY;
+				}
+				else
+				{
+					color = Color.DARK_GRAY;
+				}
+			}
+			
+			renderer.renderBox(new DebugRenderer.Box(pos, -32f, 64f, 0.05f, color));
 		}
 	}
 	
@@ -454,11 +439,12 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 	// helper classes //
 	//================//
 	
-	protected static class RequestQueueEntry
+	protected static class NetRequestTask
 	{
+		public final long pos;
+		
 		/** encapsulates the entire request, including client side queuing and the actual server request */
-		public final CompletableFuture<ERequestResult> future = new CompletableFuture<>();
-		public final Consumer<FullDataSourceV2> dataSourceConsumer;
+		public final CompletableFuture<DataSourceRetrievalResult> future = new CompletableFuture<>();
 		/** will be null if we want to retrieve the LOD regardless of when it was last updated */
 		@Nullable
 		public final Long updateTimestamp;
@@ -477,23 +463,14 @@ public abstract class AbstractFullDataNetworkRequestQueue implements IDebugRende
 		// constructor //
 		//=============//
 		
-		public RequestQueueEntry(
-				Consumer<FullDataSourceV2> dataSourceConsumer,
-				@Nullable Long updateTimestamp)
+		public NetRequestTask(long pos, @Nullable Long updateTimestamp)
 		{
-			this.dataSourceConsumer = dataSourceConsumer;
+			this.pos = pos;
 			this.updateTimestamp = updateTimestamp;
 		}
 		
 	}
 	
-	public enum ERequestResult
-	{
-		SUCCEEDED,
-		REQUIRES_SPLITTING,
-		FAILED,
-	}
-	
 	
 	
 }

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

@@ -1,8 +1,10 @@
 package com.seibel.distanthorizons.core.multiplayer.client;
 
+import com.seibel.distanthorizons.core.api.internal.ClientApi;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.config.listeners.ConfigChangeListener;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
+import com.seibel.distanthorizons.core.enums.MinecraftTextFormat;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.multiplayer.config.SessionConfig;
@@ -18,6 +20,7 @@ import com.seibel.distanthorizons.core.network.messages.fullData.FullDataPartial
 import com.seibel.distanthorizons.core.network.session.NetworkSession;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.coreapi.ModInfo;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.Closeable;
@@ -29,6 +32,10 @@ public class ClientNetworkState implements Closeable
 			.fileLevelConfig(Config.Common.Logging.logNetworkEventToFile)
 			.build();
 	
+	protected static final DhLogger CONFIG_CHANGE_LOGGER = new DhLoggerBuilder()
+			.fileLevelConfig(Config.Common.Logging.logConnectionConfigChangesToFile)
+			.build();
+	
 	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	
 	
@@ -44,6 +51,7 @@ public class ClientNetworkState implements Closeable
 	 */
 	public NetworkSession getSession() { return this.networkSession; }
 	
+	@NotNull
 	public SessionConfig sessionConfig = new SessionConfig();
 	
 	private volatile boolean configReceived = false;
@@ -89,6 +97,15 @@ public class ClientNetworkState implements Closeable
 				|| Math.abs(event.protocolVersion - ModInfo.PROTOCOL_VERSION) < this.closestProtocolVersion)
 			{
 				this.closestProtocolVersion = event.protocolVersion;
+				
+				if (ModInfo.PROTOCOL_VERSION < event.protocolVersion)
+				{
+					ClientApi.INSTANCE.showChatMessageNextFrame(MinecraftTextFormat.ORANGE + "Distant Horizons: Your mod is outdated. Update to receive LODs on this server.");
+				}
+				else
+				{
+					ClientApi.INSTANCE.showChatMessageNextFrame(MinecraftTextFormat.ORANGE + "Distant Horizons: The server's mod is outdated. Ask the server's owner to update.");
+				}
 			}
 		});
 		
@@ -129,7 +146,9 @@ public class ClientNetworkState implements Closeable
 			{
 				this.serverSupportStatus = EServerSupportStatus.FULL;
 				
-				LOGGER.info("Connection config has been changed: [" + message.config + "].");
+				String configChanges = this.sessionConfig.getDifferencesAsString(message.config);
+				CONFIG_CHANGE_LOGGER.info("Connection config has been changed: [" + configChanges + "].");
+				
 				this.sessionConfig = message.config;
 				this.configReceived = true;
 			});

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

@@ -2,6 +2,7 @@ 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.generation.tasks.DataSourceRetrievalResult;
 import com.seibel.distanthorizons.core.level.DhClientLevel;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
@@ -35,12 +36,12 @@ public class SyncOnLoadRequestQueue extends AbstractFullDataNetworkRequestQueue
 	@Override
 	protected int getRequestRateLimit() { return this.networkState.sessionConfig.getSyncOnLoginRateLimit(); }
 	@Override
-	protected boolean isSectionAllowedToGenerate(long sectionPos, DhBlockPos2D targetPos)
+	protected boolean sectionInAllowedGenerationRadius(long sectionPos, DhBlockPos2D targetPos)
 	{
 		return DhSectionPos.getChebyshevSignedBlockDistance(sectionPos, targetPos) <= this.networkState.sessionConfig.getMaxSyncOnLoadDistance() * 16;
 	}
 	@Override
-	protected boolean onBeforeRequest(long sectionPos, CompletableFuture<ERequestResult> future) { return true; }
+	protected boolean onBeforeRequest(long sectionPos, CompletableFuture<DataSourceRetrievalResult> future) { return true; }
 	
 	@Override
 	protected String getQueueName() { return "Sync On Login Queue"; }

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

@@ -33,9 +33,9 @@ public class SessionConfig implements INetworkObject
 		
 		registerConfigEntry(Config.Common.WorldGenerator.enableDistantGeneration, Boolean::logicalAnd);
 		registerConfigEntry(Config.Server.maxGenerationRequestDistance, Math::min);
-		registerConfigEntry(Config.Server.generationBoundsX, (x, y) -> y);
-		registerConfigEntry(Config.Server.generationBoundsZ, (x, y) -> y);
-		registerConfigEntry(Config.Server.generationBoundsRadius, (x, y) -> y);
+		registerConfigEntry(Config.Common.WorldGenerator.generationCenterChunkX, (x, y) -> y);
+		registerConfigEntry(Config.Common.WorldGenerator.generationCenterChunkZ, (x, y) -> y);
+		registerConfigEntry(Config.Common.WorldGenerator.generationMaxChunkRadius, (x, y) -> y);
 		registerConfigEntry(Config.Server.generationRequestRateLimit, Math::min);
 		
 		registerConfigEntry(Config.Server.enableRealTimeUpdates, Boolean::logicalAnd);
@@ -68,9 +68,9 @@ public class SessionConfig implements INetworkObject
 	
 	public boolean isDistantGenerationEnabled() { return this.getValue(Config.Common.WorldGenerator.enableDistantGeneration); }
 	public int getMaxGenerationRequestDistance() { return this.getValue(Config.Server.maxGenerationRequestDistance); }
-	public Integer getGenerationBoundsX() { return this.getValue(Config.Server.generationBoundsX); }
-	public Integer getGenerationBoundsZ() { return this.getValue(Config.Server.generationBoundsZ); }
-	public Integer getGenerationBoundsRadius() { return this.getValue(Config.Server.generationBoundsRadius); }
+	public Integer getGenerationCenterChunkX() { return this.getValue(Config.Common.WorldGenerator.generationCenterChunkX); }
+	public Integer getGenerationCenterChunkZ() { return this.getValue(Config.Common.WorldGenerator.generationCenterChunkZ); }
+	public Integer getGenerationMaxChunkRadius() { return this.getValue(Config.Common.WorldGenerator.generationMaxChunkRadius); }
 	public int getGenerationRequestRateLimit() { return this.getValue(Config.Server.generationRequestRateLimit); }
 	
 	public boolean isRealTimeUpdatesEnabled() { return this.getValue(Config.Server.enableRealTimeUpdates); }
@@ -162,6 +162,34 @@ public class SessionConfig implements INetworkObject
 	
 	
 	
+	//=========//
+ 	// logging //
+ 	//=========//
+	
+	/** 
+	 * example: "common.playerBandwidthLimit:[497], " <br>
+	 * Useful to see what was changed when receiving a new config from the server.
+	 */
+	public String getDifferencesAsString(SessionConfig that)
+	{
+		StringBuilder stringBuilder = new StringBuilder();
+		
+		for (String key : this.values.keySet())
+		{
+			String thisFieldString = this.values.get(key) + "";
+			String thatFieldString = that.values.get(key) + "";
+			
+			if (!thisFieldString.equals(thatFieldString))
+			{
+				stringBuilder.append(key+":["+thisFieldString+"], ");
+			}
+		}
+		
+		return stringBuilder.toString();
+	}
+	
+	
+	
 	//================//
 	// base overrides //
 	//================//

core/src/main/java/com/seibel/distanthorizons/core/multiplayer/fullData/FullDataPayloadReceiver.java

@@ -9,7 +9,7 @@ import com.seibel.distanthorizons.core.network.messages.fullData.FullDataSplitMe
 import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV2DTO;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import io.netty.buffer.CompositeByteBuf;
-import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.buffer.Unpooled;
 
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.TimeUnit;
@@ -36,7 +36,7 @@ public class FullDataPayloadReceiver implements AutoCloseable
 		{
 			if (message.isFirst)
 			{
-				composite = UnpooledByteBufAllocator.DEFAULT.compositeBuffer();
+				composite = Unpooled.compositeBuffer();
 				LOGGER.debug("Created new full data buffer [" + message.bufferId + "]: [" + composite + "]");
 			}
 			else if (composite == null)
@@ -45,6 +45,7 @@ public class FullDataPayloadReceiver implements AutoCloseable
 				return null;
 			}
 			
+			message.buffer.readerIndex(0);
 			composite.addComponent(message.buffer);
 			composite.writerIndex(composite.writerIndex() + message.buffer.writerIndex());
 			LOGGER.debug("Updated full data buffer [" + message.bufferId + "]: [" + composite + "].");
@@ -55,12 +56,11 @@ public class FullDataPayloadReceiver implements AutoCloseable
 	public FullDataSourceV2DTO decodeDataSource(FullDataPayload payload)
 	{
 		CompositeByteBuf compositeByteBuffer = this.buffersById.get(payload.dtoBufferId);
-		LodUtil.assertTrue(compositeByteBuffer != null);
+		LodUtil.assertTrue(compositeByteBuffer != null, "decoded data source missing byte buffer");
 		
 		try
 		{
 			FullDataSourceV2DTO dataSourceDto = INetworkObject.decodeToInstance(FullDataSourceV2DTO.CreateEmptyDataSourceForDecoding(), compositeByteBuffer);
-			LOGGER.debug("Buffer {} DTO: {}", payload.dtoBufferId, dataSourceDto);
 			return dataSourceDto;
 		}
 		finally

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

@@ -14,6 +14,7 @@ import com.seibel.distanthorizons.core.network.messages.fullData.FullDataSourceR
 import com.seibel.distanthorizons.core.network.messages.fullData.FullDataSourceResponseMessage;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.sql.dto.BeaconBeamDTO;
+import com.seibel.distanthorizons.core.util.ThreadUtil;
 import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
 
 import java.util.List;
@@ -21,7 +22,7 @@ import java.util.Map;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-public class FullDataSourceRequestHandler
+public class FullDataSourceRequestHandler implements AutoCloseable
 {
 	private static final DhLogger LOGGER = new DhLoggerBuilder()
 			.fileLevelConfig(Config.Common.Logging.logNetworkEventToFile)
@@ -29,6 +30,8 @@ public class FullDataSourceRequestHandler
 	
 	
 	private final AbstractDhServerLevel serverLevel;
+	private final ThreadPoolExecutor tickerThread;
+	
 	private String getLevelIdentifier() { return this.serverLevel.getLevelWrapper().getDhIdentifier(); }
 	private GeneratedFullDataSourceProvider fullDataSourceProvider() { return this.serverLevel.serverside.fullDataFileHandler; }
 	private List<BeaconBeamDTO> getAllBeamsForPos(long pos) { return this.serverLevel.beaconBeamRepo.getAllBeamsForPos(pos); }
@@ -37,12 +40,22 @@ public class FullDataSourceRequestHandler
 	private final ConcurrentMap<Long, DataSourceRequestGroup> requestGroupsByFutureId = new ConcurrentHashMap<>();
 	
 	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
 	public FullDataSourceRequestHandler(AbstractDhServerLevel serverLevel)
 	{
 		this.serverLevel = serverLevel;
+		
+		String levelId = this.serverLevel.getServerLevelWrapper().getDhIdentifier();
+		this.tickerThread = ThreadUtil.makeSingleDaemonThreadPool("DataSource Request Ticker ["+levelId+"]");
+		this.tickerThread.execute(this::tickLoop);
 	}
 	
 	
+	
 	//==================//
 	// network handling //
 	//==================//
@@ -161,12 +174,21 @@ public class FullDataSourceRequestHandler
 			DataSourceRequestGroup requestGroup = this.requestGroupsByPos.computeIfAbsent(requestData.sectionPos(), pos ->
 			{
 				DataSourceRequestGroup newGroup = new DataSourceRequestGroup(pos);
-				newGroup.tryAddRequest(requestData);
-				createdNewGroup.set(true);
+				try
+				{
+					newGroup.tryAddRequest(requestData);
+					createdNewGroup.set(true);
+					
+					this.tryFulfillDataSourceRequestGroup(newGroup, pos);
+					
+					LOGGER.debug("[" + this.getLevelIdentifier() + "] Created request group for pos [" + DhSectionPos.toString(pos) + "].");
+					return newGroup;
+				}
+				catch (Exception e)
+				{
+					LOGGER.error("Unable to queue request for pos: ["+DhSectionPos.toString(requestData.sectionPos())+"], error: ["+e.getMessage()+"].", e);
+				}
 				
-				this.tryFulfillDataSourceRequestGroup(newGroup, pos);
-				
-				LOGGER.debug("[" + this.getLevelIdentifier() + "] Created request group for pos [" + DhSectionPos.toString(pos) + "].");
 				return newGroup;
 			});
 			
@@ -214,14 +236,90 @@ public class FullDataSourceRequestHandler
 		}
 	}
 	
+	private void tryFulfillDataSourceRequestGroup(DataSourceRequestGroup requestGroup, long pos)
+	{
+		final GeneratedFullDataSourceProvider provider = this.fullDataSourceProvider();
+		
+		provider.getAsync(pos)
+			.thenAccept((FullDataSourceV2 fullDataSource) ->
+		{
+			if (provider.generationStepsAreFullyGenerated(fullDataSource.columnGenerationSteps))
+			{
+				//LOGGER.info("sending - complete [" + DhSectionPos.toString(pos) + "]");
+				requestGroup.fullDataSource = fullDataSource;
+				return;
+			}
+			
+			fullDataSource.close();
+			
+			if (DhSectionPos.getDetailLevel(pos) > (Config.Common.WorldGenerator.distantGeneratorMode.get() == EDhApiDistantGeneratorMode.INTERNAL_SERVER
+					? DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL
+					: this.serverLevel.serverside.fullDataFileHandler.lowestDataDetailLevel()))
+			{
+				// Make this group unavailable for adding into
+				this.requestGroupsByPos.remove(pos);
+				if (!requestGroup.tryClose())
+				{
+					//LOGGER.info("closing [" + DhSectionPos.toString(pos) + "]");
+					return;
+				}
+				
+				for (DataSourceRequestGroup.RequestData requestData : requestGroup.requestMessages.values())
+				{
+					//LOGGER.info("sending [" + DhSectionPos.toString(pos) + "] - ["+DhSectionPos.toString(requestData.sectionPos())+"]");
+					
+					this.requestGroupsByFutureId.remove(requestData.futureId());
+					requestData.rateLimiterSet.generationRequestRateLimiter.release();
+					requestData.message.sendResponse(new SectionRequiresSplittingException());
+				}
+			}
+			else if (requestGroup.isWorldGenTaskComplete())
+			{
+				//LOGGER.info("sending - retry [" + DhSectionPos.toString(pos) + "]");
+				this.tryFulfillDataSourceRequestGroup(requestGroup, pos);
+			}
+			else
+			{
+				//LOGGER.info("queueing incomplete world gen [" + DhSectionPos.toString(pos) + "]");
+				this.fullDataSourceProvider().queuePositionForRetrieval(pos);
+			}
+		});
+	}
 	
-	public void tick()
+	public void onWorldGenTaskComplete(long pos)
+	{
+		DataSourceRequestGroup requestGroup = this.requestGroupsByPos.get(pos);
+		if (requestGroup != null)
+		{
+			requestGroup.markWorldGenTaskComplete();
+			this.tryFulfillDataSourceRequestGroup(requestGroup, pos);
+		}
+	}
+	
+	
+	
+	//=========//
+	// ticking //
+	//=========//
+	
+	private void tickLoop()
+	{
+		try
+		{
+			while (!Thread.interrupted())
+			{
+				Thread.sleep(20);
+				this.tick();
+			}
+		}
+		catch (InterruptedException ignore) { }
+	}
+	private void tick()
 	{
 		// Send finished data source requests
 		for (Map.Entry<Long, DataSourceRequestGroup> entry : this.requestGroupsByPos.entrySet())
 		{
 			DataSourceRequestGroup requestGroup = entry.getValue();
-			
 			if (requestGroup.fullDataSource == null)
 			{
 				continue;
@@ -260,57 +358,18 @@ public class FullDataSourceRequestHandler
 		}
 	}
 	
-	private void tryFulfillDataSourceRequestGroup(DataSourceRequestGroup requestGroup, long pos)
+	
+	
+	//================//
+	// base overrides //
+	//================//
+	
+	@Override 
+	public void close()
 	{
-		this.fullDataSourceProvider().getAsync(pos).thenAccept(fullDataSource ->
-		{
-			if (this.fullDataSourceProvider().isFullyGenerated(fullDataSource.columnGenerationSteps))
-			{
-				requestGroup.fullDataSource = fullDataSource;
-				return;
-			}
-			
-			fullDataSource.close();
-			
-			if (DhSectionPos.getDetailLevel(pos) > (Config.Common.WorldGenerator.distantGeneratorMode.get() == EDhApiDistantGeneratorMode.INTERNAL_SERVER
-					? DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL
-					: this.serverLevel.serverside.fullDataFileHandler.lowestDataDetailLevel()))
-			{
-				// Make this group unavailable for adding into
-				this.requestGroupsByPos.remove(pos);
-				if (!requestGroup.tryClose())
-				{
-					return;
-				}
-				
-				for (DataSourceRequestGroup.RequestData requestData : requestGroup.requestMessages.values())
-				{
-					this.requestGroupsByFutureId.remove(requestData.futureId());
-					requestData.rateLimiterSet.generationRequestRateLimiter.release();
-					requestData.message.sendResponse(new SectionRequiresSplittingException());
-				}
-			}
-			else if (requestGroup.isWorldGenTaskComplete())
-			{
-				//LOGGER.info("sending - retry [" + DhSectionPos.toString(pos) + "]");
-				this.tryFulfillDataSourceRequestGroup(requestGroup, pos);
-			}
-			else
-			{
-				//LOGGER.info("sending - queueing [" + DhSectionPos.toString(pos) + "]");
-				this.fullDataSourceProvider().queuePositionForRetrieval(pos);
-			}
-		});
+		this.tickerThread.shutdownNow();
 	}
 	
-	public void onWorldGenTaskComplete(long pos)
-	{
-		DataSourceRequestGroup requestGroup = this.requestGroupsByPos.get(pos);
-		if (requestGroup != null)
-		{
-			requestGroup.markWorldGenTaskComplete();
-			this.tryFulfillDataSourceRequestGroup(requestGroup, pos);
-		}
-	}
+	
 	
 }

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

@@ -102,8 +102,8 @@ public class ServerPlayerState implements Closeable
 	private void sendConfigMessage()
 	{
 		double coordinateScale = this.getServerPlayer().getLevel().getDimensionType().getCoordinateScale();
-		this.sessionConfig.constrainValue(Config.Server.generationBoundsX, (int) (Config.Server.generationBoundsX.get() / coordinateScale));
-		this.sessionConfig.constrainValue(Config.Server.generationBoundsZ, (int) (Config.Server.generationBoundsZ.get() / coordinateScale));
+		this.sessionConfig.constrainValue(Config.Common.WorldGenerator.generationCenterChunkX, (int) (Config.Common.WorldGenerator.generationCenterChunkX.get() / coordinateScale));
+		this.sessionConfig.constrainValue(Config.Common.WorldGenerator.generationCenterChunkZ, (int) (Config.Common.WorldGenerator.generationCenterChunkZ.get() / coordinateScale));
 		
 		this.networkSession.sendMessage(new SessionConfigMessage(this.sessionConfig));
 	}

core/src/main/java/com/seibel/distanthorizons/core/network/session/NetworkSession.java

@@ -92,7 +92,8 @@ public class NetworkSession extends AbstractNetworkEventSource
 		{
 			LOGGER.error("Failed to handle the message. New messages will be ignored.", e);
 			LOGGER.error("Message: ["+message+"]");
-			this.close();
+			
+			this.close(e);
 		}
 	}
 	

core/src/main/java/com/seibel/distanthorizons/core/pooling/AbstractPhantomArrayList.java

@@ -40,7 +40,9 @@ public abstract class AbstractPhantomArrayList implements AutoCloseable
 	/** The Array counts can be 0 or greater. */
 	public AbstractPhantomArrayList(PhantomArrayListPool phantomArrayListPool, int byteArrayCount, int shortArrayCount, int longArrayCount) 
 	{
-		if (byteArrayCount < 0 || shortArrayCount < 0 || longArrayCount < 0)
+		if (byteArrayCount < 0 
+			|| shortArrayCount < 0 
+			|| longArrayCount < 0)
 		{
 			throw new IllegalArgumentException("Can't get a negative number of pooled arrays.");
 		}

core/src/main/java/com/seibel/distanthorizons/core/pooling/PhantomArrayListCheckout.java

@@ -10,6 +10,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.lang.ref.SoftReference;
 import java.util.ArrayList;
+import java.util.Arrays;
 
 /**
  * This keeps track of all the poolable
@@ -33,7 +34,7 @@ public class PhantomArrayListCheckout implements AutoCloseable
 	
 	/** Will be null if the parent pool doesn't want leak stack tracing */
 	@Nullable
-	public final String allocationStackTrace;
+	public String allocationStackTrace = null;
 	
 	private final ArrayList<ByteArrayList> byteArrayLists = new ArrayList<>();
 	private final ArrayList<ShortArrayList> shortArrayLists = new ArrayList<>();
@@ -47,21 +48,20 @@ public class PhantomArrayListCheckout implements AutoCloseable
 	
 	public PhantomArrayListCheckout(@NotNull PhantomArrayListPool owningPool)
 	{
-		if (owningPool.logGarbageCollectedStacks)
-		{
-			// TODO remove the top 4 or so lines since those will always be the same (relating to the phantom allocations)
-			//  and aren't helpful when debugging
-			this.allocationStackTrace = StringUtil.join("\n", Thread.currentThread().getStackTrace());
-		}
-		else
-		{
-			this.allocationStackTrace = null;
-		}
-		
 		this.owningPool = owningPool;
 		this.ownerSoftReference = new SoftReference<>(this);
 	}
 	
+	public void onCheckout()
+	{
+		if (this.owningPool.logGarbageCollectedStacks)
+		{
+			StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+			StackTraceElement[] trimmedElements = Arrays.copyOfRange(stackTraceElements, 4, stackTraceElements.length);
+			this.allocationStackTrace = StringUtil.join("\n", trimmedElements).intern();
+		}
+	}
+	
 	
 	
 	//=========//

core/src/main/java/com/seibel/distanthorizons/core/pooling/PhantomArrayListPool.java

@@ -2,6 +2,7 @@ package com.seibel.distanthorizons.core.pooling;
 
 import com.seibel.distanthorizons.core.api.internal.ClientApi;
 import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.enums.MinecraftTextFormat;
 import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.logging.f3.F3Screen;
@@ -12,7 +13,6 @@ import com.seibel.distanthorizons.coreapi.util.StringUtil;
 import it.unimi.dsi.fastutil.bytes.ByteArrayList;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import it.unimi.dsi.fastutil.shorts.ShortArrayList;
-import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -159,6 +159,7 @@ public class PhantomArrayListPool
 			{
 				// pool is empty, create new checkout
 				checkout = new PhantomArrayListCheckout(this);
+				checkout.onCheckout();
 			}
 			else
 			{
@@ -166,6 +167,7 @@ public class PhantomArrayListPool
 				if (checkout != null)
 				{
 					// use pooled checkout
+					checkout.onCheckout();
 				}
 				else
 				{
@@ -176,13 +178,13 @@ public class PhantomArrayListPool
 					{
 						lowMemoryWarningLogged = true;
 						
-						// orange text
-						String message = "\u00A76" + "Distant Horizons: Insufficient memory detected." + "\u00A7r \n" +
+						String message = MinecraftTextFormat.ORANGE + "Distant Horizons: Insufficient memory detected." + MinecraftTextFormat.CLEAR_FORMATTING + "\n" +
 								"This may cause stuttering or crashing. \n" +
 								"Potential causes: \n" +
 								"1. your allocated memory isn't high enough \n" +
 								"2. your DH CPU preset is too high \n" +
-								"3. your DH quality preset is too high";
+								"3. your DH quality preset is too high \n" +
+								"4. you have other memory hungry mod(s)";
 						
 						LOGGER.warn(message);
 						if (Config.Common.Logging.Warning.showPoolInsufficientMemoryWarning.get())