Add correct descriptions

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

@@ -22,7 +22,9 @@ package com.seibel.distanthorizons.api.enums.config;
 /**
  * UNCOMPRESSED <br>
  * LZ4 <br>
- * XZ <br><br>
+ * Z_STD <br>
+ * Z_STD_STREAM <br>
+ * LZMA2 <br><br>
  * 
  * Note: speed and compression ratios are examples
  * and should only be used for estimated comparisons.
@@ -32,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> 
 	 * 
@@ -56,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,6 +44,10 @@ public enum EDhApiGpuUploadMethod
 	/** Fast rendering but may stutter when uploading. */
 	SUB_DATA(false, false),
 	
+	///** Don't upload, only should be used for debugging */
+	//@Deprecated
+	//NONE(false, false),
+	
 	/**
 	 * May end up storing buffers in System memory. <br>
 	 * Fast rending if in GPU memory, slow if 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/EDhApiLoggerLevel.java

@@ -17,23 +17,37 @@
  *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package com.seibel.distanthorizons.core.generation.tasks;
+package com.seibel.distanthorizons.api.enums.config;
 
-import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+import org.apache.logging.log4j.Level;
-
-import javax.annotation.Nullable;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
 
 /**
- * @author Leetom
+ * ALL
- * @version 2022-11-25
+ * DEBUG
+ * INFO
+ * WARN
+ * ERROR
+ * DISABLED
+ * 
+ * @since API 5.0.0
+ * @version 2024-4-6
  */
-public interface IWorldGenTaskTracker
+public enum EDhApiLoggerLevel
 {
-	@Nullable
+	// ordered from most to least broad
-	Consumer<FullDataSourceV2> getDataSourceConsumer();
+	ALL(Level.ALL),
+	DEBUG(Level.DEBUG),
+	INFO(Level.INFO),
+	WARN(Level.WARN),
+	ERROR(Level.ERROR),
+	DISABLED(Level.OFF),
+	;
+	
+	public final Level level;
+	
+	EDhApiLoggerLevel(Level level)
+	{ this.level = level; }
+	
 	
-	CompletableFuture<Boolean> shouldGenerateSplitChild(long pos);
 	
 }

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

@@ -1,55 +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.api.enums.config;
-
-import org.apache.logging.log4j.Level;
-
-/**
- * @since API 2.0.0
- * @version 2024-4-6
- */
-public enum EDhApiLoggerMode
-{
-	DISABLED(Level.OFF, Level.OFF),
-	LOG_ALL_TO_FILE(Level.ALL, Level.OFF),
-	LOG_ERROR_TO_CHAT(Level.ALL, Level.ERROR),
-	LOG_WARNING_TO_CHAT(Level.ALL, Level.WARN),
-	LOG_INFO_TO_CHAT(Level.ALL, Level.INFO),
-	LOG_DEBUG_TO_CHAT(Level.ALL, Level.DEBUG),
-	LOG_ALL_TO_CHAT(Level.ALL, Level.ALL),
-	LOG_ERROR_TO_CHAT_AND_FILE(Level.ERROR, Level.ERROR),
-	LOG_WARNING_TO_CHAT_AND_FILE(Level.WARN, Level.WARN),
-	LOG_INFO_TO_CHAT_AND_FILE(Level.INFO, Level.INFO),
-	LOG_DEBUG_TO_CHAT_AND_FILE(Level.DEBUG, Level.DEBUG),
-	LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE(Level.INFO, Level.WARN),
-	LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE(Level.INFO, Level.ERROR),
-	LOG_ERROR_TO_CHAT_AND_WARNING_TO_FILE(Level.ERROR, Level.WARN),
-	;
-	
-	public final Level levelForFile;
-	public final Level levelForChat;
-	
-	EDhApiLoggerMode(Level levelForFile, Level levelForChat)
-	{
-		this.levelForFile = levelForFile;
-		this.levelForChat = levelForChat;
-	}
-	
-}

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

@@ -64,10 +64,7 @@ public enum EDhApiMaxHorizontalResolution
 	/** How wide each LOD DataPoint is */
 	public final int dataPointWidth;
 	
-	/**
+	/** This is the same as detailLevel in LodQuadTreeNode */
-	 * This is the same as detailLevel in LodQuadTreeNode,
-	 * lowest is 0 highest is 9
-	 */
 	public final byte detailLevel;
 	
 	/* Start/End X/Z give the block positions

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/abstractEvents/DhApiColorDepthTextureCreatedEvent.java

@@ -33,7 +33,7 @@ import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhAp
  * @since API 2.0.0
  * @deprecated Replaced by {@link DhApiBeforeColorDepthTextureCreatedEvent} since this event's name isn't obvious when it fires.
  */
-@Deprecated
+@Deprecated // internal notes: this method must be kept around due to Iris using it and we don't want to break old Iris support
 public abstract class DhApiColorDepthTextureCreatedEvent implements IDhApiEvent<DhApiColorDepthTextureCreatedEvent.EventParam>
 {
 	/** Fired before Distant Horizons creates. */

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
@@ -38,7 +40,7 @@ public class DhApiRenderParam implements IDhApiEventParam
 	/** Indicates how far into this tick the frame is. */
 	public final float partialTicks;
 	
-	/** 
+	/**
 	 * Indicates DH's near clip plane, measured in blocks. 
 	 * Note: this may change based on time, player speed, and other factors. 
 	 */
@@ -61,22 +63,29 @@ public class DhApiRenderParam implements IDhApiEventParam
 	
 	public final int worldYOffset;
 	
+	/**
+	 * The level currently being rendered.
+	 * 
+	 * @since API 5.1.0 
+	 */
+	public final IDhApiLevelWrapper clientLevelWrapper;
+	
 	
 	
 	//==============//
 	// constructors //
 	//==============//
 	
-	
 	public DhApiRenderParam(DhApiRenderParam parent)
 	{
 		this(
-				parent.renderPass,
+			parent.renderPass,
-				parent.partialTicks,
+			parent.partialTicks,
-				parent.nearClipPlane, parent.farClipPlane,
+			parent.nearClipPlane, parent.farClipPlane,
-				parent.mcProjectionMatrix.copy(), parent.mcModelViewMatrix.copy(),
+			parent.mcProjectionMatrix.copy(), parent.mcModelViewMatrix.copy(),
-				parent.dhProjectionMatrix.copy(), parent.dhModelViewMatrix.copy(),
+			parent.dhProjectionMatrix.copy(), parent.dhModelViewMatrix.copy(),
-				parent.worldYOffset
+			parent.worldYOffset,
+			parent.clientLevelWrapper
 		);
 	}
 	public DhApiRenderParam(
@@ -85,8 +94,9 @@ 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;
 		
@@ -102,6 +112,7 @@ public class DhApiRenderParam implements IDhApiEventParam
 		this.dhModelViewMatrix = newDhModelViewMatrix;
 		
 		this.worldYOffset = worldYOffset;
+		this.clientLevelWrapper = clientLevelWrapper;
 		
 	}
 	
@@ -111,10 +122,9 @@ public class DhApiRenderParam implements IDhApiEventParam
 	// base overrides //
 	//================//
 	
-	@Override 
+	@Override
-	public DhApiRenderParam copy()
+	public DhApiRenderParam copy() { return new DhApiRenderParam(this); }
-	{
+	
-		return new DhApiRenderParam(this); 
+	
-	}
 	
 }

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 //
 	//==============//
 	
-	/** 
+	/** @since API 3.0.0 */
-	 * Deprecated due to the topYBlockPos and bottomYBlockPos variables being put in the wrong order. 
-	 * They should have been in bottom -> top order. 
-	 * 
-	 * @see DhApiChunk#create(int, int, int, int) 
-	 */
-	@Deprecated
-	public DhApiChunk(int chunkPosX, int chunkPosZ, int topYBlockPos, int bottomYBlockPos) 
-	{ this(chunkPosX, chunkPosZ, bottomYBlockPos, topYBlockPos, false); }
-	
-	/**
-	 * @since API 3.0.0 
-	 */
 	public static DhApiChunk create(int chunkPosX, int chunkPosZ, int bottomYBlockPos, int topYBlockPos)
-	{ return new DhApiChunk(chunkPosX, chunkPosZ, bottomYBlockPos, topYBlockPos, false); }
+	{ return new DhApiChunk(chunkPosX, chunkPosZ, bottomYBlockPos, topYBlockPos); }
 	
-	/** 
+	/** Only visible to internal DH methods */
-	 * Only visible to internal DH methods 
+	private DhApiChunk(int chunkPosX, int chunkPosZ, int bottomYBlockPos, int topYBlockPos)
-	 * @param ignoredParameter is only present to differentiate the two constructors and isn't actually used
-	 */
-	private DhApiChunk(int chunkPosX, int chunkPosZ, int bottomYBlockPos, int topYBlockPos, boolean ignoredParameter)
 	{
 		this.chunkPosX = chunkPosX;
 		this.chunkPosZ = chunkPosZ;

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 //
 	//==============//
 	
-	/**
+	/** @since API 3.0.0 */
-	 * Deprecated due to the topYBlockPos and bottomYBlockPos variables being put in the wrong order. 
-	 * They should have been in bottom -> top order. 
-	 *
-	 * @see DhApiTerrainDataPoint#create(byte, int, int, int, int, IDhApiBlockStateWrapper, IDhApiBiomeWrapper) 
-	 */
-	@Deprecated
-	public DhApiTerrainDataPoint(
-			byte detailLevel, 
-			int blockLightLevel, int skyLightLevel, 
-			int topYBlockPos, int bottomYBlockPos, 
-			IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper)
-	{
-		this(detailLevel, blockLightLevel, skyLightLevel,
-			bottomYBlockPos, topYBlockPos,
-			blockStateWrapper, biomeWrapper, 
-			false);
-	}
-	
-	/**
-	 * @since API 3.0.0 
-	 */
 	public static DhApiTerrainDataPoint create(
 			byte detailLevel,
 			int blockLightLevel, int skyLightLevel,
@@ -91,20 +74,15 @@ public class DhApiTerrainDataPoint
 		return new DhApiTerrainDataPoint(
 			detailLevel, blockLightLevel, skyLightLevel,
 			bottomYBlockPos, topYBlockPos,
-			blockStateWrapper, biomeWrapper,
+			blockStateWrapper, biomeWrapper); 
-			false); 
 	}
 	
-	/**
+	/** Only visible to internal DH methods */
-	 * Only visible to internal DH methods 
-	 * @param ignoredParameter is only present to differentiate the two constructors and isn't actually used
-	 */
 	private DhApiTerrainDataPoint(
 			byte detailLevel,
 			int blockLightLevel, int skyLightLevel,
 			int bottomYBlockPos, int topYBlockPos,
-			IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper,
+			IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper
-			boolean ignoredParameter
 		)
 	{
 		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,19 +31,19 @@ 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 = 11;
+	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.6-b";
+	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 = 4;
+	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 = 1;
 	/** This version should be updated whenever non-breaking fixes are added to the DH API */

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.apache.logging.log4j.Logger;
 import org.sqlite.SQLiteJDBCLoader;
-import org.sqlite.util.OSInfo;
 import org.tukaani.xz.XZOutputStream;
 
-import java.awt.*;
+import java.lang.management.GarbageCollectorMXBean;
-import java.io.File;
+import java.lang.management.ManagementFactory;
+import java.util.List;
 
 /** Handles first time Core setup. */
 public class Initializer
 {
-	private static final Logger LOGGER = LogManager.getLogger(ModInfo.NAME + "-" + Initializer.class.getSimpleName());
+	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);
+			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);
-			// throwing here should crash the game, notifying the developer that something is wrong
-			throw new RuntimeException(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() + "].");
+			MC_CLIENT.crashMinecraft("Critical programmer error: Can't read SQL Scripts resource folder is either missing or malformed. Error: [" + e.getMessage() + "].", e);
-			throw new RuntimeException(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
-//	@Override
+	public IDhApiConfigValue<Integer> getBiomeBlending()
-//	public IDhApiConfigValue<Integer> getBiomeBlending()
+	{ return new DhApiConfigValue<Integer, Integer>(Config.Client.Advanced.Graphics.Quality.lodBiomeBlending); }
-//	{ return new DhApiConfigValue<Integer, Integer>(Quality.lodBiomeBlending); }
 	
 	
 	

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

@@ -2,10 +2,10 @@ package com.seibel.distanthorizons.core.api.external.methods.data;
 
 import com.seibel.distanthorizons.api.interfaces.data.IDhApiTerrainDataCache;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+import com.seibel.distanthorizons.core.logging.DhLogger;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import it.unimi.dsi.fastutil.longs.Long2ReferenceOpenHashMap;
 import it.unimi.dsi.fastutil.longs.LongSet;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.Nullable;
 
 import java.lang.ref.SoftReference;
@@ -15,7 +15,7 @@ public class DhApiTerrainDataCache implements IDhApiTerrainDataCache
 	private final Object modificationLock = new Object();
 	private Long2ReferenceOpenHashMap<SoftReference<FullDataSourceV2>> posToFullDataRef = new Long2ReferenceOpenHashMap<>();
 	
-	private static final Logger LOGGER = LogManager.getLogger(DhApiTerrainDataCache.class.getSimpleName());
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	
 	

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

@@ -31,6 +31,7 @@ import com.seibel.distanthorizons.core.dataObjects.fullData.FullDataPointIdMap;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 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.pos.DhLodPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
@@ -48,8 +49,7 @@ import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
 import com.seibel.distanthorizons.core.util.math.Vec3d;
 import com.seibel.distanthorizons.core.util.math.Vec3i;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
-import org.apache.logging.log4j.LogManager;
+import com.seibel.distanthorizons.core.logging.DhLogger;
-import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.Nullable;
 
 import java.awt.*;
@@ -64,7 +64,7 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 {
 	public static DhApiTerrainDataRepo INSTANCE = new DhApiTerrainDataRepo();
 	
-	private static final Logger LOGGER = LogManager.getLogger(DhApiTerrainDataRepo.class.getSimpleName());
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	// debugging values
 	private static volatile boolean debugThreadRunning = false;
@@ -258,7 +258,7 @@ public class DhApiTerrainDataRepo implements IDhApiTerrainDataRepo
 			//===============================//
 			
 			FullDataPointIdMap mapping = dataSource.mapping;
-			LongArrayList dataColumn = dataSource.get(relativePos.x, relativePos.z);
+			LongArrayList dataColumn = dataSource.getColumnAtRelPos(relativePos.x, relativePos.z);
 			if (dataColumn != null)
 			{
 				int dataColumnIndexCount = dataColumn.size();
@@ -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 minLevelBlockHeight = levelWrapper.getMinHeight();
-		int maxBlockHeight = levelWrapper.getMaxHeight();
+		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,18 +23,20 @@ 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.methods.events.sharedParameterObjects.DhApiRenderParam;
+import com.seibel.distanthorizons.core.api.internal.rendering.DhRenderState;
-import com.seibel.distanthorizons.core.api.internal.rendering.RenderState;
+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.FadeRenderer;
+import com.seibel.distanthorizons.core.render.renderer.*;
 import com.seibel.distanthorizons.core.util.TimerUtil;
 import com.seibel.distanthorizons.core.util.objects.Pair;
+import com.seibel.distanthorizons.core.util.threading.PriorityTaskPicker;
+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.level.IDhClientLevel;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
 import com.seibel.distanthorizons.core.network.session.NetworkSession;
@@ -43,30 +45,23 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiDebugRendering;
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiRendererMode;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel;
-import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
-import com.seibel.distanthorizons.core.logging.ConfigBasedSpamLogger;
-import com.seibel.distanthorizons.core.logging.SpamReducedLogger;
-import com.seibel.distanthorizons.core.util.math.Mat4f;
 import com.seibel.distanthorizons.core.render.glObject.GLProxy;
-import com.seibel.distanthorizons.core.render.renderer.TestRenderer;
-import com.seibel.distanthorizons.core.util.RenderUtil;
 import com.seibel.distanthorizons.core.world.AbstractDhWorld;
-import com.seibel.distanthorizons.core.world.DhClientServerWorld;
 import com.seibel.distanthorizons.core.world.DhClientWorld;
-import com.seibel.distanthorizons.core.world.IDhClientWorld;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
-import org.apache.logging.log4j.LogManager;
+import com.seibel.distanthorizons.core.logging.DhLogger;
-import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.lwjgl.glfw.GLFW;
 
 import java.io.File;
 import java.util.*;
 import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadPoolExecutor;
 
 /**
  * This holds the methods that should be called
@@ -75,7 +70,7 @@ import java.util.concurrent.TimeUnit;
  */
 public class ClientApi
 {
-	private static final Logger LOGGER = LogManager.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	public static boolean prefLoggerEnabled = false;
 	
@@ -85,8 +80,6 @@ public class ClientApi
 	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class);
 	
-	public static final long SPAM_LOGGER_FLUSH_NS = TimeUnit.NANOSECONDS.convert(1, TimeUnit.SECONDS);
-	
 	/** this includes the is dev build message and low allocated memory warning */
 	private static final int MS_BETWEEN_STATIC_STARTUP_MESSAGES = 4_000;
 	
@@ -98,14 +91,13 @@ public class ClientApi
 	 * 
 	 * Only downside is making sure each variable is populated before rendering.
 	 */
-	public static final RenderState RENDER_STATE = new RenderState();
+	public static final DhRenderState RENDER_STATE = new DhRenderState();
 	
 	
 	private boolean isDevBuildMessagePrinted = false;
 	private boolean lowMemoryWarningPrinted = false;
 	private boolean highVanillaRenderDistanceWarningPrinted = false;
 	
-	/** when the last static */
 	private long lastStaticWarningMessageSentMsTime = 0L;
 	
 	private final Queue<String> chatMessageQueueForNextFrame = new LinkedBlockingQueue<>();
@@ -113,8 +105,6 @@ public class ClientApi
 	
 	public boolean rendererDisabledBecauseOfExceptions = false;
 	
-	private long lastFlushNanoTime = 0;
-	
 	private final ClientPluginChannelApi pluginChannelApi = new ClientPluginChannelApi(this::clientLevelLoadEvent, this::clientLevelUnloadEvent);
 	
 	/** Delay loading the first level to give the server some time to respond with level to actually load */
@@ -126,8 +116,8 @@ public class ClientApi
 	/** Holds any chunks that were loaded before the {@link ClientApi#clientLevelLoadEvent(IClientLevelWrapper)} was fired. */
 	public final HashMap<Pair<IClientLevelWrapper, DhChunkPos>, IChunkWrapper> waitingChunkByClientLevelAndPos = new HashMap<>();
 	
-	/** re-set every frame during the opaque rendering stage */
+	@Nullable
-	private boolean renderingCancelledForThisFrame;
+	public String lastRenderParamValidationMessage = null;
 	
 	
 	
@@ -167,10 +157,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("");
 				}
@@ -256,7 +246,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())
@@ -332,49 +322,6 @@ public class ClientApi
 	
 	
 	
-	//===============//
-	// render events //
-	//===============//
-	
-	public void clientTickEvent()
-	{
-		IProfilerWrapper profiler = MC_CLIENT.getProfiler();
-		profiler.push("DH-ClientTick");
-		
-		try
-		{
-			boolean doFlush = System.nanoTime() - this.lastFlushNanoTime >= SPAM_LOGGER_FLUSH_NS;
-			if (doFlush)
-			{
-				this.lastFlushNanoTime = System.nanoTime();
-				SpamReducedLogger.flushAll();
-			}
-			ConfigBasedLogger.updateAll();
-			ConfigBasedSpamLogger.updateAll(doFlush);
-			
-			IDhClientWorld clientWorld = SharedApi.getIDhClientWorld();
-			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 //
 	//============//
@@ -386,18 +333,35 @@ public class ClientApi
 	 */
 	public void pluginMessageReceived(@NotNull AbstractNetworkMessage message)
 	{
-		NetworkSession networkSession = this.pluginChannelApi.networkSession;
+		@Nullable ThreadPoolExecutor executor = ThreadPoolUtil.networkClientHandlerExecutor();
-		if (networkSession != null)
+		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");
 		}
 	}
 	
 	
 	
-	//===========//
+	//===============//
-	// rendering //
+	// LOD rendering //
-	//===========//
+	//===============//
 	
 	/** Should be called before {@link ClientApi#renderDeferredLodsForShaders} */
 	public void renderLods() { this.renderLodLayer(false); }
@@ -410,18 +374,9 @@ public class ClientApi
 	
 	private void renderLodLayer(boolean renderingDeferredLayer)
 	{
-		// A global render state variable is used since MC has split up their
+		//=========//
-		// render prep and actual rendering into different threads/methods
-		// this is annoying since it's possible to start a render with only
-		// partially complete info, but there isn't a better option at the moment
-		IClientLevelWrapper levelWrapper = RENDER_STATE.clientLevelWrapper;
-		Mat4f mcModelViewMatrix = RENDER_STATE.mcModelViewMatrix;
-		Mat4f mcProjectionMatrix = RENDER_STATE.mcProjectionMatrix;
-		float partialTicks = RENDER_STATE.frameTime;
-		
-		
-		
 		// logging //
+		//=========//
 		
 		this.sendQueuedChatMessages();
 		
@@ -431,7 +386,36 @@ public class ClientApi
 		
 		
 		
-		// render parameter setup //
+		//=====================//
+		// render thread tasks //
+		//=====================//
+		
+		// only run these tasks once per frame
+		if (!renderingDeferredLayer)
+		{
+			profiler.push("DH render thread tasks");
+			
+			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.runRenderThreadTasks();
+			}
+			catch (Exception e)
+			{
+				LOGGER.error("Unexpected issue running render thread tasks, error: [" + e.getMessage() + "].", e);
+			}
+			
+			profiler.pop();
+		}
+		
+		
+		
+		//=================//
+		// parameter setup //
+		//=================//
 		
 		EDhApiRenderPass renderPass;
 		if (DhApiRenderProxy.INSTANCE.getDeferTransparentRendering())
@@ -450,86 +434,67 @@ public class ClientApi
 			renderPass = EDhApiRenderPass.OPAQUE_AND_TRANSPARENT;
 		}
 		
-		DhApiRenderParam renderEventParam =
+		// A global render state variable is used since MC has split up their
-				new DhApiRenderParam(
+		// render prep and actual rendering into different threads/methods
-						renderPass,
+		// this is annoying since it's possible to start a render with only
-						partialTicks,
+		// partially complete info, but there isn't a better option at the moment
-						RenderUtil.getNearClipPlaneDistanceInBlocks(partialTicks), RenderUtil.getFarClipPlaneDistanceInBlocks(),
+		RenderParams renderParams =
-						mcProjectionMatrix, mcModelViewMatrix,
+			new RenderParams(
-						RenderUtil.createLodProjectionMatrix(mcProjectionMatrix, partialTicks), RenderUtil.createLodModelViewMatrix(mcModelViewMatrix),
+				renderPass,
-						levelWrapper.getMinHeight()
+				RENDER_STATE.frameTime,
-				);
+				RENDER_STATE.mcProjectionMatrix, RENDER_STATE.mcModelViewMatrix,
+				RENDER_STATE.clientLevelWrapper
+			);
 		
 		
 		
-		//Mat4f mcCombined = mcModelViewMatrix.copy();
+		//============//
-		//mcCombined.multiply(mcProjectionMatrix);
+		// validation //
-		//
+		//============//
-		//com.seibel.distanthorizons.api.objects.math.DhApiMat4f dhCombined = renderEventParam.dhModelViewMatrix.copy();
+		
-		//dhCombined.multiply(renderEventParam.dhProjectionMatrix);
+		// TODO write this message to the F3 menu so people can see when a different mod screws with the lightmap
-		//
+		String validationMessage = renderParams.getValidationErrorMessage();
-		//LOGGER.info("\n\n" +
+		if (validationMessage != null)
-		//		"API\n" +
+		{
-		//		"Mc MVM: \n" + mcModelViewMatrix.toString() + "\n" +
+			this.lastRenderParamValidationMessage = validationMessage;
-		//		"Mc Proj: \n" + mcProjectionMatrix + "\n" +
+			return;
-		//		"Mc Combined:\n" + mcCombined.toString() + "\n" +
+		}
-		//		"\n" +
+		else
-		//		"DH MVM: \n" + renderEventParam.dhModelViewMatrix.toString() + "\n" +
+		{
-		//		"DH Proj: \n" + renderEventParam.dhProjectionMatrix + "\n" +
+			this.lastRenderParamValidationMessage = null;
-		//		"DH Combined:\n" + mcCombined.toString()
+		}
-		//);
+		
+		if (this.rendererDisabledBecauseOfExceptions)
+		{
+			// re-enable rendering if the user toggles DH rendering
+			if (!Config.Client.quickEnableRendering.get())
+			{
+				LOGGER.info("DH Renderer re-enabled after exception. Some rendering issues may occur. Please reboot Minecraft if you see any rendering issues.");
+				this.rendererDisabledBecauseOfExceptions = false;
+				Config.Client.quickEnableRendering.set(true);
+			}
+			
+			return;
+		}
 		
 		
 		
-		// render validation //
+		//===========//
+		// rendering //
+		//===========//
 		
 		try
 		{
-			// TODO write this message to the F3 menu so people can see when a different mod screws with the lightmap
-			String reasonLodsCannotRender = RenderUtil.shouldLodsRender(levelWrapper, renderEventParam);
-			if (reasonLodsCannotRender != null)
-			{
-				return;
-			}
-			
-			IDhClientWorld dhClientWorld = SharedApi.getIDhClientWorld();
-			if (dhClientWorld == null)
-			{
-				return;
-			}
-			
-			IDhClientLevel level = (IDhClientLevel) dhClientWorld.getLevel(levelWrapper);
-			if (level == null)
-			{
-				return;
-			}
-			
-			
-			if (this.rendererDisabledBecauseOfExceptions)
-			{
-				// re-enable rendering if the user toggles DH rendering
-				if (!Config.Client.quickEnableRendering.get())
-				{
-					LOGGER.info("DH Renderer re-enabled after exception. Some rendering issues may occur. Please reboot Minecraft if you see any rendering issues.");
-					this.rendererDisabledBecauseOfExceptions = false;
-					Config.Client.quickEnableRendering.set(true);
-				}
-				
-				return;
-			}
-			
-			
-			
 			// render pass //
 			
 			if (!renderingDeferredLayer)
 			{
 				if (Config.Client.Advanced.Debugging.rendererMode.get() == EDhApiRendererMode.DEFAULT)
 				{
-					this.renderingCancelledForThisFrame = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderEvent.class, renderEventParam);
+					boolean renderingCancelledForThisFrame = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderEvent.class, renderParams);
-					if (!this.renderingCancelledForThisFrame)
+					if (!renderingCancelledForThisFrame)
 					{
-						level.render(renderEventParam, profiler);
+						LodRenderer.INSTANCE.render(renderParams, profiler);
 					}
 					
 					if (!DhApi.Delayed.renderProxy.getDeferTransparentRendering())
@@ -546,10 +511,10 @@ public class ClientApi
 			}
 			else
 			{
-				boolean renderingCancelled = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeDeferredRenderEvent.class, renderEventParam);
+				boolean renderingCancelled = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeDeferredRenderEvent.class, renderParams);
 				if (!renderingCancelled)
 				{
-					level.renderDeferred(renderEventParam, profiler);
+					LodRenderer.INSTANCE.renderDeferred(renderParams, profiler);
 				}
 				
 				
@@ -564,29 +529,24 @@ 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(MinecraftTextFormat.DARK_RED + "" + MinecraftTextFormat.BOLD + "ERROR: Distant Horizons renderer has encountered an exception!" + MinecraftTextFormat.CLEAR_FORMATTING);
-			MC_CLIENT.sendChatMessage("\u00A74Renderer disabled to try preventing GL state corruption.");
+			MC_CLIENT.sendChatMessage(MinecraftTextFormat.DARK_RED + "Renderer disabled to try preventing GL state corruption." + MinecraftTextFormat.CLEAR_FORMATTING);
-			MC_CLIENT.sendChatMessage("\u00A74Toggle DH rendering via the config UI to re-activate DH rendering.");
+			MC_CLIENT.sendChatMessage(MinecraftTextFormat.DARK_RED + "Toggle DH rendering via the config UI to re-activate DH rendering." + MinecraftTextFormat.CLEAR_FORMATTING);
-			MC_CLIENT.sendChatMessage("\u00A74Error: " + e);
+			MC_CLIENT.sendChatMessage(MinecraftTextFormat.DARK_RED + "Error: " + MinecraftTextFormat.CLEAR_FORMATTING + e);
-		}
-		finally
-		{
-			try
-			{
-				// these tasks always need to be called, regardless of whether the renderer is enabled or not to prevent memory leaks
-				GLProxy.getInstance().runRenderThreadTasks();
-			}
-			catch (Exception e)
-			{
-				LOGGER.error("Unexpected issue running render thread tasks.", e);
-			}
-			
-			
-			profiler.pop(); // end LOD
-			profiler.push("terrain"); // go back into "terrain"
 		}
+		
+		
+		
+		profiler.pop(); // end LOD
+		profiler.push("terrain"); // go back into "terrain"
 	}
 	
+	
+	
+	//================//
+	// fade rendering //
+	//================//
+	
 	/** 
 	 * The first fade pass.
 	 * Called after MC finishes rendering the opaque passes. 
@@ -595,12 +555,17 @@ public class ClientApi
 	{
 		// 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())
 		{
-			FadeRenderer.INSTANCE.render(RENDER_STATE.mcModelViewMatrix, RENDER_STATE.mcProjectionMatrix, RENDER_STATE.frameTime, RENDER_STATE.clientLevelWrapper);
+			VanillaFadeRenderer.INSTANCE.render(RENDER_STATE.mcModelViewMatrix, RENDER_STATE.mcProjectionMatrix, RENDER_STATE.frameTime, RENDER_STATE.clientLevelWrapper);
 		}
 	}
 	/** 
@@ -624,14 +589,13 @@ public class ClientApi
 				&& !DhApiRenderProxy.INSTANCE.getDeferTransparentRendering();
 			if (renderFade)
 			{
-				FadeRenderer.INSTANCE.render(RENDER_STATE.mcModelViewMatrix, RENDER_STATE.mcProjectionMatrix, RENDER_STATE.frameTime, RENDER_STATE.clientLevelWrapper);
+				VanillaFadeRenderer.INSTANCE.render(RENDER_STATE.mcModelViewMatrix, RENDER_STATE.mcProjectionMatrix, RENDER_STATE.frameTime, RENDER_STATE.clientLevelWrapper);
 			}
 		}
 	}
 	
 	
 	
-	
 	//=================//
 	//    DEBUG USE    //
 	//=================//
@@ -705,15 +669,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
+					MinecraftTextFormat.DARK_GREEN + "Distant Horizons: nightly/unstable build, version: [" + ModInfo.VERSION+"]." + MinecraftTextFormat.CLEAR_FORMATTING + "\n" +
-					"\u00A72" + "Distant Horizons: nightly/unstable build, version: [" + ModInfo.VERSION+"]." + "\u00A7r\n" +
 							"Issues may occur with this version.\n" +
 							"Here be dragons!\n";
 			MC_CLIENT.sendChatMessage(message);
@@ -737,7 +701,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";
@@ -751,22 +715,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
+					MinecraftTextFormat.YELLOW + "Distant Horizons: High vanilla render distance detected." + MinecraftTextFormat.CLEAR_FORMATTING + "\n" +
-						"\u00A7e" + "Distant Horizons: High vanilla render distance detected." + "\u00A7r \n" +
+					"Using a high vanilla render distance uses a lot of CPU power \n" +
-						"Using a high vanilla render distance uses a lot of CPU power \n" +
+					"and doesn't improve graphics much after about 12.\n" +
-						"and doesn't improve graphics much after about 12.\n" +
+					"Lowering your vanilla render distance will give you better FPS\n" +
-						"Lowing your vanilla render distance will give you better FPS\n" +
+					"and reduce stuttering at a similar visual quality.\n" +
-						"and reduce stuttering at a similar visual quality.\n" +
+					MinecraftTextFormat.GRAY + "A vanilla render distance of 8 is recommended." + MinecraftTextFormat.CLEAR_FORMATTING + "\n" +
-						// gray text		
+					"This message can be disabled in DH's config under Advanced -> Logging.\n";
-						"\u00A77" + "A vanilla render distance of 8 is recommended." + "\u00A7r \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

@@ -4,13 +4,14 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager;
 import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel;
-import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
+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.apache.logging.log4j.LogManager;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -22,8 +23,10 @@ import java.util.function.Consumer;
  */
 public class ClientPluginChannelApi
 {
-	private static final ConfigBasedLogger LOGGER = new ConfigBasedLogger(LogManager.getLogger(),
+	private static final DhLogger LOGGER = new DhLoggerBuilder()
-			() -> Config.Common.Logging.logNetworkEvent.get());
+			.fileLevelConfig(Config.Common.Logging.logNetworkEventToFile)
+			.build();  
+			
 	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	private static final IKeyedClientLevelManager KEYED_CLIENT_LEVEL_MANAGER = SingletonInjector.INSTANCE.get(IKeyedClientLevelManager.class);
 	
@@ -75,14 +78,19 @@ public class ClientPluginChannelApi
 	
 	private void onLevelInitMessage(LevelInitMessage msg)
 	{
-		if (!msg.levelKey.matches(LevelInitMessage.VALIDATION_REGEX))
+		if (!msg.serverKey.isEmpty() && !msg.serverKey.matches(LevelInitMessage.SERVER_KEY_REGEX))
+		{
+			throw new IllegalArgumentException("Server sent invalid server key.");
+		}
+		
+		if (!msg.levelKey.matches(LevelInitMessage.LEVEL_KEY_REGEX))
 		{
 			throw new IllegalArgumentException("Server sent invalid level key.");
 		}
 		
 		LOGGER.info("Server level key received: [" + msg.levelKey + "].");
 		
-		MC.executeOnRenderThread(() -> 
+		GLProxy.queueRunningOnRenderThread(() -> 
 		{
 			IClientLevelWrapper clientLevel = MC.getWrappedClientLevel(true);
 			IServerKeyedClientLevel existingKeyedClientLevel = KEYED_CLIENT_LEVEL_MANAGER.getServerKeyedLevel();
@@ -105,10 +113,12 @@ public class ClientPluginChannelApi
 				this.levelUnloadHandler.accept(clientLevel);
 			}
 			
-			if (existingKeyedClientLevel == null || !existingKeyedClientLevel.getServerLevelKey().equals(msg.levelKey))
+			if (existingKeyedClientLevel == null
+					|| !existingKeyedClientLevel.getServerKey().equals(msg.serverKey)
+					|| !existingKeyedClientLevel.getServerLevelKey().equals(msg.levelKey))
 			{
 				LOGGER.info("Loading level with key: [" + msg.levelKey + "].");
-				IServerKeyedClientLevel keyedLevel = KEYED_CLIENT_LEVEL_MANAGER.setServerKeyedLevel(clientLevel, msg.levelKey);
+				IServerKeyedClientLevel keyedLevel = KEYED_CLIENT_LEVEL_MANAGER.setServerKeyedLevel(clientLevel, msg.serverKey, msg.levelKey);
 				this.levelLoadHandler.accept(keyedLevel);
 			}
 		});

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

@@ -30,7 +30,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -41,7 +41,7 @@ public class ServerApi
 {
 	public static final ServerApi INSTANCE = new ServerApi();
 	
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	
 	
@@ -53,30 +53,6 @@ public class ServerApi
 	
 	
 	
-	//=============//
-	// tick events //
-	//=============//
-	
-	public void serverTickEvent()
-	{
-		try
-		{
-			IDhServerWorld serverWorld = SharedApi.getIDhServerWorld();
-			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);
+			serverWorld.getOrLoadLevel(levelWrapper);
-			ApiEventInjector.INSTANCE.fireAllEvents(DhApiLevelLoadEvent.class, new DhApiLevelLoadEvent.EventParam(level));
+			ApiEventInjector.INSTANCE.fireAllEvents(DhApiLevelLoadEvent.class, new DhApiLevelLoadEvent.EventParam(levelWrapper));
 		}
 	}
 	public void serverLevelUnloadEvent(IServerLevelWrapper level)
@@ -152,7 +128,7 @@ public class ServerApi
 			return;
 		}
 		
-		IDhServerWorld serverWorld = SharedApi.getIDhServerWorld();
+		IDhServerWorld serverWorld = SharedApi.tryGetDhServerWorld();
 		LOGGER.info("Player ["+player.getName()+"] joined.");
 		if (serverWorld != null)
 		{
@@ -166,7 +142,7 @@ public class ServerApi
 			return;
 		}
 		
-		IDhServerWorld serverWorld = SharedApi.getIDhServerWorld();
+		IDhServerWorld serverWorld = SharedApi.tryGetDhServerWorld();
 		LOGGER.info("Player ["+player.getName()+"] disconnected.");
 		if (serverWorld != null)
 		{
@@ -180,7 +156,7 @@ public class ServerApi
 			return;
 		}
 		
-		IDhServerWorld serverWorld = SharedApi.getIDhServerWorld();
+		IDhServerWorld serverWorld = SharedApi.tryGetDhServerWorld();
 		LOGGER.info("Player ["+player.getName()+"] changed level: ["+originLevel.getKeyedLevelDimensionName()+"] -> ["+destinationLevel.getKeyedLevelDimensionName()+"].");
 		if (serverWorld != null)
 		{
@@ -200,7 +176,7 @@ public class ServerApi
 			return;
 		}
 		
-		IDhServerWorld serverWorld = SharedApi.getIDhServerWorld();
+		IDhServerWorld serverWorld = SharedApi.tryGetDhServerWorld();
 		if (serverWorld != null)
 		{
 			serverWorld.getServerPlayerStateManager().handlePluginMessage(player, message);

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;
@@ -47,7 +48,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSha
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
@@ -58,7 +59,7 @@ public class SharedApi
 {
 	public static final SharedApi INSTANCE = new SharedApi();
 	
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	/** will be null on the server-side */
 	@Nullable
 	private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class);
@@ -141,24 +142,16 @@ public class SharedApi
 		}
 	}
 	
-	public static void worldGenTick(Runnable worldGenRunnable)
-	{
-		lastWorldGenTickDelta--;
-		if (lastWorldGenTickDelta <= 0)
-		{
-			worldGenRunnable.run();
-			lastWorldGenTickDelta = 20;
-		}
-	}
-	
 	@Nullable
 	public static AbstractDhWorld getAbstractDhWorld() { return currentWorld; }
-	/** returns null if the {@link SharedApi#currentWorld} isn't a {@link DhClientServerWorld} */
+	
-	public static DhClientServerWorld getDhClientServerWorld() { return (currentWorld instanceof DhClientServerWorld) ? (DhClientServerWorld) currentWorld : null; }
 	/** returns null if the {@link SharedApi#currentWorld} isn't a {@link DhClientWorld} or {@link DhClientServerWorld} */
-	public static IDhClientWorld getIDhClientWorld() { return (currentWorld instanceof IDhClientWorld) ? (IDhClientWorld) currentWorld : null; }
+	@Nullable
+	public static IDhClientWorld tryGetDhClientWorld() { return (currentWorld instanceof IDhClientWorld) ? (IDhClientWorld) currentWorld : null; }
+	
 	/** returns null if the {@link SharedApi#currentWorld} isn't a {@link DhServerWorld} or {@link DhClientServerWorld} */
-	public static IDhServerWorld getIDhServerWorld() { return (currentWorld instanceof IDhServerWorld) ? (IDhServerWorld) currentWorld : null; }
+	@Nullable
+	public static IDhServerWorld tryGetDhServerWorld() { return (currentWorld instanceof IDhServerWorld) ? (IDhServerWorld) currentWorld : null; }
 	
 	
 	
@@ -192,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)
 		{
@@ -225,7 +217,6 @@ public class SharedApi
 			return;
 		}
 		
-		
 		// only continue if the level is loaded
 		IDhLevel dhLevel = dhWorld.getLevel(level);
 		if (dhLevel == null)
@@ -240,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()))
@@ -248,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
@@ -256,94 +255,20 @@ public class SharedApi
 		}
 		
 		
-		
+		queueChunkUpdate(chunkWrapper, dhLevel);
-		//===============================//
-		// 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;
 	}
 	
-	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);
 		
 		
@@ -351,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
 			{
@@ -391,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
@@ -423,8 +346,7 @@ public class SharedApi
 		
 		IDhLevel dhLevel = preUpdateData.dhLevel;
 		IChunkWrapper chunkWrapper = preUpdateData.chunkWrapper;
-		boolean canGetNeighboringChunks = preUpdateData.canGetNeighboringChunks;
+		chunkWrapper.createDhHeightMaps();
-		ArrayList<IChunkWrapper> neighborChunkList = preUpdateData.neighborChunkList;
 		
 		try
 		{
@@ -441,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);
@@ -481,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)
 		{
@@ -491,20 +383,17 @@ public class SharedApi
 		
 		IChunkWrapper chunkWrapper = updateData.chunkWrapper;
 		IDhLevel dhLevel = updateData.dhLevel;
-		// having a list of the nearby chunks is needed for lighting and beacon generation
+		ILevelWrapper levelWrapper = dhLevel.getLevelWrapper();
-		@Nullable ArrayList<IChunkWrapper> nearbyChunkList = updateData.neighborChunkList; 
+		
+		// having a list of the nearby chunks is needed for lighting and beacon generation
+		ArrayList<IChunkWrapper> nearbyChunkList  = tryGetNeighborChunkListForChunk(chunkWrapper);
+		
 		
-		// a non-null list is needed for the lighting engine
-		if (nearbyChunkList == null)
-		{
-			nearbyChunkList = new ArrayList<IChunkWrapper>();
-			nearbyChunkList.add(chunkWrapper);
-		}
 		
 		try
 		{
 			// sky lighting is populated later at the data source level
-			DhLightingEngine.INSTANCE.bakeChunkBlockLighting(chunkWrapper, nearbyChunkList, dhLevel.hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT);
+			DhLightingEngine.INSTANCE.bakeChunkBlockLighting(chunkWrapper, nearbyChunkList, levelWrapper.hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT);
 			
 			dhLevel.updateBeaconBeamsForChunk(chunkWrapper, nearbyChunkList);
 			
@@ -515,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,21 +1,38 @@
 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 org.apache.logging.log4j.Logger;
+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
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	
 	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();
+				this.queuedChunkWrapperByChunkPos.remove(removedData.chunkWrapper.getChunkPos());
-			}
-			else
-			{
-				this.preUpdateQueue.popFurthest();
 			}
 		}
-		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/api/internal/rendering/DhRenderState.java

@@ -9,7 +9,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapp
  * 
  * @see ClientApi
  */
-public class RenderState
+public class DhRenderState
 {
 	public Mat4f mcModelViewMatrix = null;
 	public Mat4f mcProjectionMatrix = null;

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 org.apache.logging.log4j.Logger;
+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;
@@ -54,7 +53,7 @@ import java.util.List;
 @SuppressWarnings("ConcatenationWithEmptyString")
 public class Config
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	public static ConfigCategory client = new ConfigCategory.Builder().set(Client.class).build();
 	
@@ -102,11 +101,9 @@ public class Config
 				.build();
 		
 		public static ConfigUiLinkedEntry quickEnableWorldGenerator = new ConfigUiLinkedEntry(Common.WorldGenerator.enableDistantGeneration);
+		public static ConfigUiLinkedEntry quickEnableServerGeneration = new ConfigUiLinkedEntry(Server.enableServerGeneration);
 		
-		public static ConfigEntry<Boolean> quickShowWorldGenProgress = new ConfigEntry.Builder<Boolean>()
+		public static ConfigUiLinkedEntry quickShowWorldGenProgress = new ConfigUiLinkedEntry(Common.WorldGenerator.showGenerationProgress);
-				.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 quickLodCloudRendering = new ConfigUiLinkedEntry(Advanced.Graphics.GenericRendering.enableCloudRendering);
 		
@@ -126,7 +123,6 @@ public class Config
 		{
 			// 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 +168,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();
 				
 				
@@ -193,6 +203,7 @@ public class Config
 									+ "This indicates how quickly LODs decrease in quality the further away they are. \n"
 									+ "Higher settings will render higher quality fake chunks farther away, \n"
 									+ "but will increase memory and GPU usage.")
+							.addListener(ReloadLodsConfigEventHandler.DELAYED_INSTANCE)
 							.build();
 					
 					public static ConfigEntry<EDhApiMaxHorizontalResolution> maxHorizontalResolution = new ConfigEntry.Builder<EDhApiMaxHorizontalResolution>()
@@ -262,7 +273,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();
 					
@@ -311,6 +322,14 @@ public class Config
 									+ "")
 							.build();
 					
+					public static ConfigEntry<Boolean> dhFadeFarClipPlane = new ConfigEntry.Builder<Boolean>()
+							.set(true)
+							.comment(""
+									+ "Should DH fade out before reaching the far clip plane? \n"
+									+ "This is helpful to prevent DH clouds from cutting off in the distance. \n"
+									+ "")
+							.build();
+					
 					public static ConfigEntry<Double> brightnessMultiplier = new ConfigEntry.Builder<Double>() // TODO: Make this a float (the ClassicConfigGUI doesnt support floats)
 							.set(1.0)
 							.comment(""
@@ -401,6 +420,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
@@ -431,6 +458,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(""
@@ -479,11 +515,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();
 					
 					
 					
@@ -545,14 +576,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();
@@ -767,6 +790,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();
 					
@@ -815,7 +843,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"
@@ -825,11 +853,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();
+					
+					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();
+					
 				}
 				
 			}
@@ -1061,11 +1104,10 @@ public class Config
 									+ "")
 							.build();
 					
-					public static ConfigEntry<Boolean> validateBufferIdsBeforeRendering = new ConfigEntry.Builder<Boolean>()
+					public static ConfigEntry<EDhApiGpuUploadMethod> glUploadMode = new ConfigEntry.Builder<EDhApiGpuUploadMethod>()
-							.set(false)
+							.set(EDhApiGpuUploadMethod.AUTO)
 							.comment(""
-									+ "Massively reduces FPS. \n"
+									+ "\n"
-									+ "Should only be used if mysterious EXCEPTION_ACCESS_VIOLATION crashes are happening in DH's rendering code for troubleshooting. \n"
 									+ "")
 							.build();
 					
@@ -1212,23 +1254,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(() -> 
+						new Thread(() -> onButtonPressed()).start();
-						{
-							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();
 					});
+					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();
 					
@@ -1344,6 +1380,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
@@ -1354,7 +1421,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"
@@ -1369,37 +1436,9 @@ public class Config
 					.build();
 			
 			public static ConfigEntry<EDhApiDataCompressionMode> dataCompression = new ConfigEntry.Builder<EDhApiDataCompressionMode>()
-					.set(EDhApiDataCompressionMode.Z_STD)
+					.set(EDhApiDataCompressionMode.Z_STD_BLOCK)
-					.comment(""
+					// only visible via the API since there is no reason to use any compressor except ZStandard as of 2025-11-24
-							+ "What algorithm should be used to compress new LOD data? \n"
+					.setAppearance(EConfigEntryAppearance.ONLY_IN_API)
-							+ "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"
-							+ "")
 					.build();
 			
 			public static ConfigEntry<EDhApiWorldCompressionMode> worldCompression = new ConfigEntry.Builder<EDhApiWorldCompressionMode>()
@@ -1422,49 +1461,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();
 			
 			
@@ -1506,6 +1502,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)
@@ -1519,6 +1516,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();
+			
 			
 			
 		}
@@ -1527,54 +1537,79 @@ public class Config
 		{
 			public static ConfigUIComment loggingHeader = new ConfigUIComment.Builder().setParentConfigClass(Logging.class).build();
 			
-			// TODO add change all option
+			
-			// TODO default to error chat and info file
+			public static ConfigEntry<EDhApiLoggerLevel> globalFileMaxLevel = new ConfigEntry.Builder<EDhApiLoggerLevel>()
-			public static ConfigEntry<EDhApiLoggerMode> logWorldGenEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
+					.setChatCommandName("logging.globalFileMaxLevel")
+					.set(EDhApiLoggerLevel.INFO)
+					.comment(""
+							+ ""
+							+ "")
+					.build();
+			
+			public static ConfigEntry<EDhApiLoggerLevel> globalChatMaxLevel = new ConfigEntry.Builder<EDhApiLoggerLevel>()
+					.setChatCommandName("logging.globalChatMaxLevel")
+					.set(EDhApiLoggerLevel.ERROR)
+					.comment(""
+							+ ""
+							+ "")
+					.build();
+			
+			public static ConfigUISpacer globalLoggingSpacer = new ConfigUISpacer.Builder().build();
+			
+			
+			public static ConfigEntry<EDhApiLoggerLevel> logWorldGenEventToFile = new ConfigEntry.Builder<EDhApiLoggerLevel>()
 					.setChatCommandName("logging.logWorldGenEvent")
-					.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
+					.set(EDhApiLoggerLevel.INFO)
 					.comment(""
 							+ "If enabled, the mod will log information about the world generation process. \n"
 							+ "This can be useful for debugging.")
 					.build();
 			
-			public static ConfigEntry<EDhApiLoggerMode> logWorldGenPerformance = new ConfigEntry.Builder<EDhApiLoggerMode>()
+			public static ConfigEntry<EDhApiLoggerLevel> logWorldGenChunkLoadEventToFile = new ConfigEntry.Builder<EDhApiLoggerLevel>()
-					.setChatCommandName("logging.logWorldGenPerformance")
-					.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
-					.comment(""
-							+ "If enabled, the mod will log performance about the world generation process. \n"
-							+ "This can be useful for debugging.")
-					.build();
-			
-			public static ConfigEntry<EDhApiLoggerMode> logWorldGenLoadEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
 					.setChatCommandName("logging.logWorldGenLoadEvent")
-					.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
+					.set(EDhApiLoggerLevel.INFO)
 					.comment(""
 							+ "If enabled, the mod will log information about the world generation process. \n"
 							+ "This can be useful for debugging.")
 					.build();
 			
-			public static ConfigEntry<EDhApiLoggerMode> logRendererBufferEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
+			public static ConfigEntry<EDhApiLoggerLevel> logRendererEventToFile = new ConfigEntry.Builder<EDhApiLoggerLevel>()
-					.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
+					.set(EDhApiLoggerLevel.INFO)
 					.comment(""
-							+ "If enabled, the mod will log information about the renderer buffer process. \n"
+							+ "If enabled, the mod will log information about the renderer setup, cleanup, and any issues it may encounter. \n"
 							+ "This can be useful for debugging.")
 					.build();
 			
-			public static ConfigEntry<EDhApiLoggerMode> logRendererGLEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
+			public static ConfigEntry<EDhApiLoggerLevel> logRendererGLEventToFile = new ConfigEntry.Builder<EDhApiLoggerLevel>()
-					.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
+					.set(EDhApiLoggerLevel.INFO)
 					.comment(""
 							+ "If enabled, the mod will log information about the renderer OpenGL process. \n"
 							+ "This can be useful for debugging.")
 					.build();
 			
-			public static ConfigEntry<EDhApiLoggerMode> logNetworkEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
+			public static ConfigEntry<EDhApiLoggerLevel> logRendererGLEventToChat = new ConfigEntry.Builder<EDhApiLoggerLevel>()
+					.set(EDhApiLoggerLevel.ERROR)
+					.comment(""
+							+ "If enabled, the mod will log information about the renderer OpenGL process. \n"
+							+ "This can be useful for debugging.")
+					.build();
+			
+			public static ConfigEntry<EDhApiLoggerLevel> logNetworkEventToFile = new ConfigEntry.Builder<EDhApiLoggerLevel>()
 					.setChatCommandName("logging.logNetworkEvent")
-					.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_WARNING_TO_FILE)
+					.set(EDhApiLoggerLevel.INFO)
 					.comment(""
 							+ "If enabled, the mod will log information about network operations. \n"
 							+ "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();
 			
 			
@@ -1623,6 +1658,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(""
@@ -1631,6 +1674,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();
+				
 			}
 		}
 		
@@ -1649,6 +1701,28 @@ public class Config
 						+ "")
 				.build();
 		
+		public static ConfigEntry<Integer> serverId = new ConfigEntry.Builder<Integer>()
+				.set(new Random().nextInt())
+				.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE)
+				.comment(""
+						+ "DO NOT CHANGE UNLESS YOU KNOW WHAT YOU'RE DOING.\n"
+						+ "Autogenerated ID used to prevent multiple independent servers from accidentally\n"
+						+ "writing over each other's LODs when the same serverKey is set on both.\n"
+						+ "")
+				.build();
+		
+		public static ConfigEntry<String> serverKey = new ConfigEntry.Builder<String>()
+				.setChatCommandName("levelKeys.serverKey")
+				.setAppearance(EConfigEntryAppearance.ONLY_IN_FILE)
+				.set("")
+				.comment(""
+						+ "Custom server key used which can be used to always reuse the same LOD data folder,\n"
+						+ "for cases when the server doesn't have a static IP for some reason.\n"
+						+ "If this value is empty, the client itself decides which folder name to use.\n"
+						+ "Requires rejoining the server to apply after changing.\n"
+						+ "")
+				.build();
+		
 		public static ConfigEntry<String> levelKeyPrefix = new ConfigEntry.Builder<String>()
 				.setChatCommandName("levelKeys.prefix")
 				.set("")
@@ -1661,6 +1735,15 @@ public class Config
 		
 		
 		// Generation
+		public static ConfigEntry<Boolean> enableServerGeneration = new ConfigEntry.Builder<Boolean>()
+			.set(true)
+			.comment(""
+				+ "When enabled, Distant Horizons will attempt to download missing LODs from the server.\n"
+				+ "\n"
+				+ "Note: the server must have Distant Generation enabled for it to work."
+				+ "")
+			.build();
+		
 		public static ConfigEntry<Integer> generationRequestRateLimit = new ConfigEntry.Builder<Integer>()
 				.setChatCommandName("generation.requestRateLimit")
 				.setMinDefaultMax(1, 20, 100)
@@ -1678,32 +1761,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>()
@@ -1824,7 +1881,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/ConfigHandler.java

@@ -26,7 +26,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.wrapperInterfaces.config.ILangWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
 import com.seibel.distanthorizons.coreapi.ModInfo;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.lang.reflect.Field;
 import java.nio.file.Path;
@@ -44,7 +44,7 @@ import java.util.*;
  */
 public class ConfigHandler
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	private static final IMinecraftSharedWrapper MC_SHARED = SingletonInjector.INSTANCE.get(IMinecraftSharedWrapper.class);
 	
@@ -123,6 +123,7 @@ public class ConfigHandler
 		this.initNestedClass(Config.class, ""); // Init root category
 		
 		this.configFileHandler.loadFromFile();
+		this.runMinMaxValidation = !Config.Client.Advanced.Debugging.allowUnsafeValues.get();
 		
 		this.isLoaded = true;
 		LOGGER.info("[" + ModInfo.NAME + "] Config initialised");

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>
+ * Used to support deprecated config options that may be identical
- * SINGLE_THREADED, <br>
+ * in implementation but with the On/Off values flipped.
- * SERVER_THREAD, <br>
  *
  * @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,
 	
-	/**
+	@Override 
-	 * This world generator can only be run on one thread at
+	public Boolean convertToCoreType(Boolean core)
-	 * a time, however that thread can run concurrently
+	{ return !core; }
-	 * to Minecraft's server thread.
+	
-	 */
+	@Override 
-	SINGLE_THREADED,
+	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/AbstractPresetConfigEventHandler.java

@@ -24,18 +24,19 @@ import com.seibel.distanthorizons.core.config.ConfigPresetOptions;
 import com.seibel.distanthorizons.core.config.listeners.IConfigListener;
 import com.seibel.distanthorizons.core.config.types.AbstractConfigBase;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.util.TimerUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.config.IConfigGui;
 import com.seibel.distanthorizons.coreapi.util.StringUtil;
 import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 
 public abstract class AbstractPresetConfigEventHandler<TPresetEnum extends Enum<?>> implements IConfigListener
 {
-	private static final Logger LOGGER = LogManager.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	private static final long MS_DELAY_BEFORE_APPLYING_PRESET = 3_000;
 	
 	@Nullable
@@ -139,7 +140,7 @@ public abstract class AbstractPresetConfigEventHandler<TPresetEnum extends Enum<
 		
 		
 		
-		LOGGER.info("changing preset to: " + newPresetEnum);
+		LOGGER.debug("changing preset to: [" + newPresetEnum + "].");
 		this.changingPreset = true;
 		
 		// update the controlled config values
@@ -151,7 +152,7 @@ public abstract class AbstractPresetConfigEventHandler<TPresetEnum extends Enum<
 		this.setUiOnlyConfigValues();
 		
 		this.changingPreset = false;
-		LOGGER.info("preset active: " + newPresetEnum);
+		LOGGER.debug("preset active: [" + newPresetEnum + "].");
 	}
 	
 	/**

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/eventHandlers/presets/RenderQualityPresetConfigEventHandler.java

@@ -29,8 +29,8 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.config.ConfigPresetOptions;
 import com.seibel.distanthorizons.core.config.listeners.ConfigChangeListener;
 import com.seibel.distanthorizons.core.config.types.AbstractConfigBase;
-import org.apache.logging.log4j.LogManager;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.util.*;
 
@@ -39,7 +39,7 @@ public class RenderQualityPresetConfigEventHandler extends AbstractPresetConfigE
 {
 	public static final RenderQualityPresetConfigEventHandler INSTANCE = new RenderQualityPresetConfigEventHandler();
 	
-	private static final Logger LOGGER = LogManager.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	
 	private final ConfigPresetOptions<EDhApiQualityPreset, EDhApiMaxHorizontalResolution> drawResolution = new ConfigPresetOptions<>(Config.Client.Advanced.Graphics.Quality.maxHorizontalResolution,
@@ -96,6 +96,15 @@ public class RenderQualityPresetConfigEventHandler extends AbstractPresetConfigE
 				this.put(EDhApiQualityPreset.HIGH, EDhApiMcRenderingFadeMode.DOUBLE_PASS);
 				this.put(EDhApiQualityPreset.EXTREME, EDhApiMcRenderingFadeMode.DOUBLE_PASS);
 			}});
+	private final ConfigPresetOptions<EDhApiQualityPreset, Boolean> dhFadeFarClipPlane = new ConfigPresetOptions<>(Config.Client.Advanced.Graphics.Quality.dhFadeFarClipPlane,
+			new HashMap<EDhApiQualityPreset, Boolean>()
+			{{
+				this.put(EDhApiQualityPreset.MINIMUM, false);
+				this.put(EDhApiQualityPreset.LOW, false);
+				this.put(EDhApiQualityPreset.MEDIUM, true);
+				this.put(EDhApiQualityPreset.HIGH, true);
+				this.put(EDhApiQualityPreset.EXTREME, true);
+			}});
 	private final ConfigPresetOptions<EDhApiQualityPreset, Boolean> dhDither = new ConfigPresetOptions<>(Config.Client.Advanced.Graphics.Quality.ditherDhFade,
 			new HashMap<EDhApiQualityPreset, Boolean>()
 			{{
@@ -139,6 +148,7 @@ public class RenderQualityPresetConfigEventHandler extends AbstractPresetConfigE
 		this.configList.add(this.horizontalQuality);
 		this.configList.add(this.transparency);
 		this.configList.add(this.ssaoEnabled);
+		this.configList.add(this.dhFadeFarClipPlane);
 		this.configList.add(this.vanillaFade);
 		this.configList.add(this.dhDither);
 		this.configList.add(this.caveCulling);

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

@@ -24,9 +24,10 @@ import com.seibel.distanthorizons.core.config.listeners.ConfigChangeListener;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.config.ConfigPresetOptions;
 import com.seibel.distanthorizons.core.config.types.AbstractConfigBase;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.coreapi.util.MathUtil;
 import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.util.Arrays;
 import java.util.HashMap;
@@ -37,7 +38,7 @@ public class ThreadPresetConfigEventHandler extends AbstractPresetConfigEventHan
 {
 	public static final ThreadPresetConfigEventHandler INSTANCE = new ThreadPresetConfigEventHandler();
 	
-	private static final Logger LOGGER = LogManager.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	
 	public static int getDefaultThreadCount() { return getThreadCountByPercent(0.5); }

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 org.apache.logging.log4j.Logger;
+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;
@@ -43,13 +45,11 @@ import java.util.concurrent.locks.ReentrantLock;
  */
 public class ConfigFileHandler
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	
 	public final Path configPath;
 	
-	private final Logger logger;
-	
 	/** This is the object for night-config */
 	private final CommentedFileConfig nightConfig;
 	
@@ -64,7 +64,6 @@ public class ConfigFileHandler
 	
 	public ConfigFileHandler(Path configPath)
 	{
-		this.logger = LogManager.getLogger(this.getClass().getSimpleName() + ", " + ModInfo.ID);
 		this.configPath = configPath;
 		
 		this.nightConfig = CommentedFileConfig
@@ -157,18 +156,18 @@ public class ConfigFileHandler
 			}
 			else if (currentCfgVersion > ModInfo.CONFIG_FILE_VERSION)
 			{
-				this.logger.warn("Found config version [" + currentCfgVersion + "] which is newer than current mods config version of [" + ModInfo.CONFIG_FILE_VERSION + "]. You may have downgraded the mod and items may have been moved, you have been warned");
+				LOGGER.warn("Found config version [" + currentCfgVersion + "] which is newer than current mods config version of [" + ModInfo.CONFIG_FILE_VERSION + "]. You may have downgraded the mod and items may have been moved, you have been warned");
 			}
 			else // if (currentCfgVersion < configBase.configVersion)
 			{
-				this.logger.warn(ModInfo.NAME + " config is of an older version, currently there is no config updater... so resetting config");
+				LOGGER.warn(ModInfo.NAME + " config is of an older version, currently there is no config updater... so resetting config");
 				try
 				{
 					Files.delete(this.configPath);
 				}
 				catch (Exception e)
 				{
-					this.logger.error(e);
+					LOGGER.error("Unable to delete outdated config file at: ["+this.configPath+"], error: ["+e.getMessage()+"].", e);
 				}
 			}
 			
@@ -243,7 +242,7 @@ public class ConfigFileHandler
 		else if (entry.getTrueValue() == null)
 		{
 			// TODO when can this happen?
-			throw new IllegalArgumentException("Entry [" + entry.getNameAndCategory() + "] is null, this may be a problem with [" + ModInfo.NAME + "]. Please contact the authors.");
+			throw new IllegalArgumentException("BlockBiomeWrapperPair [" + entry.getNameAndCategory() + "] is null, this may be a problem with [" + ModInfo.NAME + "]. Please contact the authors.");
 		}
 		
 		workConfig.set(entry.getNameAndCategory(), ConfigTypeConverters.attemptToConvertToString(entry.getType(), entry.getTrueValue()));
@@ -281,7 +280,7 @@ public class ConfigFileHandler
 			Object convertedValue = ConfigTypeConverters.attemptToConvertFromString(expectedValueClass, value);
 			if (!convertedValue.getClass().equals(expectedValueClass))
 			{
-				this.logger.error("Unable to convert config value ["+value+"] from ["+(value != null ? value.getClass() : "NULL")+"] to ["+expectedValueClass+"] for config ["+entry.name+"], " +
+				LOGGER.error("Unable to convert config value ["+value+"] from ["+(value != null ? value.getClass() : "NULL")+"] to ["+expectedValueClass+"] for config ["+entry.name+"], " +
 						"the default config value will be used instead ["+entry.getDefaultValue()+"]. " +
 						"Make sure a converter is defined in ["+ConfigTypeConverters.class.getSimpleName()+"].");
 				convertedValue = entry.getDefaultValue();
@@ -290,13 +289,13 @@ public class ConfigFileHandler
 			
 			if (entry.getTrueValue() == null) 
 			{
-				this.logger.warn("Entry [" + entry.getNameAndCategory() + "] returned as null from the config. Using default value.");
+				LOGGER.warn("BlockBiomeWrapperPair [" + entry.getNameAndCategory() + "] returned as null from the config. Using default value.");
 				entry.setWithoutFiringEvents(entry.getDefaultValue());
 			}
 		}
 		catch (Exception e)
 		{
-			this.logger.warn("Entry [" + entry.getNameAndCategory() + "] had an invalid value when loading the config. Using default value.");
+			LOGGER.warn("BlockBiomeWrapperPair [" + entry.getNameAndCategory() + "] had an invalid value when loading the config. Using default value.");
 			entry.setWithoutFiringEvents(entry.getDefaultValue());
 		}
 	}
@@ -350,18 +349,20 @@ public class ConfigFileHandler
 			}
 			catch (Exception e)
 			{
-				this.logger.warn("Loading file failed because of this expectation:\n" + e);
+				LOGGER.warn("Loading file failed because of this expectation:\n" + e);
 				
 				reCreateFile(this.configPath);
 				
 				nightConfig.load();
 			}
 		}
-		catch (Exception ex)
+		catch (Exception e)
 		{
-			System.out.println("Creating file failed");
+			LOGGER.error("File creation failed at ["+this.configPath+"], error: ["+e.getMessage()+"].", e);
-			this.logger.error(ex);
+			
-			SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class).crashMinecraft("Loading file and resetting config file failed at path [" + this.configPath + "]. Please check the file is ok and you have the permissions", ex);
+			// TODO is there a reason this is lazily gotten?
+			IMinecraftClientWrapper mc = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
+			mc.crashMinecraft("Loading file and resetting config file failed at path [" + this.configPath + "]. Please check the file is ok and you have the permissions", e);
 		}
 	}
 	

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

@@ -23,7 +23,7 @@ import com.electronwill.nightconfig.core.Config;
 import com.electronwill.nightconfig.core.io.ParsingMode;
 import com.electronwill.nightconfig.json.JsonFormat;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -36,7 +36,7 @@ import java.util.Map;
  */
 public class ConfigTypeConverters
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	// Once you've made a converter add it to here where the first value is the type you want to convert and the 2nd value is the converter
 	public static final Map<Class<?>, ConverterBase> convertObjects = new HashMap<Class<?>, ConverterBase>()

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

@@ -23,7 +23,7 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.config.types.enums.EConfigCommentTextPosition;
 import com.seibel.distanthorizons.core.config.types.enums.EConfigEntryAppearance;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -34,7 +34,7 @@ import org.jetbrains.annotations.Nullable;
  */
 public class ConfigUIComment extends AbstractConfigBase<String>
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	
 	public String parentConfigPath = null;

core/src/main/java/com/seibel/distanthorizons/core/dataObjects/BlockBiomeWrapperPair.java

@@ -0,0 +1,151 @@
+package com.seibel.distanthorizons.core.dataObjects;
+
+import com.seibel.distanthorizons.core.dataObjects.fullData.FullDataPointIdMap;
+import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
+import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
+import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
+import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A pooled compound key between the biome and blockState. <br>
+ * These objects are pooled since we will need this compound key
+ * many times.
+ * 
+ * @see FullDataPointIdMap
+ * @see IBlockStateWrapper
+ * @see IBiomeWrapper
+ */
+public class BlockBiomeWrapperPair
+{
+	private static final IWrapperFactory WRAPPER_FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
+	
+	/** two levels are present so we don't need to use a key object */
+	private static final ConcurrentHashMap<IBlockStateWrapper, ConcurrentHashMap<IBiomeWrapper, BlockBiomeWrapperPair>> CACHED_PAIR_BY_BIOME_BY_BLOCK = new ConcurrentHashMap<>();
+	
+	public final IBiomeWrapper biome;
+	public final IBlockStateWrapper blockState;
+	
+	private int hashCode = 0;
+	private boolean hashGenerated = false;
+	private String serialString = null;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public static BlockBiomeWrapperPair get(IBlockStateWrapper blockState, IBiomeWrapper biome)
+	{
+		// check for existing entry
+		ConcurrentHashMap<IBiomeWrapper, BlockBiomeWrapperPair> pairByBiomeWrapper = CACHED_PAIR_BY_BIOME_BY_BLOCK.get(blockState);
+		if (pairByBiomeWrapper != null)
+		{
+			BlockBiomeWrapperPair pair = pairByBiomeWrapper.get(biome);
+			if (pair != null)
+			{
+				return pair;
+			}
+		}
+		
+		// Lazily create the inner map and new BlockBiomeWrapperPair
+		return CACHED_PAIR_BY_BIOME_BY_BLOCK
+				.computeIfAbsent(blockState, newBlockState -> new ConcurrentHashMap<>())
+				.computeIfAbsent(biome, newBiome -> new BlockBiomeWrapperPair(biome, blockState));
+	}
+	private BlockBiomeWrapperPair(IBiomeWrapper biome, IBlockStateWrapper blockState)
+	{
+		this.biome = biome;
+		this.blockState = blockState;
+	}
+	
+	
+	
+	//===========//
+	// overrides //
+	//===========//
+	
+	/** 
+	 * Reminder: this hash code won't always be unique, collisions can occur;
+	 * because of that this hash shouldn't be the only unique identifier for this object.
+	 */
+	@Override
+	public int hashCode()
+	{
+		// cache the hash code to improve speed
+		if (!this.hashGenerated)
+		{
+			this.hashCode = generateHashCode(this);
+			this.hashGenerated = true;
+		}
+		
+		return this.hashCode;
+	}
+	private static int generateHashCode(BlockBiomeWrapperPair pair) { return generateHashCode(pair.biome, pair.blockState); }
+	private static int generateHashCode(IBiomeWrapper biome, IBlockStateWrapper blockState)
+	{
+		final int prime = 31;
+		
+		int result = 1;
+		// the biome and blockstate hashcode should be already calculated by the time
+		// we get here, so this operation should be very fast
+		result = prime * result + (biome == null ? 0 : biome.hashCode());
+		result = prime * result + (blockState == null ? 0 : blockState.hashCode());
+		return result;
+	}
+	
+	@Override
+	public boolean equals(Object otherObj)
+	{
+		if (otherObj == this)
+		{
+			return true;
+		}
+		
+		if (!(otherObj instanceof BlockBiomeWrapperPair))
+		{
+			return false;
+		}
+		
+		BlockBiomeWrapperPair other = (BlockBiomeWrapperPair) otherObj;
+		return other.biome.getSerialString().equals(this.biome.getSerialString())
+				&& other.blockState.getSerialString().equals(this.blockState.getSerialString());
+	}
+	
+	@Override
+	public String toString() { return this.serialize(); }
+	
+	
+	
+	//=================//
+	// (de)serializing //
+	//=================//
+	
+	public String serialize() 
+	{
+		if (this.serialString == null)
+		{
+			this.serialString = this.biome.getSerialString() + FullDataPointIdMap.BLOCK_STATE_SEPARATOR_STRING + this.blockState.getSerialString();
+		}
+		
+		return this.serialString;
+	}
+	
+	public static BlockBiomeWrapperPair deserialize(String str, ILevelWrapper levelWrapper) throws DataCorruptedException
+	{
+		int separatorIndex = str.indexOf(FullDataPointIdMap.BLOCK_STATE_SEPARATOR_STRING);
+		if (separatorIndex == -1)
+		{
+			throw new DataCorruptedException("Failed to deserialize BiomeBlockStateEntry ["+str+"], unable to find separator.");
+		}
+		
+		IBiomeWrapper biome = WRAPPER_FACTORY.deserializeBiomeWrapperOrGetDefault(str.substring(0, separatorIndex), levelWrapper);
+		IBlockStateWrapper blockState = WRAPPER_FACTORY.deserializeBlockStateWrapperOrGetDefault(str.substring(separatorIndex+FullDataPointIdMap.BLOCK_STATE_SEPARATOR_STRING.length()), levelWrapper);
+		return BlockBiomeWrapperPair.get(blockState, biome);
+	}
+	
+}

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

@@ -19,7 +19,8 @@
 
 package com.seibel.distanthorizons.core.dataObjects.fullData;
 
-import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
+import com.seibel.distanthorizons.core.dataObjects.BlockBiomeWrapperPair;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
@@ -27,10 +28,8 @@ import com.seibel.distanthorizons.core.util.objects.dataStreams.DhDataInputStrea
 import com.seibel.distanthorizons.core.util.objects.dataStreams.DhDataOutputStream;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
-import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
-import org.apache.logging.log4j.LogManager;
+import com.seibel.distanthorizons.core.logging.DhLogger;
-import org.apache.logging.log4j.Logger;
 
 import java.io.*;
 import java.util.*;
@@ -51,7 +50,7 @@ import java.util.concurrent.ConcurrentHashMap;
  */
 public class FullDataPointIdMap
 {
-	private static final Logger LOGGER = LogManager.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	/**
 	 * Should only be enabled when debugging.
 	 * Has the system check if any duplicate Entries were read/written
@@ -59,15 +58,15 @@ public class FullDataPointIdMap
 	 */
 	private static final boolean RUN_SERIALIZATION_DUPLICATE_VALIDATION = false;
 	/** Distant Horizons - Block State Wrapper */
-	private static final String BLOCK_STATE_SEPARATOR_STRING = "_DH-BSW_";
+	public static final String BLOCK_STATE_SEPARATOR_STRING = "_DH-BSW_";
 	
 	
 	/** should only be used for debugging */
 	private long pos;
 	
-	/** The index should be the same as the Entry's ID */
+	/** The index should be the same as the BlockBiomeWrapperPair's ID */
-	private final ArrayList<Entry> entryList = new ArrayList<>();
+	private final ArrayList<BlockBiomeWrapperPair> blockBiomePairList = new ArrayList<>();
-	private final ConcurrentHashMap<Entry, Integer> idMap = new ConcurrentHashMap<>();
+	private final ConcurrentHashMap<BlockBiomeWrapperPair, Integer> idMap = new ConcurrentHashMap<>();
 	
 	private int cachedHashCode = 0;
 	
@@ -89,28 +88,28 @@ public class FullDataPointIdMap
 	public IBiomeWrapper getBiomeWrapper(int id) throws IndexOutOfBoundsException { return this.getEntry(id).biome; }
 	/** @see FullDataPointIdMap#getEntry(int) */
 	public IBlockStateWrapper getBlockStateWrapper(int id) throws IndexOutOfBoundsException { return this.getEntry(id).blockState; }
-	/** @throws IndexOutOfBoundsException if the given ID isn't in the {@link FullDataPointIdMap#entryList} */
+	/** @throws IndexOutOfBoundsException if the given ID isn't in the {@link FullDataPointIdMap#blockBiomePairList} */
-	private Entry getEntry(int id) throws IndexOutOfBoundsException
+	private BlockBiomeWrapperPair getEntry(int id) throws IndexOutOfBoundsException
 	{
-		Entry entry;
+		BlockBiomeWrapperPair pair;
 		try
 		{
-			entry = this.entryList.get(id);
+			pair = this.blockBiomePairList.get(id);
 		}
 		catch (IndexOutOfBoundsException e)
 		{
-			throw new IndexOutOfBoundsException("FullData ID Map out of sync for pos: "+this.pos+". ID: ["+id+"] greater than the number of known ID's: ["+this.entryList.size()+"].");
+			throw new IndexOutOfBoundsException("FullData ID Map out of sync for pos: "+DhSectionPos.toString(this.pos)+". ID: ["+id+"] greater than the number of known ID's: ["+this.blockBiomePairList.size()+"].");
 		}
 		
-		return entry;
+		return pair;
 	}
 	
 	
 	/** @return -1 if the list is empty */
-	public int getMaxValidId() { return this.entryList.size() - 1; }
+	public int getMaxValidId() { return this.blockBiomePairList.size() - 1; }
-	public int size() { return this.entryList.size(); }
+	public int size() { return this.blockBiomePairList.size(); }
 	
-	public boolean isEmpty() { return this.entryList.isEmpty(); }
+	public boolean isEmpty() { return this.blockBiomePairList.isEmpty(); }
 	
 	public long getPos() { return this.pos; }
 	
@@ -124,11 +123,11 @@ public class FullDataPointIdMap
 	 * If an entry with the given values already exists nothing will
 	 * be added but the existing item's ID will still be returned.
 	 */
-	public int addIfNotPresentAndGetId(IBiomeWrapper biome, IBlockStateWrapper blockState) { return this.addIfNotPresentAndGetId(Entry.getEntry(biome, blockState)); }
+	public int addIfNotPresentAndGetId(IBiomeWrapper biome, IBlockStateWrapper blockState) { return this.addIfNotPresentAndGetId(BlockBiomeWrapperPair.get(blockState, biome)); }
-	private int addIfNotPresentAndGetId(Entry biomeBlockStateEntry)
+	private int addIfNotPresentAndGetId(BlockBiomeWrapperPair pair)
 	{
 		// try getting the existing ID
-		Integer nullableId = this.idMap.get(biomeBlockStateEntry);
+		Integer nullableId = this.idMap.get(pair);
 		if (nullableId != null)
 		{
 			return nullableId;
@@ -136,7 +135,7 @@ public class FullDataPointIdMap
 		
 		
 		// create the new ID
-		return this.idMap.compute(biomeBlockStateEntry, (Entry newBiomeBlockStateEntry, Integer currentId) -> 
+		return this.idMap.compute(pair, (BlockBiomeWrapperPair newPair, Integer currentId) -> 
 		{
 			if (currentId != null)
 			{
@@ -145,8 +144,8 @@ public class FullDataPointIdMap
 			
 			
 			// Add the new ID
-			currentId = this.entryList.size();
+			currentId = this.blockBiomePairList.size();
-			this.entryList.add(biomeBlockStateEntry);
+			this.blockBiomePairList.add(newPair);
 			
 			// invalidate the cached hash code
 			this.cachedHashCode = 0;
@@ -156,7 +155,7 @@ public class FullDataPointIdMap
 	}
 	
 	/**
-	 * Adds every {@link Entry} from inputMap into this map. <br>
+	 * Adds every {@link BlockBiomeWrapperPair} from inputMap into this map. <br>
 	 * Allows duplicate entries. <br><br>
 	 * 
 	 * Allowing duplicate entries should be done if a datasource is just being read in and 
@@ -166,19 +165,19 @@ public class FullDataPointIdMap
 	 */
 	public void addAll(FullDataPointIdMap inputMap)
 	{
-		ArrayList<Entry> entriesToMerge = inputMap.entryList;
+		ArrayList<BlockBiomeWrapperPair> pairsToMerge = inputMap.blockBiomePairList;
-		for (int i = 0; i < entriesToMerge.size(); i++)
+		for (int i = 0; i < pairsToMerge.size(); i++)
 		{
-			Entry entity = entriesToMerge.get(i);
+			BlockBiomeWrapperPair pair = pairsToMerge.get(i);
-			this.add(entity);
+			this.add(pair);
 		}
 	}
-	/** allows for adding duplicate {@link Entry} */
+	/** allows for adding duplicate {@link BlockBiomeWrapperPair} */
-	private void add(Entry biomeBlockStateEntry)
+	private void add(BlockBiomeWrapperPair pair)
 	{
-		int id = this.entryList.size();
+		int id = this.blockBiomePairList.size();
-		this.entryList.add(biomeBlockStateEntry);
+		this.blockBiomePairList.add(pair);
-		this.idMap.put(biomeBlockStateEntry, id);
+		this.idMap.put(pair, id);
 		
 		// invalidate the cached hash code
 		this.cachedHashCode = 0;
@@ -195,23 +194,23 @@ public class FullDataPointIdMap
 	 */
 	public int[] mergeAndReturnRemappedEntityIds(FullDataPointIdMap inputMap)
 	{
-		ArrayList<Entry> entriesToMerge = inputMap.entryList;
+		ArrayList<BlockBiomeWrapperPair> entriesToMerge = inputMap.blockBiomePairList;
-		int[] remappedEntryIds = new int[entriesToMerge.size()];
+		int[] remappedPairIds = new int[entriesToMerge.size()];
 		for (int i = 0; i < entriesToMerge.size(); i++)
 		{
-			Entry entity = entriesToMerge.get(i);
+			BlockBiomeWrapperPair entity = entriesToMerge.get(i);
 			int id = this.addIfNotPresentAndGetId(entity);
-			remappedEntryIds[i] = id;
+			remappedPairIds[i] = id;
 		}
 		
-		return remappedEntryIds;
+		return remappedPairIds;
 	}
 	
 	/** Should only be used if this map is going to be reused, otherwise bad things will happen. */
 	public void clear(long pos)
 	{
 		this.pos = pos;
-		this.entryList.clear();
+		this.blockBiomePairList.clear();
 		this.idMap.clear();
 		this.cachedHashCode = 0;
 	}
@@ -225,27 +224,27 @@ public class FullDataPointIdMap
 	/** Serializes all contained entries into the given stream, formatted in UTF */
 	public void serialize(DhDataOutputStream outputStream) throws IOException
 	{
-		outputStream.writeInt(this.entryList.size());
+		outputStream.writeInt(this.blockBiomePairList.size());
 		
 		// only used when debugging
-		HashMap<String, FullDataPointIdMap.Entry> dataPointEntryBySerialization = new HashMap<>();
+		HashMap<String, BlockBiomeWrapperPair> dataPointEntryBySerialization = new HashMap<>();
 		
-		for (Entry entry : this.entryList)
+		for (BlockBiomeWrapperPair pair : this.blockBiomePairList)
 		{
-			String entryString = entry.serialize();
+			String entryString = pair.serialize();
 			outputStream.writeUTF(entryString);
 			
 			if (RUN_SERIALIZATION_DUPLICATE_VALIDATION)
 			{
 				if (dataPointEntryBySerialization.containsKey(entryString))
 				{
-					LOGGER.error("Duplicate serialized entry found with serial: " + entryString);
+					LOGGER.error("Duplicate serialized pair found with serial: " + entryString);
 				}
-				if (dataPointEntryBySerialization.containsValue(entry))
+				if (dataPointEntryBySerialization.containsValue(pair))
 				{
-					LOGGER.error("Duplicate serialized entry found with value: " + entry.serialize());
+					LOGGER.error("Duplicate serialized pair found with value: " + pair.serialize());
 				}
-				dataPointEntryBySerialization.put(entryString, entry);
+				dataPointEntryBySerialization.put(entryString, pair);
 			}
 		}
 	}
@@ -261,7 +260,7 @@ public class FullDataPointIdMap
 		
 		
 		// only used when debugging
-		HashMap<String, FullDataPointIdMap.Entry> dataPointEntryBySerialization = new HashMap<>();
+		HashMap<String, BlockBiomeWrapperPair> dataPointEntryBySerialization = new HashMap<>();
 		
 		FullDataPointIdMap newMap = new FullDataPointIdMap(pos);
 		for (int i = 0; i < entityCount; i++)
@@ -269,13 +268,13 @@ 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.");
 			}
 			
 			
 			String entryString = inputStream.readUTF();
-			Entry newEntry = Entry.deserialize(entryString, levelWrapper);
+			BlockBiomeWrapperPair newPair = BlockBiomeWrapperPair.deserialize(entryString, levelWrapper);
-			newMap.entryList.add(newEntry);
+			newMap.blockBiomePairList.add(newPair);
 			
 			if (RUN_SERIALIZATION_DUPLICATE_VALIDATION)
 			{
@@ -283,11 +282,11 @@ public class FullDataPointIdMap
 				{
 					LOGGER.error("Duplicate deserialized entry found with serial: " + entryString);
 				}
-				if (dataPointEntryBySerialization.containsValue(newEntry))
+				if (dataPointEntryBySerialization.containsValue(newPair))
 				{
-					LOGGER.error("Duplicate deserialized entry found with value: " + newEntry.serialize());
+					LOGGER.error("Duplicate deserialized entry found with value: " + newPair.serialize());
 				}
-				dataPointEntryBySerialization.put(entryString, newEntry);
+				dataPointEntryBySerialization.put(entryString, newPair);
 			}
 		}
 		
@@ -333,149 +332,13 @@ public class FullDataPointIdMap
 	private void generateHashCode()
 	{
 		int result = DhSectionPos.hashCode(this.pos);
-		for (int i = 0; i < this.entryList.size(); i++)
+		for (int i = 0; i < this.blockBiomePairList.size(); i++)
 		{
-			result = 31 * result + this.entryList.hashCode();
+			result = 31 * result + this.blockBiomePairList.hashCode();
 		}
 		this.cachedHashCode = result;
 	}
 	
 	
 	
-	//==============//
-	// helper class //
-	//==============//
-	
-	private static final class Entry
-	{
-		private static final IWrapperFactory WRAPPER_FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
-		
-		/** two levels are present so we don't need to use a key object */
-		private static final ConcurrentHashMap<IBiomeWrapper, ConcurrentHashMap<IBlockStateWrapper, Entry>> ENTRY_BY_BLOCKSTATE_BY_BIOMEWRAPPER = new ConcurrentHashMap<>();
-		
-		public final IBiomeWrapper biome;
-		public final IBlockStateWrapper blockState;
-		
-		private int hashCode = 0;
-		private boolean hashGenerated = false;
-		private String serialString = null;
-		
-		
-		
-		//=============//
-		// constructor //
-		//=============//
-		
-		public static Entry getEntry(IBiomeWrapper biome, IBlockStateWrapper blockState)
-		{
-			// check for existing entry
-			ConcurrentHashMap<IBlockStateWrapper, Entry> entryByBlockState = ENTRY_BY_BLOCKSTATE_BY_BIOMEWRAPPER.get(biome);
-			if (entryByBlockState != null)
-			{
-				Entry entry = entryByBlockState.get(blockState);
-				if (entry != null)
-				{
-					return entry;
-				}
-			}
-			
-			// Lazily create the inner map and new Entry
-			return ENTRY_BY_BLOCKSTATE_BY_BIOMEWRAPPER
-					.computeIfAbsent(biome, newBiome -> new ConcurrentHashMap<>())
-					.computeIfAbsent(blockState, newBlockState -> new Entry(biome, blockState));
-		}
-		private Entry(IBiomeWrapper biome, IBlockStateWrapper blockState)
-		{
-			this.biome = biome;
-			this.blockState = blockState;
-		}
-		
-		
-		
-		//===========//
-		// overrides //
-		//===========//
-		
-		/** 
-		 * Reminder: this hash code won't always be unique, collisions can occur;
-		 * because of that this hash shouldn't be the only unique identifier for this object.
-		 */
-		@Override
-		public int hashCode()
-		{
-			// cache the hash code to improve speed
-			if (!this.hashGenerated)
-			{
-				this.hashCode = generateHashCode(this);
-				this.hashGenerated = true;
-			}
-			
-			return this.hashCode;
-		}
-		private static int generateHashCode(Entry entry) { return generateHashCode(entry.biome, entry.blockState); }
-		private static int generateHashCode(IBiomeWrapper biome, IBlockStateWrapper blockState)
-		{
-			final int prime = 31;
-			
-			int result = 1;
-			// the biome and blockstate hashcode should be already calculated by the time
-			// we get here, so this operation should be very fast
-			result = prime * result + (biome == null ? 0 : biome.hashCode());
-			result = prime * result + (blockState == null ? 0 : blockState.hashCode());
-			return result;
-		}
-		
-		@Override
-		public boolean equals(Object otherObj)
-		{
-			if (otherObj == this)
-			{
-				return true;
-			}
-			
-			if (!(otherObj instanceof Entry))
-			{
-				return false;
-			}
-			
-			Entry other = (Entry) otherObj;
-			return other.biome.getSerialString().equals(this.biome.getSerialString())
-					&& other.blockState.getSerialString().equals(this.blockState.getSerialString());
-		}
-		
-		@Override
-		public String toString() { return this.serialize(); }
-		
-		
-		
-		//=================//
-		// (de)serializing //
-		//=================//
-		
-		public String serialize() 
-		{
-			if (this.serialString == null)
-			{
-				this.serialString = this.biome.getSerialString() + BLOCK_STATE_SEPARATOR_STRING + this.blockState.getSerialString();
-			}
-			
-			return this.serialString;
-		}
-		
-		public static Entry deserialize(String str, ILevelWrapper levelWrapper) throws DataCorruptedException
-		{
-			int separatorIndex = str.indexOf(BLOCK_STATE_SEPARATOR_STRING);
-			if (separatorIndex == -1)
-			{
-				throw new DataCorruptedException("Failed to deserialize BiomeBlockStateEntry ["+str+"], unable to find separator.");
-			}
-			
-			IBiomeWrapper biome = WRAPPER_FACTORY.deserializeBiomeWrapperOrGetDefault(str.substring(0, separatorIndex), levelWrapper);
-			IBlockStateWrapper blockState = WRAPPER_FACTORY.deserializeBlockStateWrapperOrGetDefault(str.substring(separatorIndex+BLOCK_STATE_SEPARATOR_STRING.length()), levelWrapper);
-			return Entry.getEntry(biome, blockState);
-		}
-		
-	}
-	
-	
 }

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

@@ -20,8 +20,8 @@
 package com.seibel.distanthorizons.core.dataObjects.fullData.sources;
 
 import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiWorldGenerationStep;
-import com.seibel.distanthorizons.core.file.IDataSource;
 import com.seibel.distanthorizons.core.level.IDhLevel;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV1DTO;
@@ -33,7 +33,6 @@ import com.seibel.distanthorizons.core.util.objects.dataStreams.DhDataOutputStre
 import com.seibel.distanthorizons.core.dataObjects.fullData.FullDataPointIdMap;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
-import org.apache.logging.log4j.Logger;
 
 import java.io.*;
 import java.util.Arrays;
@@ -47,9 +46,9 @@ import java.util.Arrays;
  * @see FullDataPointUtil
  * @see FullDataSourceV2
  */
-public class FullDataSourceV1 implements IDataSource<IDhLevel>
+public class FullDataSourceV1
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	public static final byte SECTION_SIZE_OFFSET = DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL;
 	/** measured in dataPoints */
@@ -94,28 +93,13 @@ public class FullDataSourceV1 implements IDataSource<IDhLevel>
 	}
 	
 	
-	
-	
-	//======//
-	// data //
-	//======//
-	
-	@Deprecated
-	@Override
-	public boolean update(FullDataSourceV2 dataSource, IDhLevel level) { throw new UnsupportedOperationException("Deprecated"); }
-	
-	
-	
 	//=====================//
 	// setters and getters //
 	//=====================//
 	
-	@Override
 	public Long getKey() { return this.pos; }
-	@Override
 	public String getKeyDisplayString() { return DhSectionPos.toString(this.pos); }
 	
-	@Override
 	public long getPos() { return this.pos; }
 	
 	public void resizeDataStructuresForRepopulation(long pos)
@@ -124,7 +108,6 @@ public class FullDataSourceV1 implements IDataSource<IDhLevel>
 		this.pos = pos;
 	}
 	
-	@Override
 	public byte getDataDetailLevel() { return (byte) (DhSectionPos.getDetailLevel(this.pos) - SECTION_SIZE_OFFSET); }
 	
 	public boolean isEmpty() { return this.isEmpty; }
@@ -197,7 +180,7 @@ public class FullDataSourceV1 implements IDataSource<IDhLevel>
 	{
 		outputStream.writeInt(this.getDataDetailLevel());
 		outputStream.writeInt(WIDTH);
-		outputStream.writeInt(level.getMinY());
+		outputStream.writeInt(level.getLevelWrapper().getMinHeight());
 		outputStream.writeByte(this.worldGenStep.value);
 		
 	}
@@ -206,19 +189,19 @@ public class FullDataSourceV1 implements IDataSource<IDhLevel>
 		int dataDetail = inputStream.readInt();
 		if (dataDetail != dto.dataDetailLevel)
 		{
-			throw new IOException(LodUtil.formatLog("Data level mismatch. Expected: ["+dto.dataDetailLevel+"], found ["+dataDetail+"]."));
+			throw new IOException("Data level mismatch. Expected: ["+dto.dataDetailLevel+"], found ["+dataDetail+"].");
 		}
 		
 		int width = inputStream.readInt();
 		if (width != WIDTH)
 		{
-			throw new IOException(LodUtil.formatLog("Section width mismatch: " + width + " != " + WIDTH + " (Currently only 1 section width is supported)"));
+			throw new IOException("Section width mismatch: [" + width + "] != [" + WIDTH + "] (Currently only 1 section width is supported)");
 		}
 		
 		int minY = inputStream.readInt();
-		if (minY != level.getMinY())
+		if (minY != level.getLevelWrapper().getMinHeight())
 		{
-			LOGGER.warn("Data minY mismatch: " + minY + " != " + level.getMinY() + ". Will ignore data's y level");
+			LOGGER.warn("Data minY mismatch: [" + minY + "] != [" + level.getLevelWrapper().getMinHeight() + "]. Will ignore data's y level");
 		}
 		
 		byte worldGenByte = inputStream.readByte();
@@ -377,15 +360,6 @@ public class FullDataSourceV1 implements IDataSource<IDhLevel>
 	public void setIdMapping(FullDataPointIdMap mappings) { this.mapping.mergeAndReturnRemappedEntityIds(mappings); }
 	
 	
-	//==================//
-	// override methods //
-	//==================//
-	
-	@Override
-	public void close()
-	{ /* not currently needed */ }
-	
-	
 	
 	//================//
 	// helper classes //

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

@@ -23,11 +23,13 @@ import com.seibel.distanthorizons.api.enums.config.EDhApiWorldCompressionMode;
 import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiWorldGenerationStep;
 import com.seibel.distanthorizons.api.objects.data.DhApiTerrainDataPoint;
 import com.seibel.distanthorizons.api.objects.data.IDhApiFullDataSource;
+import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.FullDataPointIdMap;
+import com.seibel.distanthorizons.core.dataObjects.transformers.FullDataOcclusionCuller;
 import com.seibel.distanthorizons.core.dataObjects.transformers.LodDataBuilder;
-import com.seibel.distanthorizons.core.file.AbstractDataSourceHandler;
+import com.seibel.distanthorizons.core.enums.EDhDirection;
-import com.seibel.distanthorizons.core.file.IDataSource;
+import com.seibel.distanthorizons.core.file.fullDatafile.V2.FullDataSourceProviderV2;
-import com.seibel.distanthorizons.core.level.IDhLevel;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pooling.AbstractPhantomArrayList;
 import com.seibel.distanthorizons.core.pooling.PhantomArrayListCheckout;
@@ -35,17 +37,18 @@ import com.seibel.distanthorizons.core.pooling.PhantomArrayListPool;
 import com.seibel.distanthorizons.core.pos.DhLodPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
+import com.seibel.distanthorizons.core.sql.dto.util.FullDataMinMaxPosUtil;
 import com.seibel.distanthorizons.core.util.*;
 import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
 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.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
-import javax.annotation.Nullable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -58,9 +61,9 @@ import java.util.List;
  */
 public class FullDataSourceV2 
 		extends AbstractPhantomArrayList
-		implements IDataSource<IDhLevel>, IDhApiFullDataSource
+		implements IDhApiFullDataSource
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	/** useful for debugging, but can slow down update operations quite a bit due to being called so often. */
 	private static final boolean RUN_UPDATE_DEV_VALIDATION = false;
 	/** 
@@ -75,8 +78,6 @@ public class FullDataSourceV2
 	/** how many chunks wide this datasource is at detail level 0. */
 	public static final int NUMB_OF_CHUNKS_WIDE = WIDTH / LodUtil.CHUNK_WIDTH;
 	
-	public static final byte DATA_FORMAT_VERSION = 1;
-	
 	public static final PhantomArrayListPool ARRAY_LIST_POOL = new PhantomArrayListPool("FullDataV2");
 	
 	
@@ -84,10 +85,6 @@ public class FullDataSourceV2
 	private int cachedHashCode = 0;
 	
 	private final long pos;
-	@Override
-	public Long getKey() { return this.pos; }
-	@Override
-	public String getKeyDisplayString() { return DhSectionPos.toString(this.pos); }
 	
 	
 	public final FullDataPointIdMap mapping;
@@ -96,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}
 	 *
@@ -113,9 +108,7 @@ public class FullDataSourceV2
 	
 	/** 
 	 * stored x/z, y <br>
-	 * The y data should be sorted from top to bottom <br>
+	 * The y data should be sorted from top to bottom
-	 * TODO that ordering feels weird, it'd be nice to reverse that order, unfortunately
-	 *      there's something in the render data logic that expects this order so we can't change it right now
 	 */
 	public final LongArrayList[] dataPoints;
 	
@@ -128,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;
 	
 	
 	
@@ -209,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
@@ -225,7 +219,7 @@ public class FullDataSourceV2
 	private FullDataSourceV2(
 			long pos,
 			FullDataPointIdMap mapping, @Nullable LongArrayList[] data,
-			@Nullable byte[] columnGenerationSteps, @Nullable byte[] columnWorldCompressionMode,
+			byte @Nullable [] columnGenerationSteps, byte @Nullable [] columnWorldCompressionMode,
 			boolean empty)
 	{
 		super(ARRAY_LIST_POOL, 2, 0, WIDTH * WIDTH);
@@ -282,20 +276,32 @@ public class FullDataSourceV2
 	
 	
 	
-	//======//
+	//=========//
 	// getters //
-	//======//
+	//=========//
 	
-	public LongArrayList get(int relX, int relZ) throws IndexOutOfBoundsException 
+	public LongArrayList getColumnAtRelPos(int relX, int relZ) throws IndexOutOfBoundsException 
 	{ return this.dataPoints[relativePosToIndex(relX, relZ)]; }
 	
+	@Nullable
+	public LongArrayList tryGetColumnAtRelPos(int relX, int relZ)
+	{
+		int index = tryGetRelativePosToIndex(relX, relZ);
+		if (index == -1)
+		{
+			return null;
+		}
+		
+		return this.dataPoints[index];
+	}
+	
 	/** 
 	 * returns {@link FullDataPointUtil#EMPTY_DATA_POINT} if the given {@link DhBlockPos}
 	 * is outside this data source's boundaries.
 	 */
-	public long getAtBlockPos(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
 		{
@@ -317,7 +323,7 @@ public class FullDataSourceV2
 		DhLodPos relativePos = requestedPos.getDhSectionRelativePositionForDetailLevel(requestDetailLevel);
 		
 		// get the data column
-		LongArrayList dataColumn = this.get(relativePos.x, relativePos.z);
+		LongArrayList dataColumn = this.getColumnAtRelPos(relativePos.x, relativePos.z);
 		if (dataColumn == null)
 		{
 			return FullDataPointUtil.EMPTY_DATA_POINT;
@@ -325,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++)
 		{
@@ -339,14 +346,13 @@ public class FullDataSourceV2
 			
 			
 			
-			int requestedY = blockPos.getY();
+			int bottomY = FullDataPointUtil.getBottomY(dataPoint);
-			int bottomY = FullDataPointUtil.getBottomY(dataPoint) + this.levelMinY;
 			int height = FullDataPointUtil.getHeight(dataPoint);
 			int topY = bottomY + height;
 			
 			// does this datapoint contain the requested Y position? 
-			if (bottomY <= requestedY
+			if (bottomY <= relBlockPosY
-				&& requestedY < topY) // blockPositions start from the bottom of the block, thus "<=" for bottomY, just "<" for topY
+				&& relBlockPosY < topY) // blockPositions start from the bottom of the block, thus "<=" for bottomY, just "<" for topY
 			{
 				return dataPoint;
 			}
@@ -361,9 +367,7 @@ public class FullDataSourceV2
 	// updating //
 	//==========//
 	
-	@Override
+	public boolean updateFromDataSource(@NotNull FullDataSourceV2 inputDataSource)
-	public boolean update(@NotNull FullDataSourceV2 inputDataSource, @Nullable IDhLevel level) { return this.update(inputDataSource); }
-	public boolean update(@NotNull FullDataSourceV2 inputDataSource)
 	{
 		// don't try updating if the input is empty
 		if (inputDataSource.mapping.isEmpty())
@@ -391,7 +395,7 @@ public class FullDataSourceV2
 						// copy over application flag if either are set to continue propagating
 						(BoolUtil.falseIfNull(this.applyToParent) || BoolUtil.falseIfNull(inputDataSource.applyToParent))
 						// don't propagate past the top of the tree
-						&& (DhSectionPos.getDetailLevel(this.pos) < AbstractDataSourceHandler.TOP_SECTION_DETAIL_LEVEL);
+						&& (DhSectionPos.getDetailLevel(this.pos) < FullDataSourceProviderV2.ROOT_SECTION_DETAIL_LEVEL);
 			}
 			
 			// null check to prevent setting a flag we don't want to save in the DB
@@ -400,7 +404,7 @@ public class FullDataSourceV2
 				this.applyToChildren =
 						(BoolUtil.falseIfNull(this.applyToChildren) || BoolUtil.falseIfNull(inputDataSource.applyToChildren))
 						// don't propagate past the bottom of the tree
-						&& (DhSectionPos.getDetailLevel(this.pos) > AbstractDataSourceHandler.MIN_SECTION_DETAIL_LEVEL);
+						&& (DhSectionPos.getDetailLevel(this.pos) > FullDataSourceProviderV2.LEAF_SECTION_DETAIL_LEVEL);
 			}
 		}
 		else if (inputDetailLevel + 1 == thisDetailLevel)
@@ -411,7 +415,7 @@ public class FullDataSourceV2
 			this.applyToParent =
 					dataChanged
 					&& (BoolUtil.falseIfNull(this.applyToParent) || BoolUtil.falseIfNull(inputDataSource.applyToParent))
-					&& (DhSectionPos.getDetailLevel(this.pos) < AbstractDataSourceHandler.TOP_SECTION_DETAIL_LEVEL);
+					&& (DhSectionPos.getDetailLevel(this.pos) < FullDataSourceProviderV2.ROOT_SECTION_DETAIL_LEVEL);
 			
 		}
 		else if (inputDetailLevel - 1 == thisDetailLevel)
@@ -423,7 +427,7 @@ public class FullDataSourceV2
 			this.applyToChildren =
 					dataChanged
 					&& (BoolUtil.falseIfNull(this.applyToChildren) || BoolUtil.falseIfNull(inputDataSource.applyToChildren))
-					&& (DhSectionPos.getDetailLevel(this.pos) > AbstractDataSourceHandler.MIN_SECTION_DETAIL_LEVEL);
+					&& (DhSectionPos.getDetailLevel(this.pos) > FullDataSourceProviderV2.LEAF_SECTION_DETAIL_LEVEL);
 		}
 		else
 		{
@@ -434,8 +438,31 @@ public class FullDataSourceV2
 			throw new UnsupportedOperationException("Unsupported data source update. Expected input detail level of ["+(thisDetailLevel-1)+"], ["+thisDetailLevel+"], or ["+(thisDetailLevel+1)+"], received detail level ["+inputDetailLevel+"].");
 		}
 		
+		
+		
+		
+		
 		if (dataChanged)
 		{
+			EDhApiWorldCompressionMode worldCompressionMode = Config.Common.LodBuilding.worldCompression.get();
+			boolean cullHiddenBlocks = (worldCompressionMode != EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS);
+			if (cullHiddenBlocks)
+			{
+				for (int x = 0; x < WIDTH; x++)
+				{
+					for (int z = 0; z < WIDTH; z++)
+					{
+						LongArrayList dataColumn = this.getColumnAtRelPos(x, z);
+						if (dataColumn != null
+							&& dataColumn.size() > 1)
+						{
+							FullDataOcclusionCuller.cullHiddenDatapointsInColumn(this, x, z);
+						}
+					}
+				}
+			}
+			
+			
 			// update the hash code
 			this.generateHashCode();
 		}
@@ -443,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))
@@ -459,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);
+					continue;
-					byte inputGenState = inputDataSource.columnGenerationSteps.getByte(index);
+				}
 				
-					
+				
-					// determine if this column should be updated
+				
-					boolean genStateAllowsUpdating = false;
+				byte thisGenState = this.columnGenerationSteps.getByte(index);
-					// if the input is downsampled, we only want to replace empty or downsampled values
+				byte inputGenState = inputDataSource.columnGenerationSteps.getByte(index);
-					if (inputGenState == EDhApiWorldGenerationStep.DOWN_SAMPLED.value
+				
-						&&
+				
-						(
+				// determine if this column should be updated
-							thisGenState == EDhApiWorldGenerationStep.EMPTY.value
+				boolean genStateAllowsUpdating = false;
-							|| thisGenState == EDhApiWorldGenerationStep.DOWN_SAMPLED.value
+				// 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;
+						// the hashes are different, something was changed
-					}
+						dataChanged = 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;
 					}
 				}
+				
+				
+				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))
 		{
@@ -684,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
+		// get the 4 input columns //
-		int[] currentDatapointIndex = new int[] { -2, -2, -2, -2 };
+		//=========================//
+		
+		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 currentMinY = yTransitions.getInt(0);
-		int minY = 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 yIndex = 0; yIndex < yTransitions.size() - 1; yIndex++)
-		for (int blockY = 0; blockY < RenderDataPointUtil.MAX_WORLD_Y_SIZE; blockY++, height++)
 		{
-			// if each column has reached the end of their data, nothing more needs to be done
+			int sliceMinY = yTransitions.getInt(yIndex);
-			if (currentDatapointIndex[0] == -1
+			int sliceMaxY = yTransitions.getInt(yIndex + 1);
-				&& currentDatapointIndex[1] == -1
+			int sliceHeight = sliceMaxY - sliceMinY;
-				&& 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;
-				}
-			}
-			
 			
+			// 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]);
+				// skip columns that are empty or where we have already reached the bottom
-				mergeBlockLights[i] = FullDataPointUtil.getBlockLight(datapointsForYSlice[i]);
+				if (currentIndices[i] == -1)
-				mergeSkyLights[i] = FullDataPointUtil.getSkyLight(datapointsForYSlice[i]);
+				{
+					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
+			// Check if we need to start a new datapoint
-			if (id != lastId
+			if (accumulatedHeight == 0)
-				// block and sky light might not be necessary
-				|| blockLight != lastBlockLight
-				|| skyLight != lastSkyLight)
 			{
-				if (height != 0)
+				// first datapoint
-				{
-					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 "+inputDataSource.pos+" at relative position ["+x+","+z+"] with data: ID["+lastId+"], Height["+height+"], minY["+minY+"], lastBlockLight["+lastBlockLight+"], lastSkyLight["+lastSkyLight+"].");
-					}
-				}
-				
 				lastId = id;
 				lastBlockLight = blockLight;
 				lastSkyLight = skyLight;
-				height = 0;
+				currentMinY = sliceMinY;
-				minY = blockY;
+				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["+accumulatedHeight+"], minY["+currentMinY+"], lastBlockLight["+lastBlockLight+"], lastSkyLight["+lastSkyLight+"].");
-				LOGGER.warn("Skipping corrupt datapoint for pos "+inputDataSource.pos+" at relative position ["+x+","+z+"] with data: ID["+lastId+"], Height["+height+"], minY["+minY+"], lastBlockLight["+lastBlockLight+"], lastSkyLight["+lastSkyLight+"].");
 			}
 		}
 		
 		
-		// flip the array if necessary
+		// confirm the array is in the correct order
-		// 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?
 		ensureDataColumnOrder(newColumnList);
 		
 		return newColumnList;
@@ -871,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)
 		{
@@ -931,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
@@ -1067,23 +1131,72 @@ public class FullDataSourceV2
 	
 	
 	
+	//===================//
+	// adjacent clearing //
+	//===================//
+	
+	/** Removes any non-adjacent data from the given direction. */
+	public void clearAllNonAdjData(EDhDirection direction)
+	{
+		long encodedMinMaxPos = FullDataMinMaxPosUtil.getEncodedMinMaxPos(direction);
+		int minX = FullDataMinMaxPosUtil.getAdjMinX(encodedMinMaxPos);
+		int maxX = FullDataMinMaxPosUtil.getAdjMaxX(encodedMinMaxPos);
+		int minZ = FullDataMinMaxPosUtil.getAdjMinZ(encodedMinMaxPos);
+		int maxZ = FullDataMinMaxPosUtil.getAdjMaxZ(encodedMinMaxPos);
+		
+		for (int relX = 0; relX < FullDataSourceV2.WIDTH; relX++)
+		{
+			for (int relZ = 0; relZ < FullDataSourceV2.WIDTH; relZ++)
+			{
+				// skip non-adjacent data
+				if (relX >= minX && relX < maxX
+						&& relZ >= minZ && relZ < maxZ)
+				{
+					continue;
+				}
+				
+				LongArrayList dataColumn = this.getColumnAtRelPos(relX, relZ);
+				dataColumn.clear();
+				dataColumn.add(FullDataPointUtil.EMPTY_DATA_POINT);
+			}
+		}
+	}
+	
+	
 	//================//
 	// helper methods //
 	//================//
 	
+	/** 
+	 * Usually this should just be used internally, but there may be instances
+	 * where the raw data arrays are available without the data source object.
+	 * 	 
+	 * @return -1 if given an out-of-bounds relative position 
+	 */
+	public static int tryGetRelativePosToIndex(int relX, int relZ)
+	{
+		if (relX < 0 || relZ < 0
+				|| relX >= WIDTH || relZ >= WIDTH)
+		{
+			return -1;
+		}
+		
+		return (relX * WIDTH) + relZ;
+	}
+	
 	/** 
 	 * Usually this should just be used internally, but there may be instances
 	 * where the raw data arrays are available without the data source object.
 	 */
 	public static int relativePosToIndex(int relX, int relZ) throws IndexOutOfBoundsException
 	{ 
-		if (relX < 0 || relZ < 0 ||
+		int index = tryGetRelativePosToIndex(relX, relZ);
-			relX > WIDTH || relZ > WIDTH)
+		if (index < 0)
 		{
-			throw new IndexOutOfBoundsException("Relative data source positions must be between [0] and ["+WIDTH+"] (inclusive) the relative pos: ["+relX+","+relZ+"] is outside of those boundaries.");
+			throw new IndexOutOfBoundsException("Relative data source positions must be between [0] (inclusive) and ["+WIDTH+"] (exclusive) the relative pos: ["+relX+","+relZ+"] is outside those boundaries.");
 		}
 		
-		return (relX * WIDTH) + relZ; 
+		return index; 
 	}
 	
 	/** 
@@ -1150,18 +1263,10 @@ public class FullDataSourceV2
 	// setters and getters //
 	//=====================//
 	
-	@Override
 	public long getPos() { return this.pos; }
 	
-	@Override
 	public byte getDataDetailLevel() { return (byte) (DhSectionPos.getDetailLevel(this.pos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL); }
 	
-	public EDhApiWorldGenerationStep getWorldGenStepAtRelativePos(int relX, int relZ) 
-	{
-		int index = relativePosToIndex(relX, relZ);
-		return EDhApiWorldGenerationStep.fromValue(this.columnGenerationSteps.getByte(index)); 
-	}
-	
 	public void setSingleColumn(LongArrayList longArray, int relX, int relZ, EDhApiWorldGenerationStep worldGenStep, EDhApiWorldCompressionMode worldCompressionMode)
 	{
 		int index = relativePosToIndex(relX, relZ);
@@ -1192,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; }
@@ -1203,13 +1308,13 @@ public class FullDataSourceV2
 	{
 		try
 		{
-			LodDataBuilder.correctDataColumnOrder(columnDataPoints);
+			LodDataBuilder.putListInTopDownOrder(columnDataPoints);
-			if (this.runApiChunkValidation)
+			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);
@@ -1225,14 +1330,14 @@ public class FullDataSourceV2
 	@Override 
 	public List<DhApiTerrainDataPoint> getApiDataPointColumn(int relX, int relZ) throws IndexOutOfBoundsException
 	{
-		LongArrayList dataColumn = this.get(relX, relZ);
+		LongArrayList dataColumn = this.getColumnAtRelPos(relX, relZ);
 		
 		ArrayList<DhApiTerrainDataPoint> apiList = new ArrayList<>();
 		for (int i = 0; i < dataColumn.size(); i++)
 		{
 			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/CachedColumnRenderSource.java

@@ -1,96 +0,0 @@
-package com.seibel.distanthorizons.core.dataObjects.render;
-
-import com.google.common.cache.Cache;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.ReentrantLock;
-
-/** 
- * Wrapper for {@link ColumnRenderSource} that handles reference counting
- * and cache tracking.
- */
-public class CachedColumnRenderSource implements AutoCloseable
-{
-	/** an externally handled future that will complete once the {@link CachedColumnRenderSource#columnRenderSource} has finished loading */
-	public final CompletableFuture<CachedColumnRenderSource> loadFuture;
-	/** will be null initially, should be non-null once the corresponding load future is done */
-	@Nullable
-	public ColumnRenderSource columnRenderSource = null;
-	
-	private final AtomicInteger referenceCount;
-	private final Cache<Long, CachedColumnRenderSource> cachedRenderSourceByPos;
-	private final ReentrantLock getterLock;
-	
-	
-	
-	//=============//
-	// constructor //
-	//=============//
-	
-	public CachedColumnRenderSource(
-			@NotNull CompletableFuture<CachedColumnRenderSource> loadFuture,
-			@NotNull ReentrantLock getterLock,
-			@NotNull Cache<Long, CachedColumnRenderSource> cachedRenderSourceByPos)
-	{
-		this.loadFuture = loadFuture;
-		this.getterLock = getterLock;
-		this.referenceCount = new AtomicInteger(1);
-		this.cachedRenderSourceByPos = cachedRenderSourceByPos;
-	}
-	
-	
-	
-	//====================//
-	// reference counting //
-	//====================//
-	
-	public void markInUse() { this.referenceCount.getAndIncrement(); }
-	
-	
-	
-	//================//
-	// base overrides //
-	//================//
-	
-	/** 
-	 * Will be called multiple times,
-	 * however it will only close the underlying data once
-	 * all references have closed.
-	 */
-	@Override 
-	public void close() throws IllegalStateException
-	{
-		try
-		{
-			// lock to prevent other threads for accessing the cache if we invalidate it
-			this.getterLock.lock();
-			
-			// should only happen if something goes wrong up-stream
-			if (this.columnRenderSource == null)
-			{
-				return;
-			}
-			
-			
-			// only close once everyone is done with this datasource
-			int refCount = this.referenceCount.decrementAndGet();
-			if (refCount == 0)
-			{
-				this.cachedRenderSourceByPos.invalidate(this.columnRenderSource.pos);
-				this.columnRenderSource.close();
-			}
-			else if (refCount < 0)
-			{
-				throw new IllegalStateException("Render source ["+this.columnRenderSource.pos+"] reference count incorrect. Object already closed.");
-			}
-		}
-		finally
-		{
-			this.getterLock.unlock();
-		}
-	}
-	
-}

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

@@ -23,16 +23,12 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pooling.AbstractPhantomArrayList;
 import com.seibel.distanthorizons.core.pooling.PhantomArrayListPool;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
-import com.seibel.distanthorizons.coreapi.ModInfo;
 import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnArrayView;
 import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnQuadView;
-import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
 import com.seibel.distanthorizons.core.util.ColorUtil;
 import com.seibel.distanthorizons.core.util.RenderDataPointUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
-
-import java.util.concurrent.atomic.AtomicLong;
 
 /**
  * Stores the render data used to generate OpenGL buffers.
@@ -41,12 +37,10 @@ import java.util.concurrent.atomic.AtomicLong;
  */
 public class ColumnRenderSource extends AbstractPhantomArrayList
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
-	public static final boolean DO_SAFETY_CHECKS = ModInfo.IS_DEV_BUILD;
+	/** measured in data columns */
-	public static final byte SECTION_SIZE_OFFSET = DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL;
+	public static final int WIDTH = 64;
-	/** width of this data in columns */
-	public static final int SECTION_SIZE = BitShiftUtil.powerOfTwo(SECTION_SIZE_OFFSET); // 64
 	
 	public static final PhantomArrayListPool ARRAY_LIST_POOL = new PhantomArrayListPool("Render Source");
 	
@@ -63,8 +57,6 @@ public class ColumnRenderSource extends AbstractPhantomArrayList
 	
 	private boolean isEmpty = true;
 	
-	public AtomicLong localVersion = new AtomicLong(0); // used to track changes to the data source, so that buffers can be updated when necessary
-	
 	
 	
 	//==============//
@@ -88,9 +80,9 @@ public class ColumnRenderSource extends AbstractPhantomArrayList
 		
 		this.verticalDataCount = maxVerticalSize;
 		
-		this.renderDataContainer = this.pooledArraysCheckout.getLongArray(0, SECTION_SIZE * SECTION_SIZE * this.verticalDataCount);
+		this.renderDataContainer = this.pooledArraysCheckout.getLongArray(0, WIDTH * WIDTH * this.verticalDataCount);
 		
-		this.debugSourceFlags = new DebugSourceFlag[SECTION_SIZE * SECTION_SIZE];
+		this.debugSourceFlags = new DebugSourceFlag[WIDTH * WIDTH];
 	}
 	
 	
@@ -99,19 +91,19 @@ public class ColumnRenderSource extends AbstractPhantomArrayList
 	// datapoint manipulation //
 	//========================//
 	
-	public long getDataPoint(int posX, int posZ, int verticalIndex) { return this.renderDataContainer.getLong(posX * SECTION_SIZE * this.verticalDataCount + posZ * this.verticalDataCount + verticalIndex); }
+	public long getDataPoint(int posX, int posZ, int verticalIndex) { return this.renderDataContainer.getLong(posX * WIDTH * this.verticalDataCount + posZ * this.verticalDataCount + verticalIndex); }
 	
 	public ColumnArrayView getVerticalDataPointView(int posX, int posZ)
 	{
-		int offset = posX * SECTION_SIZE * this.verticalDataCount + posZ * this.verticalDataCount;
+		int offset = posX * WIDTH * this.verticalDataCount + posZ * this.verticalDataCount;
 		
 		// don't allow returning views that are outside this render source's bounds
 		if (offset >= this.renderDataContainer.size())
 		{
 			return null;
 		}
-		else if (posX < 0 || posX >= SECTION_SIZE
+		else if (posX < 0 || posX >= WIDTH
-				|| posZ < 0 || posZ >= SECTION_SIZE)
+				|| posZ < 0 || posZ >= WIDTH)
 		{
 			return null;
 		}
@@ -120,8 +112,8 @@ public class ColumnRenderSource extends AbstractPhantomArrayList
 				offset, this.verticalDataCount);
 	}
 	
-	public ColumnQuadView getFullQuadView() { return this.getQuadViewOverRange(0, 0, SECTION_SIZE, SECTION_SIZE); }
+	public ColumnQuadView getFullQuadView() { return this.getQuadViewOverRange(0, 0, WIDTH, WIDTH); }
-	public ColumnQuadView getQuadViewOverRange(int quadX, int quadZ, int quadXSize, int quadZSize) { return new ColumnQuadView(this.renderDataContainer, SECTION_SIZE, this.verticalDataCount, quadX, quadZ, quadXSize, quadZSize); }
+	public ColumnQuadView getQuadViewOverRange(int quadX, int quadZ, int quadXSize, int quadZSize) { return new ColumnQuadView(this.renderDataContainer, WIDTH, this.verticalDataCount, quadX, quadZ, quadXSize, quadZSize); }
 	
 	
 	
@@ -131,9 +123,8 @@ public class ColumnRenderSource extends AbstractPhantomArrayList
 	
 	public Long getPos() { return this.pos; }
 	public Long getKey() { return this.pos; }
-	public String getKeyDisplayString() { return DhSectionPos.toString(this.pos); }
 	
-	public byte getDataDetailLevel() { return (byte) (DhSectionPos.getDetailLevel(this.pos) - SECTION_SIZE_OFFSET); }
+	public byte getDataDetailLevel() { return (byte) (DhSectionPos.getDetailLevel(this.pos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL); }
 	
 	public boolean isEmpty() { return this.isEmpty; }
 	public void markNotEmpty() { this.isEmpty = false; }
@@ -147,15 +138,15 @@ public class ColumnRenderSource extends AbstractPhantomArrayList
 		}
 		
 		
-		for (int x = 0; x < SECTION_SIZE; x++)
+		for (int x = 0; x < WIDTH; x++)
 		{
-			for (int z = 0; z < SECTION_SIZE; z++)
+			for (int z = 0; z < WIDTH; z++)
 			{
 				ColumnArrayView columnArrayView = this.getVerticalDataPointView(x,z);
 				for (int i = 0; i < columnArrayView.size; i++)
 				{
 					long dataPoint = columnArrayView.get(i);
-					if (!RenderDataPointUtil.isVoid(dataPoint))
+					if (!RenderDataPointUtil.hasZeroHeight(dataPoint))
 					{
 						return true;
 					}
@@ -179,12 +170,12 @@ public class ColumnRenderSource extends AbstractPhantomArrayList
 		{
 			for (int z = zStart; z < zStart + zWidth; z++)
 			{
-				this.debugSourceFlags[x * SECTION_SIZE + z] = flag;
+				this.debugSourceFlags[x * WIDTH + z] = flag;
 			}
 		}
 	}
 	
-	public DebugSourceFlag debugGetFlag(int ox, int oz) { return this.debugSourceFlags[ox * SECTION_SIZE + oz]; }
+	public DebugSourceFlag debugGetFlag(int ox, int oz) { return this.debugSourceFlags[ox * WIDTH + oz]; }
 	
 	
 	

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

@@ -35,7 +35,7 @@ public final class BufferQuad
 	public static final int NORMAL_MAX_QUAD_WIDTH = 2048;
 	/**
 	 * The maximum number of blocks wide a quad can be
-	 * when {@link Config.Client.Advanced.Graphics.AdvancedGraphics#earthCurveRatio earthCurveRatio}
+	 * when {@link Config.Client.Advanced.Graphics.Experimental#earthCurveRatio earthCurveRatio}
 	 * is enabled.
 	 */
 	public static final int MAX_QUAD_WIDTH_FOR_EARTH_CURVATURE = LodUtil.CHUNK_WIDTH;
@@ -99,7 +99,7 @@ public final class BufferQuad
 		
 		if (compareDirection == BufferMergeDirectionEnum.EastWest)
 		{
-			switch (this.direction.getAxis())
+			switch (this.direction.axis)
 			{
 				case X:
 					return threeDimensionalCompare(this.x, this.y, this.z, quad.x, quad.y, quad.z);
@@ -109,12 +109,12 @@ public final class BufferQuad
 					return threeDimensionalCompare(this.z, this.y, this.x, quad.z, quad.y, quad.x);
 				
 				default:
-					throw new IllegalArgumentException("Invalid Axis enum: " + this.direction.getAxis());
+					throw new IllegalArgumentException("Invalid Axis enum: [" + this.direction.axis + "].");
 			}
 		}
 		else
 		{
-			switch (this.direction.getAxis())
+			switch (this.direction.axis)
 			{
 				case X:
 					return threeDimensionalCompare(this.x, this.z, this.y, quad.x, quad.z, quad.y);
@@ -124,7 +124,7 @@ public final class BufferQuad
 					return threeDimensionalCompare(this.z, this.x, this.y, quad.z, quad.x, quad.y);
 				
 				default:
-					throw new IllegalArgumentException("Invalid Axis enum: " + this.direction.getAxis());
+					throw new IllegalArgumentException("Invalid Axis enum: [" + this.direction.axis + "].");
 			}
 		}
 	}
@@ -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) ||
+		if ((mergeDirection == BufferMergeDirectionEnum.EastWest && this.y != quad.y)
-				(mergeDirection == BufferMergeDirectionEnum.NorthSouthOrUpDown && this.x != quad.x))
+			|| (mergeDirection == BufferMergeDirectionEnum.NorthSouthOrUpDown && this.x != quad.x))
 		{
 			return false;
 		}
@@ -169,7 +169,7 @@ public final class BufferQuad
 		short thisParallelCompareStartPos; // edge parallel to the merge direction
 		short otherPerpendicularCompareStartPos;
 		short otherParallelCompareStartPos;
-		switch (this.direction.getAxis())
+		switch (this.direction.axis)
 		{
 			default: // shouldn't normally happen, just here to make the compiler happy
 			case X:

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

@@ -23,38 +23,26 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.level.IDhClientLevel;
+import com.seibel.distanthorizons.core.pooling.PhantomArrayListCheckout;
 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.render.renderer.LodRenderer;
+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;
 
-import java.util.Arrays;
-
 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 
-	 * no data is expected 
-	 */
-	private static final byte SKYLIGHT_EMPTY = -1;
 	/** 
 	 * if the skylight has this value that means
-	 * that block position is covered/occuled by an adjacent block/column.
+	 * that block position is covered/occluded by an adjacent block/column.
 	 */
-	private static final byte SKYLIGHT_COVERED = -2;
+	private static final byte SKYLIGHT_COVERED = -1;
-	
-	private static final ThreadLocal<byte[]> THREAD_LOCAL_SKY_LIGHT_ARRAY = ThreadLocal.withInitial(() ->
-	{
-		byte[] array = new byte[RenderDataPointUtil.MAX_WORLD_Y_SIZE];
-		Arrays.fill(array, SKYLIGHT_EMPTY);
-		return array;
-	});
 	
 	
 	
@@ -63,8 +51,8 @@ public class ColumnBox
 	//=========//
 	
 	public static void addBoxQuadsToBuilder(
-			LodQuadBuilder builder, IDhClientLevel clientLevel,
+			LodQuadBuilder builder, PhantomArrayListCheckout phantomArrayCheckout, IDhClientLevel clientLevel,
-			short xSize, short ySize, short zSize,
+			short width, short yHeight,
 			short minX, short minY, short minZ,
 			int color, byte irisBlockMaterialId, byte skyLight, byte blockLight,
 			long topData, long bottomData, ColumnArrayView[] adjData, boolean[] isAdjDataSameDetailLevel)
@@ -73,23 +61,26 @@ public class ColumnBox
 		// variable setup //
 		//================//
 		
-		short maxX = (short) (minX + xSize);
+		short maxX = (short) (minX + width);
-		short maxY = (short) (minY + ySize);
+		short maxY = (short) (minY + yHeight);
-		short maxZ = (short) (minZ + zSize);
+		short maxZ = (short) (minZ + width);
 		byte skyLightTop = skyLight;
 		byte skyLightBot = RenderDataPointUtil.doesDataPointExist(bottomData) ? RenderDataPointUtil.getLightSky(bottomData) : 0;
 		
-		boolean isTransparent = ColorUtil.getAlpha(color) < 255 && LodRenderer.transparencyEnabled;
+		boolean transparencyEnabled = Config.Client.Advanced.Graphics.Quality.transparency.get().transparencyEnabled;
+		boolean fakeOceanFloor = Config.Client.Advanced.Graphics.Quality.transparency.get().fakeTransparencyEnabled;
+		
+		boolean isTransparent = ColorUtil.getAlpha(color) < 255 && transparencyEnabled;
 		boolean overVoid = !RenderDataPointUtil.doesDataPointExist(bottomData);
-		boolean isTopTransparent = RenderDataPointUtil.getAlpha(topData) < 255 && LodRenderer.transparencyEnabled;
+		boolean isTopTransparent = RenderDataPointUtil.getAlpha(topData) < 255 && transparencyEnabled;
-		boolean isBottomTransparent = RenderDataPointUtil.getAlpha(bottomData) < 255 && LodRenderer.transparencyEnabled;
+		boolean isBottomTransparent = RenderDataPointUtil.getAlpha(bottomData) < 255 && transparencyEnabled;
 		
 		// defaulting to a value far below what we can normally render means we
 		// don't need to have an additional "is cave culling enabled" check
 		int caveCullingMaxY = Integer.MIN_VALUE;
 		if (Config.Client.Advanced.Graphics.Culling.enableCaveCulling.get())
 		{
-			caveCullingMaxY = Config.Client.Advanced.Graphics.Culling.caveCullingHeight.get() - clientLevel.getMinY();
+			caveCullingMaxY = Config.Client.Advanced.Graphics.Culling.caveCullingHeight.get() - clientLevel.getLevelWrapper().getMinHeight();
 		}
 		
 		
@@ -103,20 +94,20 @@ public class ColumnBox
 		
 		
 		// fake ocean transparency
-		if (LodRenderer.transparencyEnabled && LodRenderer.fakeOceanFloor)
+		if (transparencyEnabled && fakeOceanFloor)
 		{
 			if (!isTransparent && isTopTransparent && RenderDataPointUtil.doesDataPointExist(topData))
 			{
 				skyLightTop = (byte) MathUtil.clamp(0, 15 - (RenderDataPointUtil.getYMax(topData) - minY), 15);
-				ySize = (short) (RenderDataPointUtil.getYMax(topData) - minY - 1);
+				yHeight = (short) (RenderDataPointUtil.getYMax(topData) - minY - 1);
 			}
 			else if (isTransparent && !isBottomTransparent && RenderDataPointUtil.doesDataPointExist(bottomData))
 			{
-				minY = (short) (minY + ySize - 1);
+				minY = (short) (minY + yHeight - 1);
-				ySize = 1;
+				yHeight = 1;
 			}
 			
-			maxY = (short) (minY + ySize);
+			maxY = (short) (minY + yHeight);
 		}
 		
 		
@@ -125,16 +116,26 @@ public class ColumnBox
 		// add top and bottom faces //
 		//==========================//
 		
-		boolean skipTop = RenderDataPointUtil.doesDataPointExist(topData) && (RenderDataPointUtil.getYMin(topData) == maxY) && !isTopTransparent;
+		// top face
-		if (!skipTop)
 		{
-			builder.addQuadUp(minX, maxY, minZ, xSize, zSize, ColorUtil.applyShade(color, MC.getShade(EDhDirection.UP)), irisBlockMaterialId, skyLightTop, blockLight);
+			boolean skipTop = RenderDataPointUtil.doesDataPointExist(topData)
+					&& (RenderDataPointUtil.getYMin(topData) == maxY)
+					&& !isTopTransparent;
+			if (!skipTop)
+			{
+				builder.addQuadUp(minX, maxY, minZ, width, width, ColorUtil.applyShade(color, MC_RENDER.getShade(EDhDirection.UP)), irisBlockMaterialId, skyLightTop, blockLight);
+			}
 		}
 		
-		boolean skipBottom = RenderDataPointUtil.doesDataPointExist(bottomData) && (RenderDataPointUtil.getYMax(bottomData) == minY) && !isBottomTransparent;
+		// bottom face 
-		if (!skipBottom)
 		{
-			builder.addQuadDown(minX, minY, minZ, xSize, zSize, ColorUtil.applyShade(color, MC.getShade(EDhDirection.DOWN)), irisBlockMaterialId, skyLightBot, blockLight);
+			boolean skipBottom = RenderDataPointUtil.doesDataPointExist(bottomData)
+					&& (RenderDataPointUtil.getYMax(bottomData) == minY)
+					&& !isBottomTransparent;
+			if (!skipBottom)
+			{
+				builder.addQuadDown(minX, minY, minZ, width, width, ColorUtil.applyShade(color, MC_RENDER.getShade(EDhDirection.DOWN)), irisBlockMaterialId, skyLightBot, blockLight);
+			}
 		}
 		
 		
@@ -145,258 +146,285 @@ public class ColumnBox
 		
 		// NORTH face
 		{
-			ColumnArrayView adjCol = adjData[EDhDirection.NORTH.ordinal() - 2]; // TODO can we use something other than ordinal-2?
+			ColumnArrayView adjCol = adjData[EDhDirection.NORTH.compassIndex];
-			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.NORTH.ordinal() - 2];
+			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.NORTH.compassIndex];
 			// if the adjacent column is null that generally means the adjacent area hasn't been generated yet
 			if (adjCol == null)
 			{
 				// Add an adjacent face if this is opaque face or transparent over the void.
 				if (!isTransparent || overVoid)
 				{
-					builder.addQuadAdj(EDhDirection.NORTH, minX, minY, minZ, xSize, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
+					builder.addQuadAdj(
+							EDhDirection.NORTH, 
+							minX, minY, minZ, 
+							width, yHeight, 
+							color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
 				}
 			}
 			else
 			{
-				makeAdjVerticalQuad(builder, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.NORTH, minX, minY, minZ, xSize, ySize,
+				makeAdjVerticalQuad(
+						builder, phantomArrayCheckout, 
+						adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.NORTH, 
+						minX, minY, minZ, width, yHeight,
 						color, irisBlockMaterialId, blockLight);
 			}
 		}
 		
 		// SOUTH face
 		{
-			ColumnArrayView adjCol = adjData[EDhDirection.SOUTH.ordinal() - 2];
+			ColumnArrayView adjCol = adjData[EDhDirection.SOUTH.compassIndex];
-			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.SOUTH.ordinal() - 2];
+			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.SOUTH.compassIndex];
 			if (adjCol == null)
 			{
 				if (!isTransparent || overVoid)
 				{
-					builder.addQuadAdj(EDhDirection.SOUTH, minX, minY, maxZ, xSize, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
+					builder.addQuadAdj(
+							EDhDirection.SOUTH, 
+							minX, minY, maxZ, 
+							width, yHeight, 
+							color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
 				}
 			}
 			else
 			{
-				makeAdjVerticalQuad(builder, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.SOUTH, minX, minY, maxZ, xSize, ySize,
+				makeAdjVerticalQuad(
+						builder, phantomArrayCheckout,
+						adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.SOUTH,
+						minX, minY, maxZ, width, yHeight,
 						color, irisBlockMaterialId, blockLight);
 			}
 		}
 		
 		// WEST face
 		{
-			ColumnArrayView adjCol = adjData[EDhDirection.WEST.ordinal() - 2];
+			ColumnArrayView adjCol = adjData[EDhDirection.WEST.compassIndex];
-			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.WEST.ordinal() - 2];
+			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.WEST.compassIndex];
 			if (adjCol == null)
 			{
 				if (!isTransparent || overVoid)
 				{
-					builder.addQuadAdj(EDhDirection.WEST, minX, minY, minZ, zSize, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
+					builder.addQuadAdj(
+							EDhDirection.WEST, 
+							minX, minY, minZ, 
+							width, yHeight, 
+							color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
 				}
 			}
 			else
 			{
-				makeAdjVerticalQuad(builder, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.WEST, minX, minY, minZ, zSize, ySize,
+				makeAdjVerticalQuad(
+						builder, phantomArrayCheckout,
+						adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.WEST, 
+						minX, minY, minZ, width, yHeight,
 						color, irisBlockMaterialId, blockLight);
 			}
 		}
 		
 		// EAST face
 		{
-			ColumnArrayView adjCol = adjData[EDhDirection.EAST.ordinal() - 2];
+			ColumnArrayView adjCol = adjData[EDhDirection.EAST.compassIndex];
-			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.EAST.ordinal() - 2];
+			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.EAST.compassIndex];
 			if (adjCol == null)
 			{
 				if (!isTransparent || overVoid)
 				{
-					builder.addQuadAdj(EDhDirection.EAST, maxX, minY, minZ, zSize, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
+					builder.addQuadAdj(
+							EDhDirection.EAST, 
+							maxX, minY, minZ, 
+							width, yHeight, 
+							color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
 				}
 			}
 			else
 			{
-				makeAdjVerticalQuad(builder, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.EAST, maxX, minY, minZ, zSize, ySize,
+				makeAdjVerticalQuad(
+						builder, phantomArrayCheckout,
+						adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.EAST, 
+						maxX, minY, minZ, width, yHeight,
 						color, irisBlockMaterialId, blockLight);
 			}
 		}
 	}
 	
 	private static void makeAdjVerticalQuad(
-			LodQuadBuilder builder, @NotNull ColumnArrayView adjColumnView, boolean adjacentIsSameDetailLevel, int caveCullingMaxY, EDhDirection direction, 
+		LodQuadBuilder builder, PhantomArrayListCheckout phantomArrayCheckout,
-			short x, short yMin, short z, short horizontalWidth, short ySize,
+		@NotNull ColumnArrayView adjColumnView, boolean adjacentIsSameDetailLevel, int caveCullingMaxY, EDhDirection direction,
-			int color, byte irisBlockMaterialId, byte blockLight)
+		short x, short yMin, short z, short horizontalWidth, short ySize,
+		int color, byte irisBlockMaterialId, byte blockLight)
 	{
+		// pooled arrays
+		LongArrayList segments = phantomArrayCheckout.getLongArray(0, 0);
+		LongArrayList newSegments = phantomArrayCheckout.getLongArray(1, 0);
+		
+		
+		
 		//==================//
 		// create face with //
 		// no adjacent data //
 		//==================//
 		
-		color = ColorUtil.applyShade(color, MC.getShade(direction));
+		color = ColorUtil.applyShade(color, MC_RENDER.getShade(direction));
 		
-		// if there isn't any data adjacent to this LOD,
+		if (adjColumnView.size == 0
-		// just add the full vertical quad
+			|| RenderDataPointUtil.hasZeroHeight(adjColumnView.get(0)))
-		if (adjColumnView.size == 0 || RenderDataPointUtil.isVoid(adjColumnView.get(0)))
 		{
-			
 			builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, ySize, color, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, blockLight);
 			return;
 		}
 		
 		
 		
-		//===========================//
+		//=================================//
-		// Determine face visibility //
+		// determine face visibility/light //
-		// based on it's neighbors   //
+		//=================================//
-		//===========================//
 		
-		short yMax = (short) (yMin + ySize); // min is inclusive, max is exclusive
+		boolean transparencyEnabled = Config.Client.Advanced.Graphics.Quality.transparency.get().transparencyEnabled;
-		byte[] skyLightAtInputPos = THREAD_LOCAL_SKY_LIGHT_ARRAY.get();
+		boolean inputTransparent = ColorUtil.getAlpha(color) < 255 && transparencyEnabled;
+		short yMax = (short) (yMin + ySize);
 		
-		try
+		
+		int adjCount = adjColumnView.size();
+		
+		// Start with the entire range at max light
+		segments.add(YSegmentUtil.encode(yMin, yMax, LodUtil.MAX_MC_LIGHT));
+		
+		// Process each adjacent datapoint and split segments as needed
+		for (int adjIndex = 0; adjIndex < adjCount; adjIndex++)
 		{
-			// set the initial sky-lights for this face,
+			long adjPoint = adjColumnView.get(adjIndex);
-			// if nothing overlaps or overhangs the face should have max sky light
+			short adjMinY = RenderDataPointUtil.getYMin(adjPoint);
-			Arrays.fill(skyLightAtInputPos, yMin, yMax, LodUtil.MAX_MC_LIGHT);
+			short adjMaxY = RenderDataPointUtil.getYMax(adjPoint);
 			
-			// iterate top down
+			// skip empty adjacent points
-			int adjCount = adjColumnView.size();
+			// or points below this one
-			for (int adjIndex = 0; adjIndex < adjCount; adjIndex++)
+			if (!RenderDataPointUtil.doesDataPointExist(adjPoint)
+				|| RenderDataPointUtil.hasZeroHeight(adjPoint)
+				|| yMax <= adjMinY)
 			{
-				long adjPoint = adjColumnView.get(adjIndex);
+				continue;
-				short adjMinY = RenderDataPointUtil.getYMin(adjPoint);
-				short adjMaxY = RenderDataPointUtil.getYMax(adjPoint);
-				
-				// skip empty adjacent datapoints
-				if (!RenderDataPointUtil.doesDataPointExist(adjPoint)
-						|| RenderDataPointUtil.isVoid(adjPoint))
-				{
-					continue;
-				}
-				
-				// skip this adjacent datapoint if it's above the input datapoint (since it can't affect the input data point)
-				if (yMax <= adjMinY)
-				{
-					continue;
-				}
-				
-				
-				long adjAbovePoint = (adjIndex != 0) ? adjColumnView.get(adjIndex - 1) : RenderDataPointUtil.EMPTY_DATA;
-				long adjBelowPoint = (adjIndex + 1 < adjCount) ? adjColumnView.get(adjIndex + 1) : RenderDataPointUtil.EMPTY_DATA;
-				
-				// if the adjacent data point is over the void
-				// don't consider it as transparent
-				boolean adjOverVoid = !RenderDataPointUtil.doesDataPointExist(adjBelowPoint);
-				boolean adjTransparent = !adjOverVoid && RenderDataPointUtil.getAlpha(adjPoint) < 255 && LodRenderer.transparencyEnabled;
-				
-				
-				
-				//=================================//
-				// set sky light based on adjacent //
-				//=================================//
-				
-				// set light based on overlapping adjacent
-				if (!adjTransparent)
-				{
-					// adj opaque
-					// mark positions adjacent is covering
-					byte adjSkyLight = RenderDataPointUtil.getLightSky(adjPoint);
-					for (int i = adjMinY; i < adjMaxY; i++)
-					{
-						byte skyLightAtPos = skyLightAtInputPos[i];
-						
-						// if the adjacent is a different detail level, we want to render adjacent opaque
-						// faces to try and reduce the chance of holes on detail level borders
-						boolean adjacentCoversThis = 
-								// if the adjacent is the same detail level, no special handling is necessary
-								!adjacentIsSameDetailLevel
-								// if the adjacent face is underground we probably don't need it
-								&& RenderDataPointUtil.getYMax(adjPoint) >= caveCullingMaxY
-								// check if this face is on a border
-								&& 
-								(
-									(x == 0 && direction == EDhDirection.WEST)
-									|| (z == 0 && direction == EDhDirection.NORTH)
-									// TODO why does 256 represent a border? aren't LODs only 64 datapoints wide?
-									|| (x == 256 && direction == EDhDirection.EAST)
-									|| (z == 256 && direction == EDhDirection.SOUTH)
-								);
-						
-						byte newSkyLightAtPos = adjacentCoversThis ? adjSkyLight : SKYLIGHT_COVERED;
-						skyLightAtInputPos[i] = (byte) Math.min(newSkyLightAtPos, skyLightAtPos);
-					}
-				}
-				else
-				{
-					// adjacent is transparent,
-					// use datapoint below adjacent for lighting
-					byte belowSkyLight = RenderDataPointUtil.getLightSky(adjBelowPoint);
-					for (int i = adjMinY; i < adjMaxY; i++)
-					{
-						byte skyLightAtPos = skyLightAtInputPos[i];
-						skyLightAtInputPos[i] = (byte) Math.min(belowSkyLight, skyLightAtPos);
-					}
-				}
-				
-				
-				// fill in sky light up to the next DP,
-				// this is done to handle overhangs
-				byte adjSkyLight = RenderDataPointUtil.getLightSky(adjPoint);
-				int adjAboveMinY = RenderDataPointUtil.getYMin(adjAbovePoint);
-				for (int i = adjMaxY; i < adjAboveMinY; i++)
-				{
-					byte skyLightAtPos = skyLightAtInputPos[i];
-					skyLightAtInputPos[i] = (byte) Math.min(adjSkyLight, skyLightAtPos);
-				}
 			}
 			
 			
+			long adjAbovePoint = (adjIndex != 0) ? adjColumnView.get(adjIndex - 1) : RenderDataPointUtil.EMPTY_DATA;
+			long adjBelowPoint = (adjIndex + 1 < adjCount) ? adjColumnView.get(adjIndex + 1) : RenderDataPointUtil.EMPTY_DATA;
 			
-			//=======================//
+			boolean adjOverVoid = !RenderDataPointUtil.doesDataPointExist(adjBelowPoint);
-			// create vertical faces //
+			boolean adjTransparent = 
-			//=======================//
+				!adjOverVoid
+				&& RenderDataPointUtil.getAlpha(adjPoint) < 255
+				&& transparencyEnabled;
 			
-			boolean inputTransparent = ColorUtil.getAlpha(color) < 255 && LodRenderer.transparencyEnabled;
+			byte adjSkyLight = RenderDataPointUtil.getLightSky(adjPoint);
-			byte lastSkyLight = skyLightAtInputPos[yMin];
+			byte lightToApply;
-			int quadBottomY = yMin;
-			int quadTopY = -1;
 			
-			// walk up the sky lights and create a new face
+			if (!adjTransparent)
-			// whenever the light changes to different valid value
-			for (int i = yMin; i < yMax; i++)
 			{
-				byte skyLight = skyLightAtInputPos[i];
+				// Adjacent is opaque
-				if (skyLight != lastSkyLight)
+				boolean adjacentCoversThis =
-				{
+					!adjacentIsSameDetailLevel
-					// the sky light changed, create the in-progress face
+						&& RenderDataPointUtil.getYMax(adjPoint) >= caveCullingMaxY
-					tryAddVerticalFaceWithSkyLightToBuilder(
+						&&
-							builder, direction,
+						(
-							x, z, horizontalWidth,
+							(x == 0 && direction == EDhDirection.WEST)
-							color, irisBlockMaterialId, blockLight,
+							|| (z == 0 && direction == EDhDirection.NORTH)
-							lastSkyLight, inputTransparent, quadTopY, quadBottomY
+							|| (x == 256 && direction == EDhDirection.EAST)
-					);
+							|| (z == 256 && direction == EDhDirection.SOUTH)
-					
+						);
-					lastSkyLight = skyLight;
-					quadBottomY = i;
-				}
 				
-				quadTopY = (i + 1);
+				lightToApply = adjacentCoversThis ? adjSkyLight : SKYLIGHT_COVERED;
+			}
+			else
+			{
+				// Adjacent is transparent, use below light
+				lightToApply = RenderDataPointUtil.getLightSky(adjBelowPoint);
 			}
 			
-			// add the in-progress face if present
+			
-			if (quadTopY != -1)
+			// Apply light to the range [adjMinY, adjMaxY)
+			applyLightToRange(segments, newSegments, adjMinY, adjMaxY, lightToApply);
+			
+			// Fill overhang area [adjMaxY, adjAboveMinY) with adjSkyLight
+			short adjAboveMinY = RenderDataPointUtil.getYMin(adjAbovePoint);
+			if (adjMaxY < adjAboveMinY)
 			{
-				tryAddVerticalFaceWithSkyLightToBuilder(
+				applyLightToRange(segments, newSegments, adjMaxY, adjAboveMinY, adjSkyLight);
-						builder, direction,
-						x, z, horizontalWidth,
-						color, irisBlockMaterialId, blockLight,
-						lastSkyLight, inputTransparent, quadTopY, quadBottomY
-				);
 			}
 		}
-		finally
+		
+		
+		
+		//=======================//
+		// Create vertical faces //
+		// from segments         //
+		//=======================//
+		
+		for (int i = 0; i < segments.size(); i++)
 		{
-			// clean up the array before the next thread uses it
+			long segment = segments.getLong(i);
-			// (may be unnecessary since we only work between the yMin-yMax anyway, but is helpful for debugging)
+			tryAddVerticalFaceWithSkyLightToBuilder(
-			Arrays.fill(skyLightAtInputPos, yMin, yMax, SKYLIGHT_EMPTY);
+				builder, direction,
+				x, z, horizontalWidth,
+				color, irisBlockMaterialId, blockLight,
+				YSegmentUtil.getSkyLight(segment), inputTransparent, YSegmentUtil.getEndY(segment), YSegmentUtil.getStartY(segment)
+			);
 		}
 	}
+	
+	/**
+	 * Apply the new light value over the given y range,
+	 * splitting segments as needed
+	 * <p>
+	 * source: claude.ai
+	 */
+	private static void applyLightToRange(
+			LongArrayList segments, LongArrayList newSegments, 
+			short rangeStart, short rangeEnd, 
+			byte newLight)
+	{
+		// clear the pooled array that the new segments will go into
+		newSegments.clear();
+		
+		for (int i = 0; i < segments.size(); i++)
+		{
+			long seg = segments.getLong(i);
+			short endY = YSegmentUtil.getEndY(seg);
+			short startY = YSegmentUtil.getStartY(seg);
+			byte skyLight = YSegmentUtil.getSkyLight(seg);
+			
+			// No overlap
+			if (endY <= rangeStart 
+				|| startY >= rangeEnd)
+			{
+				newSegments.add(seg);
+				continue;
+			}
+			
+			// Partial or complete overlap - need to split
+			
+			// Part before the range
+			if (startY < rangeStart)
+			{
+				newSegments.add(YSegmentUtil.encode(startY, rangeStart, skyLight));
+			}
+			
+			// Overlapping part - take minimum light
+			short overlapStart = (short)Math.max(startY, rangeStart);
+			short overlapEnd = (short)Math.min(endY, rangeEnd);
+			byte minLight = (byte) Math.min(newLight, skyLight);
+			newSegments.add(YSegmentUtil.encode(overlapStart, overlapEnd, minLight));
+			
+			// Part after the range
+			if (endY > rangeEnd)
+			{
+				newSegments.add(YSegmentUtil.encode(rangeEnd, endY, skyLight));
+			}
+		}
+		
+		segments.clear();
+		segments.addAll(newSegments);
+	}
+	
 	private static void tryAddVerticalFaceWithSkyLightToBuilder(
 			LodQuadBuilder builder, EDhDirection direction,
 			short x, short z, short horizontalWidth,
@@ -405,22 +433,72 @@ public class ColumnBox
 			)
 	{
 		// invalid positions will have a negative skylight
-		if (lastSkyLight >= 0)
+		if (lastSkyLight < 0)
 		{
-			// Don't add transparent vertical faces
+			return;
-			// unless the adjacent position is empty.
-			// This is done to prevent walls between water blocks in the ocean.
-			if (!inputTransparent
-				|| (lastSkyLight == LodUtil.MAX_MC_LIGHT))
-			{
-				// don't add negative/empty height faces
-				short height = (short) (quadTopY - quadBottomY);
-				if (height > 0)
-				{
-					builder.addQuadAdj(direction, x, (short) quadBottomY, z, horizontalWidth, height, color, irisBlockMaterialId, lastSkyLight, blockLight);
-				}
-			}
 		}
+		
+		// Don't add transparent vertical faces
+		// unless the adjacent position is empty.
+		// This is done to prevent walls between water blocks in the ocean.
+		if (inputTransparent
+			&& (lastSkyLight != LodUtil.MAX_MC_LIGHT))
+		{
+			return;
+		}
+		
+		// don't add negative/empty height faces
+		short height = (short) (quadTopY - quadBottomY);
+		if (height <= 0)
+		{
+			return;
+		}
+		
+		builder.addQuadAdj(
+				direction, 
+				x, (short) quadBottomY, z, 
+				horizontalWidth, height, 
+				color, irisBlockMaterialId, lastSkyLight, blockLight);
+	}
+	
+	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	/** 
+	 * encodes height/light data into a long
+	 * to reduce object allocations.
+	 */
+	private static class YSegmentUtil
+	{
+		private static final int HEIGHT_WIDTH = Short.SIZE;
+		private static final int SKY_LIGHT_WIDTH = Byte.SIZE;
+		
+		private static final int START_Y_MASK = (int) Math.pow(2, HEIGHT_WIDTH) - 1;
+		private static final int END_Y_MASK = (int) Math.pow(2, HEIGHT_WIDTH) - 1;
+		private static final int SKY_LIGHT_MASK = (int) Math.pow(2, SKY_LIGHT_WIDTH) - 1;
+		
+		private static final int START_Y_OFFSET = 0;
+		private static final int END_Y_OFFSET = START_Y_OFFSET + HEIGHT_WIDTH;
+		private static final int SKY_LIGHT_OFFSET = END_Y_OFFSET + HEIGHT_WIDTH;
+		
+		
+		
+		public static long encode(short startY, short endY, byte skyLight)
+		{
+			long data = 0L;
+			data |= (long) (startY & START_Y_MASK) << START_Y_OFFSET;
+			data |= (long) (endY & END_Y_MASK) << END_Y_OFFSET;
+			data |= (long) (skyLight & SKY_LIGHT_MASK) << SKY_LIGHT_OFFSET;
+			return data;
+		}
+		
+		public static short getStartY(long data) { return (short) ((data >> START_Y_OFFSET) & START_Y_MASK); }
+		public static short getEndY(long data) { return (short) ((data >> END_Y_OFFSET) & END_Y_MASK); }
+		public static byte getSkyLight(long data) { return (byte) ((data >> SKY_LIGHT_OFFSET) & SKY_LIGHT_MASK); }
+		
 	}
 	
 	

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

@@ -25,20 +25,17 @@ import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.render.ColumnRenderSource;
 import com.seibel.distanthorizons.core.level.IDhClientLevel;
-import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.pooling.PhantomArrayListCheckout;
+import com.seibel.distanthorizons.core.pooling.PhantomArrayListPool;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.glObject.GLProxy;
 import com.seibel.distanthorizons.core.util.ColorUtil;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.RenderDataPointUtil;
-import com.seibel.distanthorizons.core.util.objects.UncheckedInterruptedException;
 import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnArrayView;
-import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
-import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 import java.util.concurrent.CompletableFuture;
 
@@ -49,9 +46,9 @@ import java.util.concurrent.CompletableFuture;
  */
 public class ColumnRenderBufferBuilder
 {
-	public static final ConfigBasedLogger EVENT_LOGGER = new ConfigBasedLogger(LogManager.getLogger(),
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
-			() -> Config.Common.Logging.logRendererBufferEvent.get());
+	
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	public static final PhantomArrayListPool ARRAY_LIST_POOL = new PhantomArrayListPool("Column Buffer Builder");
 	
 	
 	
@@ -60,14 +57,15 @@ public class ColumnRenderBufferBuilder
 	//==============//
 	
 	/** @link adjData should be null for adjacent sections that cross detail level boundaries */
-	public static CompletableFuture<ColumnRenderBuffer> uploadBuffersAsync(
+	public static CompletableFuture<LodBufferContainer> uploadBuffersAsync(
 			IDhClientLevel clientLevel,
 			long pos,
 			LodQuadBuilder quadBuilder
 		)
 	{
-		ColumnRenderBuffer buffer = new ColumnRenderBuffer(new DhBlockPos(DhSectionPos.getMinCornerBlockX(pos), clientLevel.getMinY(), DhSectionPos.getMinCornerBlockZ(pos)));
+		DhBlockPos minBlockPos = new DhBlockPos(DhSectionPos.getMinCornerBlockX(pos), clientLevel.getLevelWrapper().getMinHeight(), DhSectionPos.getMinCornerBlockZ(pos));
-		CompletableFuture<ColumnRenderBuffer> uploadFuture = buffer.makeAndUploadBuffersAsync(quadBuilder, GLProxy.getInstance().getGpuUploadMethod());
+		LodBufferContainer bufferContainer = new LodBufferContainer(pos, minBlockPos);
+		CompletableFuture<LodBufferContainer> uploadFuture = bufferContainer.makeAndUploadBuffersAsync(quadBuilder);
 		uploadFuture.whenComplete((uploadedBuffer, exception) -> 
 		{
 			// clean up if not uploaded
@@ -109,208 +107,209 @@ public class ColumnRenderBufferBuilder
 		// build each column //
 		//===================//
 		
-		byte thisDetailLevel = renderSource.getDataDetailLevel();
+		// pooled arrays for ColumnBox use
-		for (int relX = 0; relX < ColumnRenderSource.SECTION_SIZE; relX++)
+		try (PhantomArrayListCheckout phantomArrayCheckout = ARRAY_LIST_POOL.checkoutArrays(0, 0, 2))
 		{
-			for (int relZ = 0; relZ < ColumnRenderSource.SECTION_SIZE; relZ++)
+			byte thisDetailLevel = renderSource.getDataDetailLevel();
+			for (int relX = 0; relX < ColumnRenderSource.WIDTH; relX++)
 			{
-				// stop the builder if requested
+				for (int relZ = 0; relZ < ColumnRenderSource.WIDTH; relZ++)
-				UncheckedInterruptedException.throwIfInterrupted();
-				
-				// ignore empty/null columns
-				ColumnArrayView columnRenderData = renderSource.getVerticalDataPointView(relX, relZ);
-				if (columnRenderData.size() == 0
-						|| !RenderDataPointUtil.doesDataPointExist(columnRenderData.get(0))
-						|| RenderDataPointUtil.isVoid(columnRenderData.get(0)))
 				{
-					continue;
+					// ignore empty/null columns
-				}
+					ColumnArrayView columnRenderData = renderSource.getVerticalDataPointView(relX, relZ);
-				
+					if (columnRenderData.size() == 0
-				
+							|| !RenderDataPointUtil.doesDataPointExist(columnRenderData.get(0))
-				
+							|| RenderDataPointUtil.hasZeroHeight(columnRenderData.get(0)))
-				//=============//
-				// debug limit //
-				//=============//
-				
-				// can be used to limit the buffer building to a specific relative position.
-				// useful for debugging a single column
-				if (columnBuilderDebugEnabled)
-				{
-					int wantedX = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugXRow.get();
-					if (wantedX >= 0 && relX != wantedX)
 					{
 						continue;
 					}
-					int wantedZ = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugZRow.get();
+					
-					if (wantedZ >= 0 && relZ != wantedZ)
+					
+					
+					//=============//
+					// debug limit //
+					//=============//
+					
+					// can be used to limit the buffer building to a specific relative position.
+					// useful for debugging a single column
+					if (columnBuilderDebugEnabled)
 					{
-						continue;
+						int wantedX = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugXRow.get();
-					}
+						if (wantedX >= 0 && relX != wantedX)
-				}
-				
-				
-				
-				//==================================//
-				// get adjacent render data columns //
-				//==================================//
-				
-				ColumnArrayView[] adjColumnViews = new ColumnArrayView[EDhDirection.ADJ_DIRECTIONS.length];
-				for (EDhDirection lodDirection : EDhDirection.ADJ_DIRECTIONS)
-				{
-					try
-					{
-						int xAdj = relX + lodDirection.getNormal().x;
-						int zAdj = relZ + lodDirection.getNormal().z;
-						boolean isCrossRenderSourceBoundary =
-								(xAdj < 0 || xAdj >= ColumnRenderSource.SECTION_SIZE) ||
-								(zAdj < 0 || zAdj >= ColumnRenderSource.SECTION_SIZE);
-						
-						ColumnRenderSource adjRenderSource;
-						byte adjDetailLevel;
-						
-						
-						
-						//=========================//
-						// get the adjacent render //
-						// source if present       //
-						//=========================//
-						
-						if (!isCrossRenderSourceBoundary)
 						{
-							// the adjacent position is inside this same render source
+							continue;
-							adjRenderSource = renderSource;
-							adjDetailLevel = thisDetailLevel;
 						}
-						else
+						int wantedZ = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugZRow.get();
-						{
+						if (wantedZ >= 0 && relZ != wantedZ)
-							// the adjacent position is outside this render source
-							
-							// skip empty sections
-							adjRenderSource = adjRegions[lodDirection.ordinal() - 2];
-							if (adjRenderSource == null)
-							{
-								continue;
-							}
-							
-							adjDetailLevel = adjRenderSource.getDataDetailLevel();
-							if (adjDetailLevel == thisDetailLevel)
-							{
-								// if the adjacent position is outside this render source,
-								// wrap the position around so it's inside the adjacent source
-								
-								if (xAdj < 0)
-								{
-									xAdj += ColumnRenderSource.SECTION_SIZE;
-								}
-								if (xAdj >= ColumnRenderSource.SECTION_SIZE)
-								{
-									xAdj -= ColumnRenderSource.SECTION_SIZE;
-								}
-								
-								if (zAdj < 0)
-								{
-									zAdj += ColumnRenderSource.SECTION_SIZE;
-								}
-								if (zAdj >= ColumnRenderSource.SECTION_SIZE)
-								{
-									zAdj -= ColumnRenderSource.SECTION_SIZE;
-								}
-							}
-						}
-						
-						
-						
-						//========================//
-						// get the adjacent views //
-						//========================//
-						
-						// the old logic handled additional cases, but they never appeared to fire,
-						// so just these two cases should be fine
-						boolean expectedDetailLevels = (adjDetailLevel == thisDetailLevel) || (adjDetailLevel > thisDetailLevel);
-						if (!expectedDetailLevels)
-						{
-							LodUtil.assertNotReach("Mismatch between adjacent detail level ["+adjDetailLevel+"] and this render source's detail level ["+thisDetailLevel+"]. Detail levels should be adj >= this.");	
-						}
-						
-						adjColumnViews[lodDirection.ordinal() - 2] = adjRenderSource.getVerticalDataPointView(xAdj, zAdj);
-					}
-					catch (RuntimeException e)
-					{
-						EVENT_LOGGER.warn("Failed to get adj data for relative pos: [" + thisDetailLevel + ":" + relX + "," + relZ + "] at [" + lodDirection + "], Error: "+e.getMessage(), e);
-					}
-				} // for adjacent directions
-				
-				
-				
-				//==========================//
-				// build this render column //
-				//==========================//
-				
-				ColumnRenderSource.DebugSourceFlag debugSourceFlag = renderSource.debugGetFlag(relX, relZ);
-				
-				// We render every vertical lod present in this position
-				// We only stop when we find a block that is void or non-existing block
-				for (int i = 0; i < columnRenderData.size(); i++)
-				{
-					// can be uncommented to limit which vertical LOD is generated
-					if (Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugEnable.get())
-					{
-						int wantedColumnIndex = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugColumnIndex.get();
-						if (wantedColumnIndex >= 0 && i != wantedColumnIndex)
 						{
 							continue;
 						}
 					}
 					
-					long data = columnRenderData.get(i);
+					
-					// If the data is not render-able (Void or non-existing) we stop since there is
+					
-					// no data left in this position
+					//==================================//
-					if (RenderDataPointUtil.isVoid(data) || !RenderDataPointUtil.doesDataPointExist(data))
+					// get adjacent render data columns //
+					//==================================//
+					
+					ColumnArrayView[] adjColumnViews = new ColumnArrayView[EDhDirection.CARDINAL_COMPASS.length];
+					for (EDhDirection direction : EDhDirection.CARDINAL_COMPASS)
 					{
-						break;
+						try
+						{
+							int xAdj = relX + direction.normal.x;
+							int zAdj = relZ + direction.normal.z;
+							boolean isCrossRenderSourceBoundary =
+									(xAdj < 0 || xAdj >= ColumnRenderSource.WIDTH) ||
+											(zAdj < 0 || zAdj >= ColumnRenderSource.WIDTH);
+							
+							ColumnRenderSource adjRenderSource;
+							byte adjDetailLevel;
+							
+							
+							
+							//=========================//
+							// get the adjacent render //
+							// source if present       //
+							//=========================//
+							
+							if (!isCrossRenderSourceBoundary)
+							{
+								// the adjacent position is inside this same render source
+								adjRenderSource = renderSource;
+								adjDetailLevel = thisDetailLevel;
+							}
+							else
+							{
+								// the adjacent position is outside this render source
+								
+								// skip empty sections
+								adjRenderSource = adjRegions[direction.compassIndex];
+								if (adjRenderSource == null)
+								{
+									continue;
+								}
+								
+								adjDetailLevel = adjRenderSource.getDataDetailLevel();
+								if (adjDetailLevel == thisDetailLevel)
+								{
+									// if the adjacent position is outside this render source,
+									// wrap the position around so it's inside the adjacent source
+									
+									if (xAdj < 0)
+									{
+										xAdj += ColumnRenderSource.WIDTH;
+									}
+									if (xAdj >= ColumnRenderSource.WIDTH)
+									{
+										xAdj -= ColumnRenderSource.WIDTH;
+									}
+									
+									if (zAdj < 0)
+									{
+										zAdj += ColumnRenderSource.WIDTH;
+									}
+									if (zAdj >= ColumnRenderSource.WIDTH)
+									{
+										zAdj -= ColumnRenderSource.WIDTH;
+									}
+								}
+							}
+							
+							
+							
+							//========================//
+							// get the adjacent views //
+							//========================//
+							
+							// the old logic handled additional cases, but they never appeared to fire,
+							// so just these two cases should be fine
+							boolean expectedDetailLevels = (adjDetailLevel == thisDetailLevel) || (adjDetailLevel > thisDetailLevel);
+							if (!expectedDetailLevels)
+							{
+								LodUtil.assertNotReach("Mismatch between adjacent detail level ["+adjDetailLevel+"] and this render source's detail level ["+thisDetailLevel+"]. Detail levels should be adj >= this.");
+							}
+							
+							adjColumnViews[direction.compassIndex] = adjRenderSource.getVerticalDataPointView(xAdj, zAdj);
+						}
+						catch (RuntimeException e)
+						{
+							LOGGER.warn("Failed to get adj data for relative pos: [" + thisDetailLevel + ":" + relX + "," + relZ + "] at [" + direction + "], Error: [" + e.getMessage() + "].", e);
+						}
+					} // for adjacent directions
+					
+					
+					
+					//==========================//
+					// build this render column //
+					//==========================//
+					
+					ColumnRenderSource.DebugSourceFlag debugSourceFlag = renderSource.debugGetFlag(relX, relZ);
+					
+					for (int i = 0; i < columnRenderData.size(); i++)
+					{
+						// can be uncommented to limit which vertical LOD is generated
+						if (Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugEnable.get())
+						{
+							int wantedColumnIndex = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugColumnIndex.get();
+							if (wantedColumnIndex >= 0
+									&& i != wantedColumnIndex)
+							{
+								continue;
+							}
+						}
+						
+						long data = columnRenderData.get(i);
+						// If the data is not render-able (Void or non-existing) we stop since there is
+						// no data left in this position
+						if (RenderDataPointUtil.hasZeroHeight(data)
+								|| !RenderDataPointUtil.doesDataPointExist(data))
+						{
+							break;
+						}
+						
+						long topDataPoint = (i - 1) >= 0 ? columnRenderData.get(i - 1) : RenderDataPointUtil.EMPTY_DATA;
+						long bottomDataPoint = (i + 1) < columnRenderData.size() ? columnRenderData.get(i + 1) : RenderDataPointUtil.EMPTY_DATA;
+						
+						addRenderDataPointToBuilder(
+								clientLevel, phantomArrayCheckout,
+								data, topDataPoint, bottomDataPoint,
+								adjColumnViews, isSameDetailLevel,
+								thisDetailLevel, relX, relZ,
+								quadBuilder, debugSourceFlag);
 					}
 					
-					long topDataPoint = (i - 1) >= 0 ? columnRenderData.get(i - 1) : RenderDataPointUtil.EMPTY_DATA;
+				}// for z
-					long bottomDataPoint = (i + 1) < columnRenderData.size() ? columnRenderData.get(i + 1) : RenderDataPointUtil.EMPTY_DATA;
+			}// for x
-					
+		}// phantom checkout
-					addLodToBuffer(
-							clientLevel,
-							data, topDataPoint, bottomDataPoint, 
-							adjColumnViews, isSameDetailLevel,
-							thisDetailLevel, relX, relZ, 
-							quadBuilder, debugSourceFlag);
-				}
-				
-			}// for z
-		}// for x
 		
 		quadBuilder.mergeQuads();
 	}
-	private static void addLodToBuffer(
+	private static void addRenderDataPointToBuilder(
-			IDhClientLevel clientLevel,
+			IDhClientLevel clientLevel, PhantomArrayListCheckout phantomArrayCheckout,
-			long data, long topData, long bottomData, 
+			long renderData, long topRenderData, long bottomRenderData, 
 			ColumnArrayView[] adjColumnViews, boolean[] isSameDetailLevel,
 			byte detailLevel, int renderSourceOffsetPosX, int renderSourceOffsetPosZ, 
 			LodQuadBuilder quadBuilder, ColumnRenderSource.DebugSourceFlag debugSource)
 	{
 		long sectionPos = DhSectionPos.encode(detailLevel, renderSourceOffsetPosX, renderSourceOffsetPosZ);
 		
-		short width = (short) BitShiftUtil.powerOfTwo(detailLevel);
+		short blockWidth = (short) DhSectionPos.getDetailLevelWidthInBlocks(detailLevel);
-		short xMin = (short) DhSectionPos.getMinCornerBlockX(sectionPos);
+		short blockMinX = (short) DhSectionPos.getMinCornerBlockX(sectionPos);
-		short yMin = RenderDataPointUtil.getYMin(data);
+		short blockMinY = RenderDataPointUtil.getYMin(renderData);
-		short zMin = (short) DhSectionPos.getMinCornerBlockZ(sectionPos);
+		short blockMinZ = (short) DhSectionPos.getMinCornerBlockZ(sectionPos);
-		short ySize = (short) (RenderDataPointUtil.getYMax(data) - yMin);
+		short blockMaxY = (short) (RenderDataPointUtil.getYMax(renderData) - blockMinY);
 		
-		if (ySize == 0)
+		if (blockMaxY == 0)
 		{
 			return;
 		}
-		else if (ySize < 0)
+		else if (blockMaxY < 0)
 		{
-			throw new IllegalArgumentException("Negative y size for the data! Data: [" + RenderDataPointUtil.toString(data) + "].");
+			throw new IllegalArgumentException("Negative y size for the renderDataPoint! Data: [" + RenderDataPointUtil.toString(renderData) + "].");
 		}
 		
-		byte blockMaterialId = RenderDataPointUtil.getBlockMaterialId(data);
+		byte blockMaterialId = RenderDataPointUtil.getBlockMaterialId(renderData);
 		
 		
 		
@@ -325,11 +324,11 @@ public class ColumnRenderBufferBuilder
 				float brightnessMultiplier = Config.Client.Advanced.Graphics.Quality.brightnessMultiplier.get().floatValue();
 				if (saturationMultiplier == 1.0 && brightnessMultiplier == 1.0)
 				{
-					color = RenderDataPointUtil.getColor(data);
+					color = RenderDataPointUtil.getColor(renderData);
 				}
 				else
 				{
-					float[] ahsv = ColorUtil.argbToAhsv(RenderDataPointUtil.getColor(data));
+					float[] ahsv = ColorUtil.argbToAhsv(RenderDataPointUtil.getColor(renderData));
 					color = ColorUtil.ahsvToArgb(ahsv[0], ahsv[1], ahsv[2] * saturationMultiplier, ahsv[3] * brightnessMultiplier);
 				}
 				break;
@@ -419,14 +418,14 @@ public class ColumnRenderBufferBuilder
 		}
 		
 		ColumnBox.addBoxQuadsToBuilder(
-				quadBuilder, clientLevel,
+				quadBuilder, phantomArrayCheckout, clientLevel,
-				width, ySize, width,
+				blockWidth, blockMaxY,
-				xMin, yMin, zMin,
+				blockMinX, blockMinY, blockMinZ,
 				color,
 				blockMaterialId,
-				RenderDataPointUtil.getLightSky(data),
+				RenderDataPointUtil.getLightSky(renderData),
-				fullBright ? 15 : RenderDataPointUtil.getLightBlock(data),
+				fullBright ? LodUtil.MAX_MC_LIGHT : RenderDataPointUtil.getLightBlock(renderData),
-				topData, bottomData, adjColumnViews, isSameDetailLevel);
+				topRenderData, bottomRenderData, adjColumnViews, isSameDetailLevel);
 	}
 	
 }

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

@@ -19,16 +19,14 @@
 
 package com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding;
 
-import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
 import com.seibel.distanthorizons.core.render.glObject.GLProxy;
 import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer;
-import com.seibel.distanthorizons.core.render.renderer.LodRenderer;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.objects.StatsMap;
 import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod;
-import org.apache.logging.log4j.Logger;
 import org.lwjgl.system.MemoryUtil;
 
 import java.nio.ByteBuffer;
@@ -40,9 +38,9 @@ import java.util.concurrent.*;
  *
  * @see ColumnRenderBufferBuilder
  */
-public class ColumnRenderBuffer implements AutoCloseable
+public class LodBufferContainer implements AutoCloseable
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	/** number of bytes a single quad takes */
 	public static final int QUADS_BYTE_SIZE = LodUtil.LOD_VERTEX_FORMAT.getByteSize() * 4;
@@ -52,15 +50,16 @@ public class ColumnRenderBuffer implements AutoCloseable
 	public static final int FULL_SIZED_BUFFER = MAX_QUADS_PER_BUFFER * QUADS_BYTE_SIZE;
 	
 	
-	
+	/** the position closest to minimum X/Z infinity and the level's lowest Y */
-	public final DhBlockPos blockPos;
+	public final DhBlockPos minCornerBlockPos;
+	public final long pos;
 	
 	public boolean buffersUploaded = false;
 	
-	private GLVertexBuffer[] vbos;
+	public GLVertexBuffer[] vbos;
-	private GLVertexBuffer[] vbosTransparent;
+	public GLVertexBuffer[] vbosTransparent;
 	
-	private CompletableFuture<ColumnRenderBuffer> uploadFuture = null;
+	private CompletableFuture<LodBufferContainer> uploadFuture = null;
 	
 	
 	
@@ -68,9 +67,10 @@ public class ColumnRenderBuffer implements AutoCloseable
 	// constructors //
 	//==============//
 	
-	public ColumnRenderBuffer(DhBlockPos blockPos)
+	public LodBufferContainer(long pos, DhBlockPos minCornerBlockPos)
 	{
-		this.blockPos = blockPos;
+		this.pos = pos;
+		this.minCornerBlockPos = minCornerBlockPos;
 		this.vbos = new GLVertexBuffer[0];
 		this.vbosTransparent = new GLVertexBuffer[0];
 	}
@@ -82,10 +82,10 @@ public class ColumnRenderBuffer implements AutoCloseable
 	//==================//
 	
 	/** Should be run on a DH thread. */
-	public synchronized CompletableFuture<ColumnRenderBuffer> makeAndUploadBuffersAsync(LodQuadBuilder builder, EDhApiGpuUploadMethod gpuUploadMethod)
+	public synchronized CompletableFuture<LodBufferContainer> makeAndUploadBuffersAsync(LodQuadBuilder builder)
 	{
 		// separate variable to prevent race condition when checking null
-		CompletableFuture<ColumnRenderBuffer> future = this.uploadFuture;
+		CompletableFuture<LodBufferContainer> future = this.uploadFuture;
 		if (future != null)
 		{
 			// upload already in process
@@ -107,16 +107,19 @@ public class ColumnRenderBuffer 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();
 				}
 				
+				EDhApiGpuUploadMethod gpuUploadMethod = GLProxy.getInstance().getGpuUploadMethod();
+				
 				// upload on the render thread
 				uploadBuffersDirect(this.vbos, opaqueBuffers, gpuUploadMethod);
 				uploadBuffersDirect(this.vbosTransparent, transparentBuffers, gpuUploadMethod);
@@ -133,7 +136,7 @@ public class ColumnRenderBuffer implements AutoCloseable
 			}
 			catch (Exception e)
 			{
-				LOGGER.error("Unexpected issue uploading buffer ["+this.blockPos +"], error: ["+e.getMessage()+"].", e);
+				LOGGER.error("Unexpected issue uploading buffer ["+this.minCornerBlockPos +"], error: ["+e.getMessage()+"].", e);
 				
 				this.uploadFuture.completeExceptionally(e);
 				this.uploadFuture = null;
@@ -177,7 +180,9 @@ public class ColumnRenderBuffer implements AutoCloseable
 		}
 		return newVbos;
 	}
-	private static void uploadBuffersDirect(GLVertexBuffer[] vbos, ArrayList<ByteBuffer> byteBuffers, EDhApiGpuUploadMethod method) throws InterruptedException
+	private static void uploadBuffersDirect(
+			GLVertexBuffer[] vbos, ArrayList<ByteBuffer> byteBuffers, 
+			EDhApiGpuUploadMethod uploadMethod) throws InterruptedException
 	{
 		int vboIndex = 0;
 		for (int i = 0; i < byteBuffers.size(); i++)
@@ -191,7 +196,7 @@ public class ColumnRenderBuffer implements AutoCloseable
 			// get or create the VBO
 			if (vbos[vboIndex] == null)
 			{
-				vbos[vboIndex] = new GLVertexBuffer(method.useBufferStorage);
+				vbos[vboIndex] = new GLVertexBuffer(uploadMethod.useBufferStorage);
 			}
 			GLVertexBuffer vbo = vbos[vboIndex];
 			
@@ -202,13 +207,13 @@ public class ColumnRenderBuffer implements AutoCloseable
 			try
 			{
 				vbo.bind();
-				vbo.uploadBuffer(buffer, size / LodUtil.LOD_VERTEX_FORMAT.getByteSize(), method, FULL_SIZED_BUFFER);
+				vbo.uploadBuffer(buffer, size / LodUtil.LOD_VERTEX_FORMAT.getByteSize(), uploadMethod, FULL_SIZED_BUFFER);
 			}
 			catch (Exception e)
 			{
 				vbos[vboIndex] = null;
 				vbo.close();
-				LOGGER.error("Failed to upload buffer: ", e);
+				LOGGER.error("Failed to upload buffer. Error: ["+e.getMessage()+"].", e);
 			}
 			
 			vboIndex++;
@@ -222,69 +227,6 @@ public class ColumnRenderBuffer implements AutoCloseable
 	
 	
 	
-	//========//
-	// render //
-	//========//
-	
-	/** @return true if something was rendered, false otherwise */
-	public boolean renderOpaque(LodRenderer renderContext, DhApiRenderParam renderEventParam)
-	{
-		boolean hasRendered = false;
-		renderContext.setModelViewMatrixOffset(this.blockPos, renderEventParam);
-		for (GLVertexBuffer vbo : this.vbos)
-		{
-			if (vbo == null)
-			{
-				continue;
-			}
-			
-			if (vbo.getVertexCount() == 0)
-			{
-				continue;
-			}
-			
-			hasRendered = true;
-			renderContext.drawVbo(vbo, this);
-		}
-		return hasRendered;
-	}
-	
-	/** @return true if something was rendered, false otherwise */
-	public boolean renderTransparent(LodRenderer renderContext, DhApiRenderParam renderEventParam)
-	{
-		boolean hasRendered = false;
-		
-		try
-		{
-			// can throw an IllegalStateException if the GL program was freed before it should've been
-			renderContext.setModelViewMatrixOffset(this.blockPos, renderEventParam);
-			
-			for (GLVertexBuffer vbo : this.vbosTransparent)
-			{
-				if (vbo == null)
-				{
-					continue;
-				}
-				
-				if (vbo.getVertexCount() == 0)
-				{
-					continue;
-				}
-				
-				hasRendered = true;
-				renderContext.drawVbo(vbo, this);
-			}
-		}
-		catch (IllegalStateException e)
-		{
-			LOGGER.error("renderContext program doesn't exist for pos: "+this.blockPos, e);
-		}
-		
-		return hasRendered;
-	}
-	
-	
-	
 	//================//
 	// helper methods //
 	//================//
@@ -328,7 +270,7 @@ public class ColumnRenderBuffer implements AutoCloseable
 				
 				if (vertexBuffer.getSize() == 0)
 				{
-					GLProxy.GL_LOGGER.warn("VBO with size 0");
+					GLProxy.LOGGER.warn("VBO with size 0");
 				}
 				statsMap.incBytesStat("TotalUsage", vertexBuffer.getSize());
 			}
@@ -353,24 +295,21 @@ public class ColumnRenderBuffer 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

@@ -20,9 +20,7 @@
 package com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding;
 
 import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
 import java.util.*;
-import java.util.concurrent.atomic.AtomicLong;
 
 import com.seibel.distanthorizons.api.enums.config.EDhApiGrassSideRendering;
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
@@ -30,15 +28,13 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiDebugRendering;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer;
 import com.seibel.distanthorizons.core.util.ColorUtil;
-import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod;
-import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 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.apache.logging.log4j.Logger;
 import org.lwjgl.system.MemoryUtil;
 
 /**
@@ -48,8 +44,8 @@ import org.lwjgl.system.MemoryUtil;
  */
 public class LodQuadBuilder
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	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];
@@ -143,7 +139,8 @@ public class LodQuadBuilder
 	//===========//
 	
 	public void addQuadAdj(
-			EDhDirection dir, short x, short y, short z,
+			EDhDirection dir, 
+			short x, short y, short z,
 			short widthEastWest, short widthNorthSouthOrUpDown,
 			int color, byte irisBlockMaterialId, byte skyLight, byte blockLight)
 	{
@@ -152,13 +149,23 @@ 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()
-		if (!quadList.isEmpty() &&
+			&& (
-				(
+				quadList.get(quadList.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.EastWest)
-						quadList.get(quadList.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.EastWest)
+				|| quadList.get(quadList.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.NorthSouthOrUpDown))
-								|| quadList.get(quadList.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.NorthSouthOrUpDown))
+			)
-		)
 		{
 			this.premergeCount++;
 			return;
@@ -170,18 +177,23 @@ public class LodQuadBuilder
 	// XZ
 	public void addQuadUp(short minX, short maxY, short minZ, short widthEastWest, short widthNorthSouthOrUpDown, int color, byte irisBlockMaterialId, byte skylight, byte blocklight) // TODO argument names are wrong
 	{
-		BufferQuad quad = new BufferQuad(minX, maxY, minZ, widthEastWest, widthNorthSouthOrUpDown, color, irisBlockMaterialId, skylight, blocklight, EDhDirection.UP);
 		boolean isTransparent = (this.doTransparency && ColorUtil.getAlpha(color) < 255);
-		ArrayList<BufferQuad> quadList = isTransparent ? this.transparentQuads[EDhDirection.UP.ordinal()] : this.opaqueQuads[EDhDirection.UP.ordinal()];
+		ArrayList<BufferQuad> quadList = isTransparent 
+				? this.transparentQuads[EDhDirection.UP.ordinal()] 
+				: this.opaqueQuads[EDhDirection.UP.ordinal()];
+		
+		BufferQuad quad = new BufferQuad(minX, maxY, minZ, widthEastWest, widthNorthSouthOrUpDown, color, irisBlockMaterialId, skylight, blocklight, EDhDirection.UP);
 		quadList.add(quad);
 	}
 	
 	public void addQuadDown(short x, short y, short z, short width, short wz, int color, byte irisBlockMaterialId, byte skylight, byte blocklight)
 	{
+		ArrayList<BufferQuad> quadArray = (this.doTransparency && ColorUtil.getAlpha(color) < 255)
+				? this.transparentQuads[EDhDirection.DOWN.ordinal()]
+				: this.opaqueQuads[EDhDirection.DOWN.ordinal()];
+		
 		BufferQuad quad = new BufferQuad(x, y, z, width, wz, color, irisBlockMaterialId, skylight, blocklight, EDhDirection.DOWN);
-		ArrayList<BufferQuad> qs = (doTransparency && ColorUtil.getAlpha(color) < 255)
+		quadArray.add(quad);
-				? transparentQuads[EDhDirection.DOWN.ordinal()] : opaqueQuads[EDhDirection.DOWN.ordinal()];
-		qs.add(quad);
 	}
 	
 	
@@ -285,7 +297,7 @@ public class LodQuadBuilder
 				// create a new buffer
 				if (buffer == null || !buffer.hasRemaining())
 				{
-					buffer = MemoryUtil.memAlloc(ColumnRenderBuffer.FULL_SIZED_BUFFER);
+					buffer = MemoryUtil.memAlloc(LodBufferContainer.FULL_SIZED_BUFFER);
 					byteBufferList.add(buffer);
 				}
 				
@@ -309,7 +321,7 @@ public class LodQuadBuilder
 		short widthEastWest = quad.widthEastWest;
 		short widthNorthSouth = quad.widthNorthSouthOrUpDown;
 		byte normalIndex = (byte) quad.direction.ordinal();
-		EDhDirection.Axis axis = quad.direction.getAxis();
+		EDhDirection.Axis axis = quad.direction.axis;
 		for (int i = 0; i < quadBase.length; i++)
 		{
 			short dx, dy, dz;
@@ -357,18 +369,18 @@ public class LodQuadBuilder
 					if (this.grassSideRenderingMode != EDhApiGrassSideRendering.AS_GRASS)
 					{
 						// only change the vertex color if it's on the side or bottom
-						if (quad.direction.getAxis().isHorizontal() || quad.direction == EDhDirection.DOWN)
+						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
+								// 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)
+								|| (this.grassSideRenderingMode == EDhApiGrassSideRendering.FADE_TO_DIRT && quadBase[i][1] == 0)
-									// always render the bottom as dirt
+								// always render the bottom as dirt
-									|| quad.direction == EDhDirection.DOWN)
+								|| 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));
 							}
 						}
 					}
@@ -387,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;
+			skylight %= 16;
-		// mirco offset which is a xyz 2bit value
+			blocklight %= 16;
-		// 0b00 = no offset
+			meta |= (short) (skylight | (blocklight << 4));
-		// 0b01 = positive offset
+			
-		// 0b11 = negative offset
+			byte mircoOffset = 0;
-		// format is: 0b00zzyyxx
+			// mirco offset which is a xyz 2bit value
-		if (mx != 0) mirco |= mx > 0 ? 0b01 : 0b11;
+			// 0b00 = no offset
-		if (my != 0) mirco |= my > 0 ? 0b0100 : 0b1100;
+			// 0b01 = positive offset
-		if (mz != 0) mirco |= mz > 0 ? 0b010000 : 0b110000;
+			// 0b11 = negative offset
-		meta |= mirco << 8;
+			// 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);
@@ -456,7 +470,7 @@ public class LodQuadBuilder
 	}
 	
 	/** Returns how many GpuBuffers will be needed to render opaque quads in this builder. */
-	public int getCurrentNeededOpaqueVertexBufferCount() { return MathUtil.ceilDiv(this.getCurrentOpaqueQuadsCount(), ColumnRenderBuffer.MAX_QUADS_PER_BUFFER); }
+	public int getCurrentNeededOpaqueVertexBufferCount() { return MathUtil.ceilDiv(this.getCurrentOpaqueQuadsCount(), LodBufferContainer.MAX_QUADS_PER_BUFFER); }
 	/** Returns how many GpuBuffers will be needed to render transparent quads in this builder. */
 	public int getCurrentNeededTransparentVertexBufferCount()
 	{
@@ -465,7 +479,7 @@ public class LodQuadBuilder
 			return 0;
 		}
 		
-		return MathUtil.ceilDiv(this.getCurrentTransparentQuadsCount(), ColumnRenderBuffer.MAX_QUADS_PER_BUFFER);
+		return MathUtil.ceilDiv(this.getCurrentTransparentQuadsCount(), LodBufferContainer.MAX_QUADS_PER_BUFFER);
 	}
 	
 }

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

@@ -101,9 +101,7 @@ public final class ColumnArrayView implements IColumnDataView
 	
 	@Override
 	public ColumnArrayView subView(int dataIndexStart, int dataCount)
-	{
+	{ return new ColumnArrayView(data, dataCount * verticalSize, offset + dataIndexStart * verticalSize, verticalSize); }
-		return new ColumnArrayView(data, dataCount * verticalSize, offset + dataIndexStart * verticalSize, verticalSize);
-	}
 	
 	public void fill(long value) { Arrays.fill(data.elements(), offset, offset + size, value); }
 	
@@ -185,21 +183,11 @@ public final class ColumnArrayView implements IColumnDataView
 		{
 			for (int i = 0; i < this.dataCount(); i++)
 			{
-				RenderDataPointUtil.mergeMultiData(source.subView(i, 1), subView(i, 1));
+				RenderDataPointUtil.mergeMultiData(source.subView(i, 1), this.subView(i, 1));
 			}
 		}
 	}
 	
-	public void mergeMultiDataFrom(IColumnDataView source)
-	{
-		if (dataCount() != 1)
-		{
-			throw new IllegalArgumentException("output dataCount must be 1");
-		}
-		
-		RenderDataPointUtil.mergeMultiData(source, this);
-	}
-	
 	
 	
 	//================//
@@ -210,15 +198,15 @@ public final class ColumnArrayView implements IColumnDataView
 	public String toString()
 	{
 		StringBuilder sb = new StringBuilder();
-		sb.append("S:").append(size);
+		sb.append("S:").append(this.size);
-		sb.append(" V:").append(verticalSize);
+		sb.append(" V:").append(this.verticalSize);
-		sb.append(" O:").append(offset);
+		sb.append(" O:").append(this.offset);
 		
 		sb.append(" [");
-		for (int i = 0; i < size; i++)
+		for (int i = 0; i < this.size; i++)
 		{
-			sb.append(RenderDataPointUtil.toString(data.getLong(offset + i)));
+			sb.append(RenderDataPointUtil.toString(this.data.getLong(this.offset + i)));
-			if (i < size - 1)
+			if (i < this.size - 1)
 			{
 				sb.append(",\n");
 			}
@@ -229,11 +217,7 @@ public final class ColumnArrayView implements IColumnDataView
 	}
 	
 	
-	public int getDataHash()
+	public int getDataHash() { return arrayHash(this.data, this.offset, this.size); }
-	{
-		return arrayHash(data, offset, size);
-	}
-	
 	private static int arrayHash(LongArrayList a, int offset, int length)
 	{
 		if (a == null)
@@ -252,4 +236,6 @@ public final class ColumnArrayView implements IColumnDataView
 		return result;
 	}
 	
+	
+	
 }

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

@@ -140,40 +140,4 @@ public class ColumnQuadView implements IColumnDataView
 		}
 	}
 	
-	public void copyTo(ColumnQuadView target)
-	{
-		if (target.xSize != xSize || target.zSize != zSize)
-			throw new IllegalArgumentException("Target view must have same size as this view");
-		
-		for (int x = 0; x < xSize; x++)
-		{
-			target.getRow(x).changeVerticalSizeFrom(getRow(x));
-		}
-	}
-	
-	public void mergeMultiColumnFrom(ColumnQuadView source)
-	{
-		if (source.xSize == xSize && source.zSize == zSize)
-		{
-			source.copyTo(this);
-			return;
-		}
-		if (source.xSize < xSize || source.zSize < zSize)
-			throw new IllegalArgumentException("Source view must have same or larger size as this view");
-		
-		int srcXPerTrgX = source.xSize / xSize;
-		int srcZPerTrgZ = source.zSize / zSize;
-		if (source.xSize % xSize != 0 || source.zSize % zSize != 0)
-			throw new IllegalArgumentException("Source view's size must be a multiple of this view's size");
-		
-		for (int x = 0; x < xSize; x++)
-		{
-			for (int z = 0; z < zSize; z++)
-			{
-				ColumnQuadView srcBlock = source.subView(x * srcXPerTrgX, z * srcZPerTrgZ, srcXPerTrgX, srcZPerTrgZ);
-				get(x, z).mergeMultiDataFrom(srcBlock);
-			}
-		}
-	}
-	
 }

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

@@ -0,0 +1,199 @@
+package com.seibel.distanthorizons.core.dataObjects.transformers;
+
+import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+import com.seibel.distanthorizons.core.util.FullDataPointUtil;
+import com.seibel.distanthorizons.core.util.LodUtil;
+import it.unimi.dsi.fastutil.longs.LongArrayList;
+import org.jetbrains.annotations.NotNull;
+
+public class FullDataOcclusionCuller
+{
+	/**
+	 * Mutates the given datasource so blocks that aren't visible
+	 * (IE completely surrounded by other opaque blocks)
+	 * are removed from the data column.
+	 * 
+	 * @param dataSource
+	 * @param relX relative X position in the datasource
+	 * @param relZ relative Z position in the datasource
+	 */
+	public static void cullHiddenDatapointsInColumn(
+			FullDataSourceV2 dataSource,
+			int relX, int relZ
+	)
+	{
+		LongArrayList centerColumn = dataSource.getColumnAtRelPos(relX, relZ);
+		LongArrayList posXColumn = dataSource.tryGetColumnAtRelPos(relX + 1, relZ);
+		LongArrayList negXColumn = dataSource.tryGetColumnAtRelPos(relX - 1, relZ);
+		LongArrayList posZColumn = dataSource.tryGetColumnAtRelPos(relX, relZ + 1);
+		LongArrayList negZColumn = dataSource.tryGetColumnAtRelPos(relX, relZ - 1);
+		
+		if (posXColumn == null || posXColumn.size() == 0
+			|| negXColumn == null || negXColumn.size() == 0
+			|| posZColumn == null || posZColumn.size() == 0
+			|| negZColumn == null || negZColumn.size() == 0)
+		{
+			// if any adjacent columns are empty then we can't
+			// cull this column, since at least one side will be open
+			// to air/void
+			return;
+		}
+		
+		
+		int centerIndex = centerColumn.size() - 1;
+		int posXIndex = (posXColumn.size() - 1);
+		int negXIndex = (negXColumn.size() - 1);
+		int posZIndex = (posZColumn.size() - 1);
+		int negZIndex = (negZColumn.size() - 1);
+		
+		for (; centerIndex >= 0; centerIndex--)
+		{
+			long currentPoint = centerColumn.getLong(centerIndex);
+			
+			// Translucent data points are not eligible to be culled.
+			if (isTranslucent(dataSource, currentPoint))
+			{
+				continue;
+			}
+			
+			// the top segment should never be culled.
+			if (centerIndex == 0
+				|| isTranslucent(dataSource, centerColumn.getLong(centerIndex - 1)))
+			{
+				continue;
+			}
+			
+			// the bottom segment can sometimes be culled.
+			// assume it will not be seen from below,
+			// because this would imply the player is in the void.
+			if (centerIndex + 1 < centerColumn.size()
+				&& isTranslucent(dataSource, centerColumn.getLong(centerIndex + 1)))
+			{
+				continue;
+			}
+			
+			// the lowest/bedrock segment should not be culled
+			if (centerIndex + 1 == centerColumn.size())
+			{
+				continue;
+			}
+			
+			
+			posXIndex = checkOcclusion(dataSource, currentPoint, posXColumn, posXIndex);
+			if (posXIndex < 0)
+			{
+				posXIndex = ~posXIndex;
+				continue;
+			}
+			
+			negXIndex = checkOcclusion(dataSource, currentPoint, negXColumn, negXIndex);
+			if (negXIndex < 0)
+			{
+				negXIndex = ~negXIndex;
+				continue;
+			}
+			
+			posZIndex = checkOcclusion(dataSource, currentPoint, posZColumn, posZIndex);
+			if (posZIndex < 0)
+			{
+				posZIndex = ~posZIndex;
+				continue;
+			}
+			
+			negZIndex = checkOcclusion(dataSource, currentPoint, negZColumn, negZIndex);
+			if (negZIndex < 0)
+			{
+				negZIndex = ~negZIndex;
+				continue;
+			}
+			
+			
+			// Current point is fully surrounded. remove it.
+			centerColumn.removeLong(centerIndex);
+			
+			// Make the above data point cover the area that the current point used to occupy.
+			// The element that was at `centerIndex - 1` is still at that position even after removal of centerIndex.
+			long above = centerColumn.getLong(centerIndex - 1);
+			above = FullDataPointUtil.setBottomY(above, FullDataPointUtil.getBottomY(currentPoint));
+			above = FullDataPointUtil.setHeight(above, FullDataPointUtil.getHeight(currentPoint) + FullDataPointUtil.getHeight(above));
+			centerColumn.set(centerIndex - 1, above);
+		}
+	}
+	/**
+	 checks if centerPoint is "covered" by opaque data points in adjacentColumn.
+	 centerPoint counts as covered if, and only if, for all Y levels in its height range,
+	 there exists an opaque data point in adjacentColumn which overlaps with that Y level.
+	 
+	 @param source used to lookup blocks (and their opacities) based on their IDs.
+	 @param centerPoint the point being checked to see if it's fully covered.
+	 @param adjacentColumn the data points which might cover centerPoint.
+	 @param adjacentIndex the starting index in adjacentColumn to start scanning at.
+	 indices greater than adjacentIndex have already been checked and confirmed to
+	 not overlap or only overlap partially with centerPoint's Y range.
+	 
+	 @return if centerPoint is covered, returns the index of the segment which finishes covering it.
+	 the start of the covering may be a smaller index. in this case, the returned index may be used
+	 as the adjacentIndex provided to this method on the next iteration which yields a new centerPoint.
+	 
+	 if centerPoint is NOT covered, returns the bitwise negation of the index of the
+	 segment which did not cover it. this guarantees that the returned value is negative.
+	 the caller should check for negative return values and manually un-negate them to proceed with the loop.
+	 
+	 in other words, this function returns the index of the next adjacent data
+	 point to use in the loop, AND a boolean indicating whether or not the
+	 centerPoint is covered;	both are packed into the same int, and returned.
+	 */
+	private static int checkOcclusion(@NotNull FullDataSourceV2 source, long centerPoint, @NotNull LongArrayList adjacentColumn, int adjacentIndex)
+	{
+		// check if this point is adjacent to an empty column
+		// if so it will always be shown
+		if (adjacentColumn.isEmpty())
+		{
+			return ~adjacentIndex;
+		}
+		else if (adjacentColumn.size() == 1
+				&& adjacentColumn.getLong(0) == FullDataPointUtil.EMPTY_DATA_POINT)
+		{	
+			return ~adjacentIndex;
+		}
+		
+		
+		int bottomOfCenter = FullDataPointUtil.getBottomY(centerPoint);
+		int topOfCenter = bottomOfCenter + FullDataPointUtil.getHeight(centerPoint);
+		for (; adjacentIndex >= 0; adjacentIndex--)
+		{
+			long adjacentPoint = adjacentColumn.getLong(adjacentIndex);
+			int topOfAdjacent = FullDataPointUtil.getBottomY(adjacentPoint) + FullDataPointUtil.getHeight(adjacentPoint);
+			if (topOfAdjacent <= bottomOfCenter)
+			{
+				// the adjacent point is below the center point,
+				// check the next one
+				continue;
+			}
+			else if (isTranslucent(source, adjacentPoint))
+			{
+				// this point is adjacent to a transparent LOD and should be shown
+				return ~adjacentIndex;
+			}
+			else if (topOfAdjacent >= topOfCenter)
+			{
+				// the adjacent point covers the center point
+				return adjacentIndex;
+			}
+		}
+		
+		
+		// the Adjacent column ends before center column does,
+		// this point should be visible
+		return ~adjacentIndex;
+	}
+	private static boolean isTranslucent(FullDataSourceV2 source, long point)
+	{
+		int id = FullDataPointUtil.getId(point);
+		int opacity = source.mapping.getBlockStateWrapper(id).getOpacity();
+		return opacity < LodUtil.BLOCK_FULLY_OPAQUE;
+	}
+	
+	
+	
+}

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

@@ -34,13 +34,12 @@ import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPosMutable;
 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;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.HashSet;
@@ -50,14 +49,14 @@ import java.util.HashSet;
  */
 public class FullDataToRenderDataTransformer
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	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;
 	
 	
 	
@@ -66,7 +65,8 @@ public class FullDataToRenderDataTransformer
 	//==============================//
 	
 	@Nullable
-	public static ColumnRenderSource transformFullDataToRenderSource(@Nullable FullDataSourceV2 fullDataSource, @Nullable IClientLevelWrapper levelWrapper)
+	public static ColumnRenderSource transformFullDataToRenderSource(
+			@Nullable FullDataSourceV2 fullDataSource, @Nullable IClientLevelWrapper levelWrapper)
 	{
 		if (fullDataSource == null)
 		{
@@ -102,7 +102,8 @@ public class FullDataToRenderDataTransformer
 	 * @throws InterruptedException Can be caused by interrupting the thread upstream.
 	 * Generally thrown if the method is running after the client leaves the current world.
 	 */
-	private static ColumnRenderSource transformCompleteFullDataToColumnData(IClientLevelWrapper levelWrapper, FullDataSourceV2 fullDataSource) throws InterruptedException
+	private static ColumnRenderSource transformCompleteFullDataToColumnData(
+			IClientLevelWrapper levelWrapper, FullDataSourceV2 fullDataSource) throws InterruptedException
 	{
  		final long pos = fullDataSource.getPos();
 		final byte dataDetail = fullDataSource.getDataDetailLevel();
@@ -125,10 +126,8 @@ public class FullDataToRenderDataTransformer
 		{
 			for (int z = 0; z < FullDataSourceV2.WIDTH; z++)
 			{
-				throwIfThreadInterrupted();
-				
 				ColumnArrayView columnArrayView = columnSource.getVerticalDataPointView(x, z);
-				LongArrayList dataColumn = fullDataSource.get(x, z);
+				LongArrayList dataColumn = fullDataSource.getColumnAtRelPos(x, z);
 				
 				updateOrReplaceRenderDataViewColumnWithFullDataColumn(
 						levelWrapper, fullDataSource, 
@@ -138,7 +137,7 @@ public class FullDataToRenderDataTransformer
 			}
 		}
 		
-		columnSource.fillDebugFlag(0, 0, ColumnRenderSource.SECTION_SIZE, ColumnRenderSource.SECTION_SIZE, ColumnRenderSource.DebugSourceFlag.FULL);
+		columnSource.fillDebugFlag(0, 0, ColumnRenderSource.WIDTH, ColumnRenderSource.WIDTH, ColumnRenderSource.DebugSourceFlag.FULL);
 		
 		return columnSource;
 	}
@@ -173,6 +172,7 @@ public class FullDataToRenderDataTransformer
 				// expand the ColumnArrayView to fit the new larger max vertical size
 				ColumnArrayView newColumnArrayView = new ColumnArrayView(dataArrayList, fullDataLength, 0, fullDataLength);
 				setRenderColumnView(levelWrapper, fullDataSource, blockX, blockZ, newColumnArrayView, fullDataColumn);
+				
 				columnArrayView.changeVerticalSizeFrom(newColumnArrayView);
 			}
 			finally
@@ -196,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()
@@ -250,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()+"]) " +
@@ -277,18 +287,18 @@ public class FullDataToRenderDataTransformer
 			if (caveBlock)
 			{
 				if (caveCullingEnabled
-					// assume this data point is underground if it has no sky-light
+						// assume this data point is underground if it has no sky-light
-					&& skyLight == LodUtil.MIN_MC_LIGHT	
+						&& skyLight == LodUtil.MIN_MC_LIGHT
-					// ignore caves above a certain height to prevent floating islands from having walls underneath them
+						// ignore caves above a certain height to prevent floating islands from having walls underneath them
-					&& topY < caveCullingMaxY
+						&& topY < caveCullingMaxY
-					// cave culling shouldn't happen when at the top of the world
+						// cave culling shouldn't happen when at the top of the world
-					&& renderDataIndex != 0 && fullDataIndex != 0
+						&& renderDataIndex != 0 && fullDataIndex != 0
-					// cave culling can't happen when at the bottom of the world
+						// cave culling can't happen when at the bottom of the world
-					&& (fullDataIndex+1) < fullColumnData.size())
+						&& (fullDataIndex + 1) < fullColumnData.size())
 				{
 					// we need to get the next sky/block lights because
 					// the air block here will always have a light of 0/0 due to only the top of the LOD's light being saved.
-					long nextFullData = fullColumnData.getLong(fullDataIndex+1);
+					long nextFullData = fullColumnData.getLong(fullDataIndex + 1);
 					int nextSkyLight = FullDataPointUtil.getSkyLight(nextFullData);
 					
 					if (nextSkyLight == LodUtil.MIN_MC_LIGHT
@@ -322,10 +332,26 @@ public class FullDataToRenderDataTransformer
 			// non-solid block check //
 			//=======================//
 			
-			if (ignoreNonCollidingBlocks 
+			boolean ignoreNonSolidBlock =
-				&& !block.isSolid() 
+				ignoreNonCollidingBlocks
-				&& !block.isLiquid() 
+				&& !block.isSolid()
-				&& block.getOpacity() != LodUtil.BLOCK_FULLY_OPAQUE)
+				&& !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)
 				{
@@ -335,7 +361,7 @@ public class FullDataToRenderDataTransformer
 					// this prevents issues if grass is transparent
 					if (ColorUtil.getAlpha(tempColor) != 0)
 					{
-						colorToApplyToNextBlock = ColorUtil.setAlpha(tempColor,255);
+						colorToApplyToNextBlock = ColorUtil.setAlpha(tempColor, 255);
 						skylightToApplyToNextBlock = skyLight;
 						blocklightToApplyToNextBlock = blockLight;
 					}
@@ -368,7 +394,9 @@ public class FullDataToRenderDataTransformer
 			//=============================//
 			
 			// check if they share a top-bottom face and if they have same color
-			if (color == lastColor && bottomY + blockHeight == lastBottom  && renderDataIndex > 0)
+			if (color == lastColor 
+				&& bottomY + blockHeight == lastBottom  
+				&& renderDataIndex > 0)
 			{
 				//replace the previous block with new bottom
 				long columnData = renderColumnData.get(renderDataIndex - 1);
@@ -396,21 +424,4 @@ public class FullDataToRenderDataTransformer
 	
 	
 	
-	//================//
-	// helper methods //
-	//================//
-	
-	/**
-	 * Called in loops that may run for an extended period of time. <br>
-	 * This is necessary to allow canceling these transformers since running
-	 * them after the client has left a given world will throw exceptions.
-	 */
-	private static void throwIfThreadInterrupted() throws InterruptedException
-	{
-		if (Thread.interrupted())
-		{
-			throw new InterruptedException(FullDataToRenderDataTransformer.class.getSimpleName() + " task interrupted.");
-		}
-	}
-	
 }

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

@@ -24,8 +24,6 @@ import java.util.List;
 
 import com.seibel.distanthorizons.api.enums.config.EDhApiWorldCompressionMode;
 import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiWorldGenerationStep;
-import com.seibel.distanthorizons.api.interfaces.block.IDhApiBiomeWrapper;
-import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper;
 import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiChunkProcessingEvent;
 import com.seibel.distanthorizons.api.objects.data.DhApiChunk;
 import com.seibel.distanthorizons.api.objects.data.DhApiTerrainDataPoint;
@@ -46,12 +44,12 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.Nullable;
 
 public class LodDataBuilder
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	private static final IWrapperFactory WRAPPER_FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
 	private static final IBlockStateWrapper AIR = WRAPPER_FACTORY.getAirBlockStateWrapper();
 	
@@ -76,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;
 		
@@ -118,7 +116,6 @@ public class LodDataBuilder
 		//==========================//
 		
 		EDhApiWorldCompressionMode worldCompressionMode = Config.Common.LodBuilding.worldCompression.get();
-		boolean ignoreHiddenBlocks = (worldCompressionMode != EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS);
 		
 		try
 		{
@@ -142,7 +139,7 @@ public class LodDataBuilder
 					int columnZ = relBlockZ + chunkOffsetZ;
 					
 					// Get column data
-					LongArrayList longs = dataSource.get(columnX, columnZ);
+					LongArrayList longs = dataSource.getColumnAtRelPos(columnX, columnZ);
 					if (longs == null)
 					{
 						longs = new LongArrayList(dataCapacity);
@@ -247,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;
+							}
 						}
 					}
 					
@@ -257,11 +263,6 @@ public class LodDataBuilder
 					dataSource.setSingleColumn(longs, columnX, columnZ, EDhApiWorldGenerationStep.LIGHT, worldCompressionMode);
 				}
 			}
-			
-			if (ignoreHiddenBlocks)
-			{
-				cullHiddenBlocks(dataSource, chunkOffsetX, chunkOffsetZ);
-			}
 		}
 		catch (DataCorruptedException e)
 		{
@@ -269,157 +270,9 @@ public class LodDataBuilder
 			return null;
 		}
 		
-		LodUtil.assertTrue(!dataSource.isEmpty);
 		return dataSource;
 	}
 	
-	private static void cullHiddenBlocks(FullDataSourceV2 dataSource, int chunkOffsetX, int chunkOffsetZ)
-	{
-		for (int relZ = 1; relZ < LodUtil.CHUNK_WIDTH - 1; relZ++)
-		{
-			for (int relX = 1; relX < LodUtil.CHUNK_WIDTH - 1; relX++)
-			{
-				LongArrayList
-						centerColumn = dataSource.get(relX + chunkOffsetX, relZ + chunkOffsetZ),
-						posXColumn = dataSource.get(relX + chunkOffsetX + 1, relZ + chunkOffsetZ),
-						negXColumn = dataSource.get(relX + chunkOffsetX - 1, relZ + chunkOffsetZ),
-						posZColumn = dataSource.get(relX + chunkOffsetX, relZ + chunkOffsetZ + 1),
-						negZColumn = dataSource.get(relX + chunkOffsetX, relZ + chunkOffsetZ - 1);
-				int
-						centerIndex = centerColumn.size() - 1,
-						posXIndex = posXColumn.size() - 1,
-						negXIndex = negXColumn.size() - 1,
-						posZIndex = posZColumn.size() - 1,
-						negZIndex = negZColumn.size() - 1;
-				for (; centerIndex >= 0; centerIndex--)
-				{
-					long currentPoint = centerColumn.getLong(centerIndex);
-					
-					// Translucent data points are not eligible to be culled.
-					if (isTranslucent(dataSource, currentPoint))
-					{
-						continue;
-					}
-					
-					// the top segment should never be culled.
-					if (centerIndex == 0
-							|| isTranslucent(dataSource, centerColumn.getLong(centerIndex - 1))
-					)
-					{
-						continue;
-					}
-					
-					// the bottom segment can sometimes be culled.
-					// assume it will not be seen from below,
-					// because this would imply the player is in the void.
-					if (centerIndex + 1 < centerColumn.size()
-							&& isTranslucent(dataSource, centerColumn.getLong(centerIndex + 1))
-					)
-					{
-						continue;
-					}
-					
-					// the lowest/bedrock segment should not be culled
-					if (centerIndex + 1 == centerColumn.size())
-					{
-						continue;
-					}
-					
-					posXIndex = checkOcclusion(dataSource, currentPoint, posXColumn, posXIndex);
-					if (posXIndex < 0)
-					{
-						posXIndex = ~posXIndex;
-						continue;
-					}
-					
-					negXIndex = checkOcclusion(dataSource, currentPoint, negXColumn, negXIndex);
-					if (negXIndex < 0)
-					{
-						negXIndex = ~negXIndex;
-						continue;
-					}
-					
-					posZIndex = checkOcclusion(dataSource, currentPoint, posZColumn, posZIndex);
-					if (posZIndex < 0)
-					{
-						posZIndex = ~posZIndex;
-						continue;
-					}
-					
-					negZIndex = checkOcclusion(dataSource, currentPoint, negZColumn, negZIndex);
-					if (negZIndex < 0)
-					{
-						negZIndex = ~negZIndex;
-						continue;
-					}
-					
-					// Current point is fully surrounded. remove it.
-					centerColumn.removeLong(centerIndex);
-					
-					// Make the above data point cover the area that the current point used to occupy.
-					// The element that was at `centerIndex - 1` is still at that position even after removal of centerIndex.
-					long above = centerColumn.getLong(centerIndex - 1);
-					above = FullDataPointUtil.setBottomY(above, FullDataPointUtil.getBottomY(currentPoint));
-					above = FullDataPointUtil.setHeight(above, FullDataPointUtil.getHeight(currentPoint) + FullDataPointUtil.getHeight(above));
-					centerColumn.set(centerIndex - 1, above);
-				}
-			}
-		}
-	}
-	
-	/**
-	 checks if centerPoint is "covered" by opaque data points in adjacentColumn.
-	 centerPoint counts as covered if, and only if, for all Y levels in its height range,
-	 there exists an opaque data point in adjacentColumn which overlaps with that Y level.
-	 
-	 @param source used to lookup blocks (and their opacities) based on their IDs.
-	 @param centerPoint the point being checked to see if it's fully covered.
-	 @param adjacentColumn the data points which might cover centerPoint.
-	 @param adjacentIndex the starting index in adjacentColumn to start scanning at.
-	 indices greater than adjacentIndex have already been checked and confirmed to
-	 not overlap or only overlap partially with centerPoint's Y range.
-	 
-	 @return if centerPoint is covered, returns the index of the segment which finishes covering it.
-	 the start of the covering may be a smaller index. in this case, the returned index may be used
-	 as the adjacentIndex provided to this method on the next iteration which yields a new centerPoint.
-	 
-	 if centerPoint is NOT covered, returns the bitwise negation of the index of the
-	 segment which did not cover it. this guarantees that the returned value is negative.
-	 the caller should check for negative return values and manually un-negate them to proceed with the loop.
-	 
-	 in other words, this function returns the index of the next adjacent data
-	 point to use in the loop, AND a boolean indicating whether or not the
-	 centerPoint is covered;	both are packed into the same int, and returned.
-	 */
-	private static int checkOcclusion(FullDataSourceV2 source, long centerPoint, LongArrayList adjacentColumn, int adjacentIndex)
-	{
-		int bottomOfCenter = FullDataPointUtil.getBottomY(centerPoint);
-		int topOfCenter = bottomOfCenter + FullDataPointUtil.getHeight(centerPoint);
-		for (; adjacentIndex >= 0; adjacentIndex--)
-		{
-			long adjacentPoint = adjacentColumn.getLong(adjacentIndex);
-			int topOfAdjacent = FullDataPointUtil.getBottomY(adjacentPoint) + FullDataPointUtil.getHeight(adjacentPoint);
-			if (topOfAdjacent <= bottomOfCenter)
-			{
-				continue;
-			}
-			else if (isTranslucent(source, adjacentPoint))
-			{
-				return ~adjacentIndex;
-			}
-			else if (topOfAdjacent >= topOfCenter)
-			{
-				return adjacentIndex;
-			}
-		}
-		
-		throw new LodUtil.AssertFailureException("Adjacent column ends before center column does.");
-	}
-	
-	private static boolean isTranslucent(FullDataSourceV2 source, long point) {
-		return source.mapping.getBlockStateWrapper(FullDataPointUtil.getId(point)).getOpacity() < LodUtil.BLOCK_FULLY_OPAQUE;
-	}
-	
 	
 	
 	/** @throws ClassCastException if an API user returns the wrong object type(s) */
@@ -444,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
@@ -458,7 +327,6 @@ public class LodDataBuilder
 						packedDataPoints,
 						relBlockX + relSourceBlockX, relBlockZ + relSourceBlockZ,
 						EDhApiWorldGenerationStep.LIGHT, EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS);
-				dataSource.isEmpty = false;
 			}
 		}
 		return dataSource;
@@ -472,41 +340,97 @@ public class LodDataBuilder
 	
 	/** @see FullDataPointUtil */
 	public static LongArrayList convertApiDataPointListToPackedLongArray(
-			@Nullable List<DhApiTerrainDataPoint> columnDataPoints, FullDataSourceV2 dataSource,
+			@Nullable List<DhApiTerrainDataPoint> topDownColumnDataPoints, FullDataSourceV2 dataSource,
-			int bottomYBlockPos) throws DataCorruptedException
+			int bottomYBlockPos, boolean runAdditionalValidation) throws DataCorruptedException
 	{
-		// this null check does 2 nice things at the same time:
+		if (topDownColumnDataPoints == null 
-		// if columnDataPoints is null,
+			|| topDownColumnDataPoints.size() == 0)
-		// 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++)
 		{
-			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(
+			int thisId = dataSource.mapping.addIfNotPresentAndGetId(
-					(IBiomeWrapper) (dataPoint.biomeWrapper),
+					(IBiomeWrapper) (apiDataPoint.biomeWrapper),
-					(IBlockStateWrapper) (dataPoint.blockStateWrapper)
+					(IBlockStateWrapper) (apiDataPoint.blockStateWrapper)
 			);
+			int thisHeight = (apiDataPoint.topYBlockPos - apiDataPoint.bottomYBlockPos);
 			
-			packedDataPoints.set(index, FullDataPointUtil.encode(
+			int lastId = FullDataPointUtil.getId(lastDataPoint);
-					id,
+			byte lastBlockLight = (byte)FullDataPointUtil.getBlockLight(lastDataPoint);
-					dataPoint.topYBlockPos - dataPoint.bottomYBlockPos,
+			byte lastSkyLight = (byte)FullDataPointUtil.getSkyLight(lastDataPoint);
-					dataPoint.bottomYBlockPos - bottomYBlockPos,
+			
-					(byte) (dataPoint.blockLightLevel),
+			
-					(byte) (dataPoint.skyLightLevel)
+			// 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 putListInTopDownOrder(List<DhApiTerrainDataPoint> dataPoints)
-	public static void correctDataColumnOrder(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/dependencyInjection/ModAccessorInjector.java

@@ -23,7 +23,7 @@ import com.seibel.distanthorizons.coreapi.DependencyInjection.DependencyInjector
 import com.seibel.distanthorizons.coreapi.interfaces.dependencyInjection.IBindable;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModAccessor;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.lang.invoke.MethodHandles;
 
@@ -40,7 +40,7 @@ import java.lang.invoke.MethodHandles;
  */
 public class ModAccessorInjector extends DependencyInjector<IModAccessor>
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger(MethodHandles.lookup().lookupClass().getSimpleName());
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	public static final ModAccessorInjector INSTANCE = new ModAccessorInjector(IModAccessor.class);
 	

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

@@ -19,496 +19,165 @@
 
 package com.seibel.distanthorizons.core.enums;
 
-import java.util.Arrays;
-import java.util.Locale;
-import java.util.Map;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
 import com.seibel.distanthorizons.core.util.math.Vec3i;
 
 /**
- * An (almost) exact copy of Minecraft's
- * Direction enum. <Br><Br>
- *
  * Up <Br>
  * Down <Br>
  * North <Br>
  * South <Br>
  * East <Br>
  * West <Br>
- *
- * @author James Seibel
- * @version 2021-11-13
  */
 public enum EDhDirection
 {
 	/** negative Y */
-	DOWN(0, 1, -1, "down", EDhDirection.AxisDirection.NEGATIVE, EDhDirection.Axis.Y, new Vec3i(0, -1, 0)),
+	DOWN("down", EDhDirection.AxisDirection.NEGATIVE, EDhDirection.Axis.Y, new Vec3i(0, -1, 0), -1),
 	/** positive Y */
-	UP(1, 0, -1, "up", EDhDirection.AxisDirection.POSITIVE, EDhDirection.Axis.Y, new Vec3i(0, 1, 0)),
+	UP("up", EDhDirection.AxisDirection.POSITIVE, EDhDirection.Axis.Y, new Vec3i(0, 1, 0), -1),
 	/** negative Z */
-	NORTH(2, 3, 2, "north", EDhDirection.AxisDirection.NEGATIVE, EDhDirection.Axis.Z, new Vec3i(0, 0, -1)),
+	NORTH("north", EDhDirection.AxisDirection.NEGATIVE, EDhDirection.Axis.Z, new Vec3i(0, 0, -1), 0),
 	/** positive Z */
-	SOUTH(3, 2, 0, "south", EDhDirection.AxisDirection.POSITIVE, EDhDirection.Axis.Z, new Vec3i(0, 0, 1)),
+	SOUTH("south", EDhDirection.AxisDirection.POSITIVE, EDhDirection.Axis.Z, new Vec3i(0, 0, 1), 1),
 	/** negative X */
-	WEST(4, 5, 1, "west", EDhDirection.AxisDirection.NEGATIVE, EDhDirection.Axis.X, new Vec3i(-1, 0, 0)),
+	WEST("west", EDhDirection.AxisDirection.NEGATIVE, EDhDirection.Axis.X, new Vec3i(-1, 0, 0), 2),
 	/** positive X */
-	EAST(5, 4, 3, "east", EDhDirection.AxisDirection.POSITIVE, EDhDirection.Axis.X, new Vec3i(1, 0, 0));
+	EAST("east", EDhDirection.AxisDirection.POSITIVE, EDhDirection.Axis.X, new Vec3i(1, 0, 0), 3);
 	
-	/**
+	
-	 * Up, Down, West, East, North, South <br>
+	/** Up, Down, West, East, North, South */
-	 * Similar to {@link EDhDirection#OPPOSITE_DIRECTIONS}, just with a different order
+	public static final EDhDirection[] ALL = new EDhDirection[] {
-	 */
-	public static final EDhDirection[] CARDINAL_DIRECTIONS = new EDhDirection[]{
 			EDhDirection.UP,
 			EDhDirection.DOWN,
 			EDhDirection.WEST,
 			EDhDirection.EAST,
 			EDhDirection.NORTH,
-			EDhDirection.SOUTH};
+			EDhDirection.SOUTH
+	};
 	
-	/**
+	/** North, South, East, West */
-	 * Up, Down, South, North, East, West <br>
+	public static final EDhDirection[] CARDINAL_COMPASS = new EDhDirection[] {
-	 * Similar to {@link EDhDirection#CARDINAL_DIRECTIONS}, just with a different order
-	 */
-	public static final EDhDirection[] OPPOSITE_DIRECTIONS = new EDhDirection[]{
-			EDhDirection.UP,
-			EDhDirection.DOWN,
-			EDhDirection.SOUTH,
-			EDhDirection.NORTH,
-			EDhDirection.EAST,
-			EDhDirection.WEST};
-	
-	/** North, South, East, West */ // TODO rename to state this is just X/Z or flat directions
-	public static final EDhDirection[] ADJ_DIRECTIONS = new EDhDirection[]{
 			EDhDirection.EAST,
 			EDhDirection.WEST,
 			EDhDirection.SOUTH,
-			EDhDirection.NORTH};
+			EDhDirection.NORTH
-
+	};
-//	private final int data3d;
-//	private final int oppositeIndex;
-//	private final int data2d;
 	
-	private final String name;
-	private final EDhDirection.Axis axis;
-	private final EDhDirection.AxisDirection axisDirection;
-	private final Vec3i normal;
-	private static final EDhDirection[] VALUES = values();
 	
-	private static final Map<String, EDhDirection> BY_NAME = Arrays.stream(VALUES).collect(Collectors.toMap(EDhDirection::getName, (p_199787_0_) ->
+	
+	public final String name;
+	public final EDhDirection.Axis axis;
+	public final EDhDirection.AxisDirection axisDirection;
+	public final Vec3i normal;
+	/** -1 if not a {@link EDhDirection#CARDINAL_COMPASS} direction */
+	public final int compassIndex;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+		
+	EDhDirection(String name, EDhDirection.AxisDirection axisDirection, EDhDirection.Axis axis, Vec3i normal, int compassIndex)
 	{
-		return p_199787_0_;
+		this.name = name;
-	}));
+		this.axis = axis;
-
+		this.axisDirection = axisDirection;
-//	private static final LodDirection[] BY_3D_DATA = Arrays.stream(VALUES).sorted(Comparator.comparingInt((p_199790_0_) ->
+		this.normal = normal;
-//	{
+		this.compassIndex = compassIndex;
-//		return p_199790_0_.data3d;
-//	})).toArray((p_199788_0_) ->
-//	{
-//		return new LodDirection[p_199788_0_];
-//	});
-//	
-//	private static final LodDirection[] BY_2D_DATA = Arrays.stream(VALUES).filter((p_199786_0_) ->
-//	{
-//		return p_199786_0_.getAxis().isHorizontal();
-//	}).sorted(Comparator.comparingInt((p_199789_0_) ->
-//	{
-//		return p_199789_0_.data2d;
-//	})).toArray((p_199791_0_) ->
-//	{
-//		return new LodDirection[p_199791_0_];
-//	});
-
-//	private static final Long2ObjectMap<LodDirection> BY_NORMAL = Arrays.stream(VALUES).collect(Collectors.toMap((p_218385_0_) ->
-//	{
-//		return (new BlockPos(p_218385_0_.getNormal())).asLong();
-//	}, (p_218384_0_) ->
-//	{
-//		return p_218384_0_;
-//	}, (p_218386_0_, p_218386_1_) ->
-//	{
-//		throw new IllegalArgumentException("Duplicate keys");
-//	}, Long2ObjectOpenHashMap::new));
-	
-	
-	
-	EDhDirection(int p_i46016_3_, int p_i46016_4_, int p_i46016_5_, String p_i46016_6_, EDhDirection.AxisDirection p_i46016_7_, EDhDirection.Axis p_i46016_8_, Vec3i p_i46016_9_)
-	{
-//		this.data3d = p_i46016_3_;
-//		this.data2d = p_i46016_5_;
-//		this.oppositeIndex = p_i46016_4_;
-		this.name = p_i46016_6_;
-		this.axis = p_i46016_8_;
-		this.axisDirection = p_i46016_7_;
-		this.normal = p_i46016_9_;
 	}
-
-
-
-
-//	public static LodDirection[] orderedByNearest(Entity p_196054_0_)
-//	{
-//		float f = p_196054_0_.getViewXRot(1.0F) * ((float) Math.PI / 180F);
-//		float f1 = -p_196054_0_.getViewYRot(1.0F) * ((float) Math.PI / 180F);
-//		float f2 = MathHelper.sin(f);
-//		float f3 = MathHelper.cos(f);
-//		float f4 = MathHelper.sin(f1);
-//		float f5 = MathHelper.cos(f1);
-//		boolean flag = f4 > 0.0F;
-//		boolean flag1 = f2 < 0.0F;
-//		boolean flag2 = f5 > 0.0F;
-//		float f6 = flag ? f4 : -f4;
-//		float f7 = flag1 ? -f2 : f2;
-//		float f8 = flag2 ? f5 : -f5;
-//		float f9 = f6 * f3;
-//		float f10 = f8 * f3;
-//		LodDirection lodDirection = flag ? EAST : WEST;
-//		LodDirection direction1 = flag1 ? UP : DOWN;
-//		LodDirection direction2 = flag2 ? SOUTH : NORTH;
-//		if (f6 > f8)
-//		{
-//			if (f7 > f9)
-//			{
-//				return makeDirectionArray(direction1, lodDirection, direction2);
-//			}
-//			else
-//			{
-//				return f10 > f7 ? makeDirectionArray(lodDirection, direction2, direction1) : makeDirectionArray(lodDirection, direction1, direction2);
-//			}
-//		}
-//		else if (f7 > f10)
-//		{
-//			return makeDirectionArray(direction1, direction2, lodDirection);
-//		}
-//		else
-//		{
-//			return f9 > f7 ? makeDirectionArray(direction2, lodDirection, direction1) : makeDirectionArray(direction2, direction1, lodDirection);
-//		}
-//	}
-
-//	private static LodDirection[] makeDirectionArray(LodDirection p_196053_0_, LodDirection p_196053_1_, LodDirection p_196053_2_)
-//	{
-//		return new LodDirection[] { p_196053_0_, p_196053_1_, p_196053_2_, p_196053_2_.getOpposite(), p_196053_1_.getOpposite(), p_196053_0_.getOpposite() };
-//	}
-
-//	public static LodDirection rotate(Mat4f p_229385_0_, LodDirection p_229385_1_)
-//	{
-//		Vec3i Vec3i = p_229385_1_.getNormal();
-//		Vector4f vector4f = new Vector4f(Vec3i.getX(), Vec3i.getY(), Vec3i.getZ(), 0.0F);
-//		vector4f.transform(p_229385_0_);
-//		return getNearest(vector4f.x(), vector4f.y(), vector4f.z());
-//	}
-
-//	public Quaternion getRotation()
-//	{
-//		Quaternion quaternion = Vector3f.XP.rotationDegrees(90.0F);
-//		switch (this)
-//		{
-//		case DOWN:
-//			return Vector3f.XP.rotationDegrees(180.0F);
-//		case UP:
-//			return Quaternion.ONE.copy();
-//		case NORTH:
-//			quaternion.mul(Vector3f.ZP.rotationDegrees(180.0F));
-//			return quaternion;
-//		case SOUTH:
-//			return quaternion;
-//		case WEST:
-//			quaternion.mul(Vector3f.ZP.rotationDegrees(90.0F));
-//			return quaternion;
-//		case EAST:
-//		default:
-//			quaternion.mul(Vector3f.ZP.rotationDegrees(-90.0F));
-//			return quaternion;
-//		}
-//	}
-
-//	public int get3DDataValue()
-//	{
-//		return this.data3d;
-//	}
-//	
-//	public int get2DDataValue()
-//	{
-//		return this.data2d;
-//	}
 	
-	public EDhDirection.AxisDirection getAxisDirection()
-	{
-		return this.axisDirection;
-	}
-
-//	public LodDirection getOpposite()
-//	{
-//		return from3DDataValue(this.oppositeIndex);
-//	}
 	
-	public EDhDirection getClockWise()
+	
-	{
+	//=========//
-		switch (this)
+	// methods //
+	//=========//
+	
+	public EDhDirection opposite()
+	{ 
+		switch(this)
 		{
+			case UP:
+				return EDhDirection.DOWN;
+			case DOWN:
+				return EDhDirection.UP;
+				
 			case NORTH:
-				return EAST;
+				return EDhDirection.SOUTH;
 			case SOUTH:
-				return WEST;
+				return EDhDirection.NORTH;
-			case WEST:
+				
-				return NORTH;
 			case EAST:
-				return SOUTH;
+				return EDhDirection.WEST;
-			default:
-				throw new IllegalStateException("Unable to get Y-rotated facing of " + this);
-		}
-	}
-	
-	public EDhDirection getCounterClockWise()
-	{
-		switch (this)
-		{
-			case NORTH:
-				return WEST;
-			case SOUTH:
-				return EAST;
 			case WEST:
-				return SOUTH;
+				return EDhDirection.EAST;
-			case EAST:
+				
-				return NORTH;
 			default:
-				throw new IllegalStateException("Unable to get CCW facing of " + this);
+				throw new IllegalArgumentException();
 		}
 	}
 	
-	public String getName()
-	{
-		return this.name;
-	}
 	
-	public EDhDirection.Axis getAxis()
+	@Override
-	{
+	public String toString() { return this.name; }
-		return this.axis;
-	}
 	
-	public static EDhDirection byName(String name)
-	{
-		return name == null ? null : BY_NAME.get(name.toLowerCase(Locale.ROOT));
-	}
-
-//	public static LodDirection from3DDataValue(int p_82600_0_)
-//	{
-//		return BY_3D_DATA[MathHelper.abs(p_82600_0_ % BY_3D_DATA.length)];
-//	}
-//	
-//	public static LodDirection from2DDataValue(int p_176731_0_)
-//	{
-//		return BY_2D_DATA[MathHelper.abs(p_176731_0_ % BY_2D_DATA.length)];
-//	}
-
-//	@Nullable
-//	public static LodDirection fromNormal(int p_218383_0_, int p_218383_1_, int p_218383_2_)
-//	{
-//		return BY_NORMAL.get(BlockPos.asLong(p_218383_0_, p_218383_1_, p_218383_2_));
-//	}
-
-//	public static LodDirection fromYRot(double p_176733_0_)
-//	{
-//		return from2DDataValue(MathHelper.floor(p_176733_0_ / 90.0D + 0.5D) & 3);
-//	}
 	
-	public static EDhDirection fromAxisAndDirection(EDhDirection.Axis p_211699_0_, EDhDirection.AxisDirection p_211699_1_)
-	{
-		switch (p_211699_0_)
-		{
-			case X:
-				return p_211699_1_ == EDhDirection.AxisDirection.POSITIVE ? EAST : WEST;
-			case Y:
-				return p_211699_1_ == EDhDirection.AxisDirection.POSITIVE ? UP : DOWN;
-			case Z:
-			default:
-				return p_211699_1_ == EDhDirection.AxisDirection.POSITIVE ? SOUTH : NORTH;
-		}
-	}
-
-//	public float toYRot()
-//	{
-//		return (this.data2d & 3) * 90;
-//	}
-
-//	public static LodDirection getRandom(Random p_239631_0_)
-//	{
-//		return Util.getRandom(VALUES, p_239631_0_);
-//	}
-
-//	public static LodDirection getNearest(double p_210769_0_, double p_210769_2_, double p_210769_4_)
-//	{
-//		return getNearest((float) p_210769_0_, (float) p_210769_2_, (float) p_210769_4_);
-//	}
-
-//	public static LodDirection getNearest(float p_176737_0_, float p_176737_1_, float p_176737_2_)
-//	{
-//		LodDirection lodDirection = NORTH;
-//		float f = Float.MIN_VALUE;
-//		
-//		for (LodDirection direction1 : VALUES)
-//		{
-//			float f1 = p_176737_0_ * direction1.normal.x + p_176737_1_ * direction1.normal.y + p_176737_2_ * direction1.normal.z;
-//			if (f1 > f)
-//			{
-//				f = f1;
-//				lodDirection = direction1;
-//			}
-//		}
-//		
-//		return lodDirection;
-//	}
 	
-	public static EDhDirection get(EDhDirection.AxisDirection p_181076_0_, EDhDirection.Axis p_181076_1_)
+	//================//
-	{
+	// helper classes //
-		for (EDhDirection lodDirection : VALUES)
+	//================//
-		{
-			if (lodDirection.getAxisDirection() == p_181076_0_ && lodDirection.getAxis() == p_181076_1_)
-			{
-				return lodDirection;
-			}
-		}
-		
-		throw new IllegalArgumentException("No such direction: " + p_181076_0_ + " " + p_181076_1_);
-	}
 	
-	public Vec3i getNormal()
+	/**
+	 * X <br>
+	 * Y <br>
+	 * Z <br>
+	 */
+	public enum Axis
 	{
-		return this.normal;
+		X("x"),
-	}
+		Y("y"),
-
+		Z("z");
-//	public boolean isFacingAngle(float p_243532_1_)
-//	{
-//		float f = p_243532_1_ * ((float) Math.PI / 180F);
-//		float f1 = -MathHelper.sin(f);
-//		float f2 = MathHelper.cos(f);
-//		return this.normal.getX() * f1 + this.normal.getZ() * f2 > 0.0F;
-//	}
-	
-	public enum Axis implements Predicate<EDhDirection>
-	{
-		X("x")
-				{
-					@Override
-					public int choose(int x, int y, int z)
-					{
-						return x;
-					}
-					
-					@Override
-					public double choose(double x, double y, double z)
-					{
-						return x;
-					}
-				},
-		Y("y")
-				{
-					@Override
-					public int choose(int x, int y, int z)
-					{
-						return y;
-					}
-					
-					@Override
-					public double choose(double x, double y, double z)
-					{
-						return y;
-					}
-				},
-		Z("z")
-				{
-					@Override
-					public int choose(int x, int y, int z)
-					{
-						return z;
-					}
-					
-					@Override
-					public double choose(double x, double y, double z)
-					{
-						return z;
-					}
-				};
 		
-		private static final EDhDirection.Axis[] VALUES = values();
+		public final String name;
 		
-		private static final Map<String, EDhDirection.Axis> BY_NAME = Arrays.stream(VALUES).collect(Collectors.toMap(EDhDirection.Axis::getName, (p_199785_0_) ->
-		{
-			return p_199785_0_;
-		}));
-		private final String name;
 		
-		Axis(String name)
+		//=============//
-		{
+		// constructor //
-			this.name = name;
+		//=============//
-		}
 		
-		public static EDhDirection.Axis byName(String name)
+		Axis(String name) { this.name = name; }
-		{
-			return BY_NAME.get(name.toLowerCase(Locale.ROOT));
-		}
 		
-		public String getName()
-		{
-			return this.name;
-		}
 		
-		public boolean isVertical()
-		{
-			return this == Y;
-		}
 		
-		public boolean isHorizontal()
+		//=========//
-		{
+		// methods //
-			return this == X || this == Z;
+		//=========//
-		}
+		
+		public boolean isVertical() { return this == Y; }
+		public boolean isHorizontal() { return this == X || this == Z; }
 		
 		@Override
-		public String toString()
+		public String toString() { return this.name; }
-		{
-			return this.name;
-		}
-
-//		public static LodDirection.Axis getRandom(Random p_239634_0_)
-//		{
-//			return Util.getRandom(VALUES, p_239634_0_);
-//		}
 		
-		@Override
-		public boolean test(EDhDirection p_test_1_)
-		{
-			return p_test_1_ != null && p_test_1_.getAxis() == this;
-		}
-
-//		public LodDirection.Plane getPlane()
-//		{
-//			switch (this)
-//			{
-//			case X:
-//			case Z:
-//				return LodDirection.Plane.HORIZONTAL;
-//			case Y:
-//				return LodDirection.Plane.VERTICAL;
-//			default:
-//				throw new Error("Someone's been tampering with the universe!");
-//			}
-//		}
-		
-		public abstract int choose(int p_196052_1_, int p_196052_2_, int p_196052_3_);
-		
-		public abstract double choose(double p_196051_1_, double p_196051_3_, double p_196051_5_);
 	}
 	
+	/**
+	 * POSITIVE <br>
+	 * NEGATIVE <br>
+	 */
 	public enum AxisDirection
 	{
 		POSITIVE(1, "Towards positive"),
 		NEGATIVE(-1, "Towards negative");
 		
-		private final int step;
+		public final int step;
-		private final String name;
+		public final String name;
+		
+		
+		
+		//=============//
+		// constructor //
+		//=============//
 		
 		AxisDirection(int newStep, String newName)
 		{
@@ -516,77 +185,20 @@ public enum EDhDirection
 			this.name = newName;
 		}
 		
-		public int getStep()
+		
-		{
+		
-			return this.step;
+		//=========//
-		}
+		// methods //
+		//=========//
+		
+		public EDhDirection.AxisDirection opposite() 
+		{ return (this == POSITIVE) ? NEGATIVE : POSITIVE; }
 		
 		@Override
-		public String toString()
+		public String toString() { return this.name; }
-		{
+		
-			return this.name;
+		
-		}
 		
-		public EDhDirection.AxisDirection opposite()
-		{
-			return this == POSITIVE ? NEGATIVE : POSITIVE;
-		}
-	}
-
-//	public static enum Plane implements Iterable<LodDirection>, Predicate<LodDirection>
-//	{
-//		HORIZONTAL(new LodDirection[] { LodDirection.NORTH, LodDirection.EAST, LodDirection.SOUTH, LodDirection.WEST }, new LodDirection.Axis[] { LodDirection.Axis.X, LodDirection.Axis.Z }),
-//		VERTICAL(new LodDirection[] { LodDirection.UP, LodDirection.DOWN }, new LodDirection.Axis[] { LodDirection.Axis.Y });
-//		
-//		private final LodDirection[] faces;
-//		private final LodDirection.Axis[] axis;
-//		
-//		private Plane(LodDirection[] p_i49393_3_, LodDirection.Axis[] p_i49393_4_)
-//		{
-//			this.faces = p_i49393_3_;
-//			this.axis = p_i49393_4_;
-//		}
-//		
-//		public LodDirection getRandomDirection(Random p_179518_1_)
-//		{
-//			return Util.getRandom(this.faces, p_179518_1_);
-//		}
-//		
-//		public LodDirection.Axis getRandomAxis(Random p_244803_1_)
-//		{
-//			return Util.getRandom(this.axis, p_244803_1_);
-//		}
-//		
-//		@Override
-//		public boolean test(@Nullable LodDirection p_test_1_)
-//		{
-//			return p_test_1_ != null && p_test_1_.getAxis().getPlane() == this;
-//		}
-//		
-//		@Override
-//		public Iterator<LodDirection> iterator()
-//		{
-//			return Iterators.forArray(this.faces);
-//		}
-//		
-//		public Stream<LodDirection> stream()
-//		{
-//			return Arrays.stream(this.faces);
-//		}
-//	}
-	
-	
-	
-	
-	public String getSerializedName()
-	{
-		return this.name;
-	}
-	
-	@Override
-	public String toString()
-	{
-		return this.name;
 	}
 	
 }

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/AbstractDataSourceHandler.java

@@ -1,369 +0,0 @@
-package com.seibel.distanthorizons.core.file;
-
-import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
-import com.seibel.distanthorizons.core.file.structure.ISaveStructure;
-import com.seibel.distanthorizons.core.level.IDhLevel;
-import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhSectionPos;
-import com.seibel.distanthorizons.core.sql.repo.AbstractDhRepo;
-import com.seibel.distanthorizons.core.sql.dto.IBaseDTO;
-import com.seibel.distanthorizons.core.util.LodUtil;
-import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
-import com.seibel.distanthorizons.core.util.threading.PositionalLockProvider;
-import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
-import org.apache.logging.log4j.Logger;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.ReentrantLock;
-
-// TODO is there a reason this is separate from FullDataSourceProviderV2?
-//  We shouldn't need multiple data source handlers
-public abstract class AbstractDataSourceHandler
-		<TDataSource extends IDataSource<TDhLevel>, 
-				TDTO extends IBaseDTO<Long>,
-				TRepo extends AbstractDhRepo<Long, TDTO>,
-				TDhLevel extends IDhLevel>
-		implements AutoCloseable
-{
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
-	private static final Set<String> CORRUPT_DATA_ERRORS_LOGGED = Collections.newSetFromMap(new ConcurrentHashMap<>());
-	
-	
-	/**
-	 * The highest numerical detail level possible. 
-	 * Used when determining which positions to update. 
-	 * 
-	 * @see AbstractDataSourceHandler#MIN_SECTION_DETAIL_LEVEL
-	 */
-	public static final byte TOP_SECTION_DETAIL_LEVEL = DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL + LodUtil.REGION_DETAIL_LEVEL;
-	/** 
-	 * The lowest numerical detail level possible. 
-	 *
-	 * @see AbstractDataSourceHandler#TOP_SECTION_DETAIL_LEVEL
-	 */
-	public static final byte MIN_SECTION_DETAIL_LEVEL = DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL;
-	
-	
-	protected final PositionalLockProvider updateLockProvider = new PositionalLockProvider();
-	/** 
-	 * generally just used for debugging,
-	 * keeps track of which positions are currently locked.
-	 */
-	public final Set<Long> lockedPosSet = ConcurrentHashMap.newKeySet();
-	public final ConcurrentHashMap<Long, AtomicInteger> queuedUpdateCountsByPos = new ConcurrentHashMap<>();
-	
-	
-	protected final ReentrantLock closeLock = new ReentrantLock();
-	protected volatile boolean isShutdown = false;
-	
-	protected final TDhLevel level;
-	protected final File saveDir;
-	
-	public final TRepo repo;
-	
-	public final ArrayList<IDataSourceUpdateFunc<TDataSource>> dateSourceUpdateListeners = new ArrayList<>();
-	
-	
-	
-	//=============//
-	// constructor //
-	//=============//
-	
-	public AbstractDataSourceHandler(TDhLevel level, ISaveStructure saveStructure) { this(level, saveStructure, null); }
-	public AbstractDataSourceHandler(TDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride)
-	{
-		this.level = level;
-		this.saveDir = (saveDirOverride == null) ? saveStructure.getSaveFolder(level.getLevelWrapper()) : saveDirOverride;
-		this.repo = this.createRepo();
-	}
-	
-	
-	
-	
-	//==================//
-	// abstract methods //
-	//==================//
-	
-	/** When this is called the parent folders should be created */
-	protected abstract TRepo createRepo();
-	
-	protected abstract TDataSource createDataSourceFromDto(TDTO dto) throws InterruptedException, IOException, DataCorruptedException;
-	protected abstract TDTO createDtoFromDataSource(TDataSource dataSource);
-	
-	protected abstract TDataSource makeEmptyDataSource(long pos);
-	
-	
-	
-	//==============//
-	// data reading //
-	//==============//
-	
-	/**
-	 * Returns the {@link TDataSource} for the given section position. <Br>
-	 * The returned data source may be null if repo is in the process of shutting down. <Br> <Br>
-	 *
-	 * This call is concurrent. I.e. it supports being called by multiple threads at the same time.
-	 */
-	public CompletableFuture<TDataSource> getAsync(long pos)
-	{
-		AbstractExecutorService executor = ThreadPoolUtil.getFileHandlerExecutor();
-		if (executor == null || executor.isTerminated())
-		{
-			return CompletableFuture.completedFuture(null);
-		}
-		
-		
-		try
-		{
-			return CompletableFuture.supplyAsync(() -> this.get(pos), executor);
-		}
-		catch (RejectedExecutionException ignore) 
-		{
-			// the thread pool was probably shut down because it's size is being changed, just wait a sec and it should be back
-			return CompletableFuture.completedFuture(null);
-		}
-	}
-	/**
-	 * Should only be used in internal file handler methods where we are already running on a file handler thread.
-	 * Can return null if the repo is in the process of being shut down
-	 * @see AbstractDataSourceHandler#getAsync(long)
-	 */
-	@Nullable
-	public TDataSource get(long pos)
-	{
-		TDataSource dataSource = null;
-		try(TDTO dto = this.repo.getByKey(pos))
-		{
-			if (dto != null)
-			{
-				try
-				{
-					// load from database
-					dataSource = this.createDataSourceFromDto(dto);
-				}
-				catch (DataCorruptedException e)
-				{
-					// there's a rare issue where the exception doesn't
-					// have a message, which can cause problems
-					String message = (e.getMessage() == null) ? e.getMessage() : "No Error message for exception ["+e.getClass().getSimpleName()+"]";
-					
-					// Only log each message type once.
-					// This is done to prevent logging "No compression mode with the value [2]" 10,000 times 
-					// if the user is migrating from a nightly build and used ZStd.
-					if (CORRUPT_DATA_ERRORS_LOGGED.add(message))
-					{
-						LOGGER.warn("Corrupted data found at pos [" + DhSectionPos.toString(pos) + "]. Data at position will be deleted so it can be re-generated to prevent issues. Future errors with this same message won't be logged. Error: [" + message + "].", e);
-					}
-					
-					this.repo.deleteWithKey(pos);
-				}
-			}
-			else
-			{
-				dataSource = this.makeEmptyDataSource(pos);
-			}
-		}
-		catch (InterruptedException ignore) { }
-		catch (IOException e)
-		{
-			LOGGER.warn("File read Error for pos ["+ DhSectionPos.toString(pos)+"], error: "+e.getMessage(), e);
-		}
-		
-		return dataSource;
-	}
-	
-	
-	
-	//===============//
-	// data updating //
-	//===============//
-	
-	/** 
-	 * Can be used if the same thread is already handling IO and/or LOD generation.
-	 * Otherwise the async version {@link AbstractDataSourceHandler#updateDataSourceAsync(FullDataSourceV2)} may be a better choice.
-	 */
-	public void updateDataSource(@NotNull FullDataSourceV2 inputDataSource)
-	{ this.updateDataSourceAtPos(inputDataSource.getPos(), inputDataSource, true); }
-	
-	/**
-	 * Can be used if you don't want to lock the current thread
-	 * Otherwise the sync version {@link AbstractDataSourceHandler#updateDataSource(FullDataSourceV2)} may be a better choice.
-	 */
-	public CompletableFuture<Void> updateDataSourceAsync(@NotNull FullDataSourceV2 inputDataSource)
-	{
-		AbstractExecutorService executor = ThreadPoolUtil.getChunkToLodBuilderExecutor();
-		if (executor == null || executor.isTerminated())
-		{
-			return CompletableFuture.completedFuture(null);
-		}
-		
-		
-		try
-		{
-			this.markUpdateStart(inputDataSource.getPos());
-			return CompletableFuture.runAsync(() ->
-			{
-				try
-				{
-					this.updateDataSourceAtPos(inputDataSource.getPos(), inputDataSource, true);
-				}
-				catch (Exception e)
-				{
-					LOGGER.error("Unexpected error in async data source update at pos: ["+DhSectionPos.toString(inputDataSource.getPos())+"], error: ["+e.getMessage()+"].", e);
-				}
-				finally
-				{
-					this.markUpdateEnd(inputDataSource.getPos());
-				}
-			}, executor);
-		}
-		catch (RejectedExecutionException ignore)
-		{
-			// can happen if the executor was shutdown while this task was queued
-			this.markUpdateEnd(inputDataSource.getPos());
-			return CompletableFuture.completedFuture(null);
-		}
-	}
-	
-	/** 
-	 * After this method returns the inputData will be written to file.
-	 *
-	 * @param updatePos the position to update
-	 */
-	protected void updateDataSourceAtPos(long updatePos, @NotNull FullDataSourceV2 inputData, boolean lockOnUpdatePos)
-	{
-		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);
-			}
-			
-			
-			// get or create the data source
-			try (TDataSource recipientDataSource = this.get(updatePos))
-			{
-				if (recipientDataSource != null)
-				{
-					boolean dataModified = recipientDataSource.update(inputData, this.level);
-					if (dataModified)
-					{
-						// save the updated data to the database
-						try (TDTO dto = this.createDtoFromDataSource(recipientDataSource))
-						{
-							this.repo.save(dto);
-						}
-						
-						
-						for (IDataSourceUpdateFunc<TDataSource> listener : this.dateSourceUpdateListeners)
-						{
-							if (listener != null)
-							{
-								listener.OnDataSourceUpdated(recipientDataSource);
-							}
-						}
-					}
-				}
-			}
-		}
-		catch (Exception e)
-		{
-			LOGGER.error("Error updating pos ["+DhSectionPos.toString(updatePos)+"], error: "+e.getMessage(), e);
-		}
-		finally
-		{
-			if (methodLocked)
-			{
-				updateLock.unlock();
-				this.lockedPosSet.remove(updatePos);
-			}
-		}
-	}
-	
-	
-	
-	//================//
-	// helper methods //
-	//================//
-	
-	/** used for debugging to track which positions are queued for updating */
-	private void markUpdateStart(long dataSourcePos)
-	{
-		this.queuedUpdateCountsByPos.compute(dataSourcePos, (pos, atomicCount) ->
-		{
-			if (atomicCount == null)
-			{
-				atomicCount = new AtomicInteger(0);
-			}
-			atomicCount.incrementAndGet();
-			return atomicCount;
-		});
-	}
-	/** used for debugging to track which positions are queued for updating */
-	private void markUpdateEnd(long dataSourcePos)
-	{
-		this.queuedUpdateCountsByPos.compute(dataSourcePos, (pos, atomicCount) ->
-		{
-			if (atomicCount != null && atomicCount.decrementAndGet() <= 0)
-			{
-				atomicCount = null;
-			}
-			return atomicCount;
-		});
-	}
-	
-	
-	
-	//=========//
-	// cleanup //
-	//=========//
-	
-	@Override
-	public void close()
-	{
-		try
-		{
-			this.closeLock.lock();
-			this.isShutdown = true;
-			
-			// wait a moment so any queued saves can finish queuing, 
-			// otherwise we might not see everything that needs saving and attempt to use a closed repo
-			Thread.sleep(200);
-			
-			LOGGER.info("Closing [" + this.getClass().getSimpleName() + "] for level: [" + this.level + "].");
-			
-			this.repo.close();
-		}
-		catch (InterruptedException ignore) { }
-		finally
-		{
-			this.closeLock.unlock();
-		}
-	}
-	
-	
-	
-	//================//
-	// helper classes //
-	//================//
-	
-	@FunctionalInterface
-	public interface IDataSourceUpdateFunc<TDataSource>
-	{
-		void OnDataSourceUpdated(TDataSource updatedFullDataSource);
-	}
-	
-}

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

@@ -1,36 +0,0 @@
-package com.seibel.distanthorizons.core.file;
-
-import com.seibel.distanthorizons.api.enums.EDhApiDetailLevel;
-import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
-import com.seibel.distanthorizons.core.level.IDhLevel;
-import com.seibel.distanthorizons.core.sql.dto.IBaseDTO;
-
-/**
- * Base for all data sources. <br><br>
- * 
- * AutoCloseable Can be implemented to allow for disposing of pooled data sources. <br><br>
- * 
- * @param <TDhLevel> there are times when we need specifically a client level vs a more generic level
- */
-public interface IDataSource<TDhLevel extends IDhLevel> extends IBaseDTO<Long>, AutoCloseable
-{
-	long getPos();
-	
-	/** @return true if the data was changed */
-	boolean update(FullDataSourceV2 chunkData, TDhLevel level);
-	
-	
-	
-	//===========//
-	// meta data //
-	//===========//
-	
-	/** 
-	 * Returns the detail level of the data contained by this data source. 
-	 * IE: 0 for block, 1 for 2x2 blocks, etc.
-	 * 
-	 * @see EDhApiDetailLevel
-	 */
-	byte getDataDetailLevel();
-	
-}

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

@@ -5,7 +5,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.util.KeyedLockContainer;
 import com.seibel.distanthorizons.core.util.ThreadUtil;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.NotNull;
 
 import java.lang.ref.WeakReference;
@@ -21,7 +21,7 @@ import java.util.concurrent.locks.ReentrantLock;
  */
 public class DelayedFullDataSourceSaveCache implements AutoCloseable
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	/** 
 	 * a cache won't automatically clean itself unless we trigger it's clean method
@@ -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.update(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/FullDataSourceProviderV2.java

@@ -1,813 +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.file.fullDatafile;
-
-import com.seibel.distanthorizons.api.enums.config.EDhApiDataCompressionMode;
-import com.seibel.distanthorizons.core.api.internal.ClientApi;
-import com.seibel.distanthorizons.core.config.Config;
-import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV1;
-import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
-import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
-import com.seibel.distanthorizons.core.file.structure.ISaveStructure;
-import com.seibel.distanthorizons.core.file.AbstractDataSourceHandler;
-import com.seibel.distanthorizons.core.generation.tasks.WorldGenResult;
-import com.seibel.distanthorizons.core.level.IDhLevel;
-import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.logging.f3.F3Screen;
-import com.seibel.distanthorizons.core.pos.DhSectionPos;
-import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
-import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
-import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
-import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV2DTO;
-import com.seibel.distanthorizons.core.sql.repo.AbstractDhRepo;
-import com.seibel.distanthorizons.core.sql.repo.FullDataSourceV2Repo;
-import com.seibel.distanthorizons.core.util.ThreadUtil;
-import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
-import com.seibel.distanthorizons.core.util.threading.PriorityTaskPicker;
-import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
-import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
-import it.unimi.dsi.fastutil.longs.LongArrayList;
-import org.apache.logging.log4j.Logger;
-import org.jetbrains.annotations.Nullable;
-
-import java.awt.*;
-import java.io.File;
-import java.io.IOException;
-import java.sql.SQLException;
-import java.text.NumberFormat;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- * Handles reading/writing {@link FullDataSourceV2} 
- * to and from the database.
- */
-public class FullDataSourceProviderV2 
-		extends AbstractDataSourceHandler<FullDataSourceV2, FullDataSourceV2DTO, FullDataSourceV2Repo, IDhLevel> 
-		implements IDebugRenderable
-{
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
-	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
-	
-	protected static final int NUMBER_OF_PARENT_UPDATE_TASKS_PER_THREAD = 5;
-	/** how many parent update tasks can be in the queue at once */
-	protected static int getMaxUpdateTaskCount() { return NUMBER_OF_PARENT_UPDATE_TASKS_PER_THREAD* Config.Common.MultiThreading.numberOfThreads.get(); } 
-	
-	/** indicates how long the update queue thread should wait between queuing ticks */
-	protected static final int UPDATE_QUEUE_THREAD_DELAY_IN_MS = 250;
-	
-	/** how many data sources should be pulled down for migration at once */
-	private static final int MIGRATION_BATCH_COUNT = NUMBER_OF_PARENT_UPDATE_TASKS_PER_THREAD;
-	/** 
-	 * 5 minutes <br>
-	 * This should be much longer than any update should take. This is just
-	 * to make sure the thread doesn't get stuck.
-	 */
-	private static final int MIGRATION_MAX_UPDATE_TIMEOUT_IN_MS = 5 * 60 * 1_000;
-	
-	
-	
-	/**
-	 * Interrupting the migration thread pool doesn't work well and may corrupt the database
-	 * vs gracefully shutting down the thread ourselves. 
-	 */
-	protected final AtomicBoolean migrationThreadRunning = new AtomicBoolean(true);
-	protected final FullDataSourceProviderV1<IDhLevel> legacyFileHandler;
-	
-	protected boolean migrationStartMessageQueued = false;
-	
-	protected long legacyDeletionCount = -1;
-	protected long migrationCount = -1;
-	protected boolean migrationStoppedWithError = false;
-	
-	/** 
-	 * Tracks which positions are currently being updated
-	 * to prevent duplicate concurrent updates.
-	 */
-	public final Set<Long> updatingPosSet = ConcurrentHashMap.newKeySet();
-	
-	// TODO only run thread if modifications happened recently
-	/** 
-	 * This isn't in {@link AbstractDataSourceHandler} since we only want to update
-	 * the newest version of the full data, so if we have providers for either
-	 * render data or old full data, we don't want to update them. <br><br>
-	 * 
-	 * Will be null on the dedicated server since updates don't need to be propagated,
-	 * only the highest detail level is needed.
-	 */
-	@Nullable
-	private final ThreadPoolExecutor updateQueueProcessor;
-	
-	
-	
-	//=============//
-	// constructor //
-	//=============//
-	
-	public FullDataSourceProviderV2(IDhLevel level, ISaveStructure saveStructure) { this(level, saveStructure, null); }
-	public FullDataSourceProviderV2(IDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride) 
-	{
-		super(level, saveStructure, saveDirOverride);
-		this.legacyFileHandler = new FullDataSourceProviderV1<>(level, saveStructure, saveDirOverride);
-		
-		DebugRenderer.register(this, Config.Client.Advanced.Debugging.DebugWireframe.showFullDataUpdateStatus);
-		
-		String levelId = level.getLevelWrapper().getDhIdentifier();
-		
-		// start migrating any legacy data sources present in the background
-		ThreadPoolExecutor executor = ThreadPoolUtil.getFullDataMigrationExecutor();
-		if (executor != null)
-		{
-			executor.execute(this::convertLegacyDataSources);
-		}
-		else
-		{
-			// shouldn't happen, but just in case
-			LOGGER.error("Unable to start migration for level: ["+levelId+"] due to missing executor.");
-		}
-		
-		// update propagation doesn't need to be run on the server since only the highest detail level is needed
-		this.updateQueueProcessor = ThreadUtil.makeSingleThreadPool("Parent Update Queue [" + levelId + "]");
-		this.updateQueueProcessor.execute(this::runUpdateQueue);
-	}
-	
-	
-	
-	//====================//
-	// Abstract overrides //
-	//====================//
-	
-	@Override
-	protected 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);
-		}
-	}
-	
-	@Override 
-	protected FullDataSourceV2DTO createDtoFromDataSource(FullDataSourceV2 dataSource)
-	{
-		try
-		{
-			// when creating new data use the compressor currently selected in the config
-			EDhApiDataCompressionMode compressionModeEnum = Config.Common.LodBuilding.dataCompression.get();
-			return FullDataSourceV2DTO.CreateFromDataSource(dataSource, compressionModeEnum);
-		}
-		catch (IOException e)
-		{
-			LOGGER.warn("Unable to create DTO, error: "+e.getMessage(), e);
-			return null;
-		}
-	}
-	
-	@Override
-	protected FullDataSourceV2 createDataSourceFromDto(FullDataSourceV2DTO dto) throws InterruptedException, IOException, DataCorruptedException
-	{ return dto.createDataSource(this.level.getLevelWrapper()); }
-	
-	@Override
-	protected FullDataSourceV2 makeEmptyDataSource(long pos) 
-	{ return FullDataSourceV2.createEmpty(pos); }
-	
-	
-	
-	//================//
-	// parent updates //
-	//================//
-	
-	private void runUpdateQueue()
-	{
-		while (!Thread.interrupted())
-		{
-			try
-			{
-				Thread.sleep(UPDATE_QUEUE_THREAD_DELAY_IN_MS);
-				
-				PriorityTaskPicker.Executor executor = ThreadPoolUtil.getUpdatePropagatorExecutor();
-				if (executor == null || executor.isTerminated())
-				{
-					continue;
-				}
-				
-				// TODO it might be worth skipping this logic if no parent updates happened
-				
-				// update positions closest to the player (if not on a server)
-				// to make world gen appear faster
-				DhBlockPos targetBlockPos = DhBlockPos.ZERO;
-				if (MC_CLIENT != null && MC_CLIENT.playerExists())
-				{
-					targetBlockPos = MC_CLIENT.getPlayerBlockPos(); 
-				}
-				
-				this.runParentUpdates(executor, targetBlockPos);
-				
-				if (Config.Common.LodBuilding.Experimental.upsampleLowerDetailLodsToFillHoles.get())
-				{
-					this.runChildUpdates(executor, targetBlockPos);
-				}
-				
-			}
-			catch (InterruptedException ignored)
-			{
-				Thread.currentThread().interrupt();
-			}
-			catch (Exception e)
-			{
-				LOGGER.error("Unexpected error in the parent update queue thread. Error: " + e.getMessage(), e);
-			}
-		}
-		
-		LOGGER.info("Update thread ["+Thread.currentThread().getName()+"] terminated.");
-	}
-	/** will always apply updates */
-	private void runParentUpdates(PriorityTaskPicker.Executor executor, DhBlockPos targetBlockPos)
-	{
-		int maxUpdateTaskCount = getMaxUpdateTaskCount();
-		
-		// queue parent updates
-		if (executor.getQueueSize() < maxUpdateTaskCount
-			&& this.updatingPosSet.size() < maxUpdateTaskCount)
-		{
-			// get the positions that need to be applied to their parents
-			LongArrayList parentUpdatePosList = this.repo.getPositionsToUpdate(targetBlockPos.getX(), targetBlockPos.getZ(), maxUpdateTaskCount);
-			
-			// combine updates together based on their parent
-			HashMap<Long, HashSet<Long>> updatePosByParentPos = new HashMap<>();
-			for (Long pos : parentUpdatePosList)
-			{
-				updatePosByParentPos.compute(DhSectionPos.getParentPos(pos), (parentPos, updatePosSet) ->
-				{
-					if (updatePosSet == null)
-					{
-						updatePosSet = new HashSet<>();
-					}
-					updatePosSet.add(pos);
-					return updatePosSet;
-				});
-			}
-			
-			// queue the updates
-			for (Long parentUpdatePos : updatePosByParentPos.keySet())
-			{
-				// stop if there are already a bunch of updates queued
-				if (this.updatingPosSet.size() > maxUpdateTaskCount
-					|| executor.getQueueSize() > maxUpdateTaskCount
-					|| !this.updatingPosSet.add(parentUpdatePos))
-				{
-					break;
-				}
-				
-				try
-				{
-					executor.execute(() ->
-					{
-						ReentrantLock parentWriteLock = this.updateLockProvider.getLock(parentUpdatePos);
-						boolean parentLocked = false;
-						try
-						{
-							//LOGGER.info("updating parent: "+parentUpdatePos);
-							
-							// Locking the parent before the children should prevent deadlocks.
-							// TryLock is used instead of lock so this thread can handle a different update.
-							if (parentWriteLock.tryLock())
-							{
-								parentLocked = true;
-								this.lockedPosSet.add(parentUpdatePos);
-								
-								try (FullDataSourceV2 parentDataSource = this.get(parentUpdatePos))
-								{
-									// will return null if the file handler is shutting down
-									if (parentDataSource != null)
-									{
-										// apply each child pos to the parent
-										for (Long childPos : updatePosByParentPos.get(parentUpdatePos))
-										{
-											ReentrantLock childReadLock = this.updateLockProvider.getLock(childPos);
-											try
-											{
-												childReadLock.lock();
-												this.lockedPosSet.add(childPos);
-												
-												try (FullDataSourceV2 childDataSource = this.get(childPos))
-												{
-													// can return null when the file handler is being shut down
-													if (childDataSource != null)
-													{
-														parentDataSource.update(childDataSource);
-													}
-												}
-											}
-											catch (Exception e)
-											{
-												LOGGER.error("Unexpected in parent update propagation for parent pos: ["+DhSectionPos.toString(parentUpdatePos)+"], child pos: [" + DhSectionPos.toString(parentUpdatePos) + "], Error: [" + e.getMessage() + "].", e);
-											}
-											finally
-											{
-												childReadLock.unlock();
-												this.lockedPosSet.remove(childPos);
-											}
-										}
-										
-										
-										if (DhSectionPos.getDetailLevel(parentUpdatePos) < TOP_SECTION_DETAIL_LEVEL)
-										{
-											parentDataSource.applyToParent = true;
-										}
-										
-										this.updateDataSourceAtPos(parentUpdatePos, parentDataSource, false);
-										for (Long childPos : updatePosByParentPos.get(parentUpdatePos))
-										{
-											this.repo.setApplyToParent(childPos, false);
-										}
-									}
-								}
-							}
-						}
-						finally
-						{
-							if (parentLocked)
-							{
-								parentWriteLock.unlock();
-								this.lockedPosSet.remove(parentUpdatePos);
-							}
-							
-							this.updatingPosSet.remove(parentUpdatePos);
-						}
-					});
-				}
-				catch (RejectedExecutionException ignore)
-				{ /* the executor was shut down, it should be back up shortly and able to accept new jobs */ }
-				catch (Exception e)
-				{
-					this.updatingPosSet.remove(parentUpdatePos);
-					throw e;
-				}
-			}
-		}
-	}
-	/** stops if it finds any LOD data */
-	private void runChildUpdates(PriorityTaskPicker.Executor executor, DhBlockPos targetBlockPos)
-	{
-		int maxUpdateTaskCount = getMaxUpdateTaskCount();
-		
-		// queue child updates
-		if (executor.getQueueSize() < maxUpdateTaskCount
-			&& this.updatingPosSet.size() < maxUpdateTaskCount)
-		{
-			// get the positions that need to be applied to their children
-			LongArrayList childUpdatePosList = this.repo.getChildPositionsToUpdate(targetBlockPos.getX(), targetBlockPos.getZ(), maxUpdateTaskCount);
-			
-			// queue the updates
-			for (long parentUpdatePos : childUpdatePosList)
-			{
-				// stop if there are already a bunch of updates queued
- 				if (this.updatingPosSet.size() > maxUpdateTaskCount
-					    || executor.getQueueSize() > maxUpdateTaskCount)
-				{
-					break;
-				}
-				
-				// skip already updating positions
-				if (!this.updatingPosSet.add(parentUpdatePos))
-				{
-					continue;
-				}
-				
-				try
-				{
-					executor.execute(() ->
-					{
-						ReentrantLock parentReadLock = this.updateLockProvider.getLock(parentUpdatePos);
-						boolean parentLocked = false;
-						try
-						{
-							//LOGGER.info("updating parent: "+parentUpdatePos);
-							
-							// Locking the parent before the children should prevent deadlocks.
-							// TryLock is used instead of lock so this thread can handle a different update.
-							if (parentReadLock.tryLock())
-							{
-								parentLocked = true;
-								this.lockedPosSet.add(parentUpdatePos);
-								
-								try (FullDataSourceV2 parentDataSource = this.get(parentUpdatePos))
-								{
-									// will return null if the file handler is shutting down
-									if (parentDataSource != null)
-									{
-										// apply parent to each child
-										for (int i = 0; i < 4; i++)
-										{
-											long childPos = DhSectionPos.getChildByIndex(parentUpdatePos, i);
-											
-											ReentrantLock childWriteLock = this.updateLockProvider.getLock(childPos);
-											try
-											{
-												childWriteLock.lock();
-												this.lockedPosSet.add(childPos);
-												
-												try (FullDataSourceV2 childDataSource = this.get(childPos))
-												{
-													// will return null if the file handler is shutting down
-													if (childDataSource != null)
-													{
-														childDataSource.update(parentDataSource);
-														
-														// don't propagate child updates past the bottom of the tree
-														if (DhSectionPos.getDetailLevel(childPos) != DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL)
-														{
-															childDataSource.applyToChildren = true;
-														}
-														
-														this.updateDataSourceAtPos(childPos, childDataSource, false);
-													}
-												}
-											}
-											catch (Exception e)
-											{
-												LOGGER.error("Unexpected in child update propagation for parent pos: ["+DhSectionPos.toString(parentUpdatePos)+"], child pos: [" + DhSectionPos.toString(parentUpdatePos) + "], Error: [" + e.getMessage() + "].", e);
-											}
-											finally
-											{
-												childWriteLock.unlock();
-												this.lockedPosSet.remove(childPos);
-											}
-										}
-										
-										this.repo.setApplyToChild(parentUpdatePos, false);
-									}
-								}
-							}
-						}
-						finally
-						{
-							if (parentLocked)
-							{
-								parentReadLock.unlock();
-								this.lockedPosSet.remove(parentUpdatePos);
-							}
-							
-							this.updatingPosSet.remove(parentUpdatePos);
-						}
-					});
-				}
-				catch (RejectedExecutionException ignore)
-				{ /* the executor was shut down, it should be back up shortly and able to accept new jobs */ }
-				catch (Exception e)
-				{
-					this.updatingPosSet.remove(parentUpdatePos);
-					throw e;
-				}
-			}
-		}
-	}
-	
-	
-	
-	//=======================//
-	// data source migration //
-	//=======================//
-	
-	private void convertLegacyDataSources()
-	{
-		try
-		{
-			String levelId = this.level.getLevelWrapper().getDhIdentifier();
-			LOGGER.info("Attempting to migrate data sources for: [" + levelId + "]-[" + this.saveDir + "]...");
-			this.migrationThreadRunning.set(true);
-			
-			
-			
-			//============================//
-			// delete unused data sources //
-			//============================//
-			
-			// this could be done all at once via SQL, 
-			// but doing it in chunks prevents locking the database for long periods of time 
-			long unusedCount = 0;
-			long totalDeleteCount = this.legacyFileHandler.repo.getUnusedDataSourceCount();
-			if (totalDeleteCount != 0)
-			{
-				// this should only be shown once per session but should be shown during 
-				// either when the deletion or migration phases start
-				this.showMigrationStartMessage();
-				
-				
-				LOGGER.info("deleting [" + levelId + "] - [" + totalDeleteCount + "] unused data sources...");
-				this.legacyDeletionCount = totalDeleteCount;
-				
-				ArrayList<String> unusedDataPosList = this.legacyFileHandler.repo.getUnusedDataSourcePositionStringList(50);
-				while (unusedDataPosList.size() != 0)
-				{
-					unusedCount += unusedDataPosList.size();
-					this.legacyDeletionCount -= unusedDataPosList.size();
-					
-					
-					long startTime = System.currentTimeMillis();
-					
-					// delete batch and get next batch 
-					this.legacyFileHandler.repo.deleteUnusedLegacyData(unusedDataPosList);
-					unusedDataPosList = this.legacyFileHandler.repo.getUnusedDataSourcePositionStringList(50);
-					
-					long endStart = System.currentTimeMillis();
-					long deleteTime = endStart - startTime;
-					LOGGER.info("Deleting [" + levelId + "] - [" + unusedCount + "/" + totalDeleteCount + "] in [" + deleteTime + "]ms ...");
-					
-					
-					// a slight delay is added to prevent accidentally locking the database when deleting a lot of rows
-					// (that shouldn't be the case since we're using WAL journaling, but just in case)
-					try
-					{
-						// use the delete time so we don't make powerful computers wait super long
-						// and weak computers wait no time at all
-						Thread.sleep(deleteTime / 2);
-					}
-					catch (InterruptedException ignore)
-					{
-					}
-				}
-				LOGGER.info("Done deleting [" + levelId + "] - [" + totalDeleteCount + "] unused data sources.");
-				
-			}
-			
-			
-			
-			//===========//
-			// migration //
-			//===========//
-			
-			long totalMigrationCount = this.legacyFileHandler.getDataSourceMigrationCount();
-			this.migrationCount = totalMigrationCount;
-			LOGGER.info("Found [" + totalMigrationCount + "] data sources that need migration.");
-			
-			ArrayList<FullDataSourceV1> legacyDataSourceList = this.legacyFileHandler.getDataSourcesToMigrate(MIGRATION_BATCH_COUNT);
-			if (!legacyDataSourceList.isEmpty())
-			{
-				this.showMigrationStartMessage();
-				
-				try
-				{
-					// keep going until every data source has been migrated
-					int progressCount = 0;
-					while (!legacyDataSourceList.isEmpty() && this.migrationThreadRunning.get())
-					{
-						NumberFormat numFormat = F3Screen.NUMBER_FORMAT;
-						LOGGER.info("Migrating [" + levelId + "] - [" + numFormat.format(progressCount) + "/" + numFormat.format(totalMigrationCount) + "]...");
-						
-						ArrayList<CompletableFuture<Void>> updateFutureList = new ArrayList<>();
-						for (int i = 0; i < legacyDataSourceList.size() && this.migrationThreadRunning.get(); i++)
-						{
-							FullDataSourceV1 legacyDataSource = legacyDataSourceList.get(i);
-							
-							try
-							{
-								// convert the legacy data source to the new format,
-								// this is a relatively cheap operation
-								FullDataSourceV2 newDataSource = FullDataSourceV2.createFromLegacyDataSourceV1(legacyDataSource);
-								newDataSource.applyToParent = true;
-								
-								// the actual update process can be moderately expensive due to having to update
-								// the render data along with the full data, so running it async on the update threads gains us a good bit of speed
-								CompletableFuture<Void> future = this.updateDataSourceAsync(newDataSource);
-								updateFutureList.add(future);
-								future.thenRun(() ->
-								{
-									// after the update finishes the legacy data source can be safely deleted
-									this.legacyFileHandler.repo.deleteWithKey(legacyDataSource.getPos());
-									newDataSource.close();
-								});
-							}
-							catch (Exception e)
-							{
-								Long migrationPos = legacyDataSource.getPos();
-								LOGGER.warn("Unexpected issue migrating data source at pos [" + DhSectionPos.toString(migrationPos) + "]. Error: " + e.getMessage(), e);
-								this.legacyFileHandler.markMigrationFailed(migrationPos);
-							}
-						}
-						
-						
-						try
-						{
-							// wait for each thread to finish updating
-							CompletableFuture<Void> combinedFutures = CompletableFuture.allOf(updateFutureList.toArray(new CompletableFuture[0]));
-							combinedFutures.get(MIGRATION_MAX_UPDATE_TIMEOUT_IN_MS, TimeUnit.MILLISECONDS);
-						}
-						catch (InterruptedException | TimeoutException e)
-						{
-							LOGGER.warn("Migration update timed out after [" + MIGRATION_MAX_UPDATE_TIMEOUT_IN_MS + "] milliseconds. Migration will re-try the same positions again in a moment.", e);
-						}
-						catch (ExecutionException e)
-						{
-							LOGGER.warn("Migration update failed. Migration will re-try the same positions again. Error:" + e.getMessage(), e);
-						}
-						
-						legacyDataSourceList = this.legacyFileHandler.getDataSourcesToMigrate(MIGRATION_BATCH_COUNT);
-						
-						progressCount += legacyDataSourceList.size();
-						this.migrationCount -= legacyDataSourceList.size();
-					}
-				}
-				catch (Exception e)
-				{
-					LOGGER.info("migration stopped due to error for: [" + levelId + "]-[" + this.saveDir + "], error: [" + e.getMessage() + "].", e);
-					this.showMigrationEndMessage(false);
-					this.migrationStoppedWithError = true;
-				}
-				finally
-				{
-					if (this.migrationThreadRunning.get())
-					{
-						LOGGER.info("migration complete for: [" + levelId + "]-[" + this.saveDir + "].");
-						this.showMigrationEndMessage(true);
-						this.migrationCount = 0;
-					}
-					else
-					{
-						LOGGER.info("migration stopped for: [" + levelId + "]-[" + this.saveDir + "].");
-						this.showMigrationEndMessage(false);
-						this.migrationStoppedWithError = true;
-					}
-				}
-			}
-			else
-			{
-				LOGGER.info("No migration necessary.");
-			}
-		}
-		finally
-		{
-			this.migrationThreadRunning.set(false);
-		}
-	}
-	
-	public long getLegacyDeletionCount() { return this.legacyDeletionCount; }
-	public long getTotalMigrationCount() { return this.migrationCount; }
-	public boolean getMigrationStoppedWithError() { return this.migrationStoppedWithError; }
-	
-	
-	private void showMigrationStartMessage()
-	{
-		if (this.migrationStartMessageQueued)
-		{
-			return;
-		}
-		this.migrationStartMessageQueued = true;
-		
-		String levelId = this.level.getLevelWrapper().getDhIdentifier();
-		ClientApi.INSTANCE.showChatMessageNextFrame(
-				"Old Distant Horizons data is being migrated for ["+levelId+"]. \n" +
-				"While migrating LODs may load slowly \n" +
-				"and DH world gen will be disabled. \n" +
-				"You can see migration progress in the F3 menu."
-			);
-	}
-	
-	private void showMigrationEndMessage(boolean success)
-	{
-		String levelId = this.level.getLevelWrapper().getDhIdentifier();
-		
-		if (success)
-		{
-			ClientApi.INSTANCE.showChatMessageNextFrame("Distant Horizons data migration for ["+levelId+"] completed.");
-		}
-		else
-		{
-			ClientApi.INSTANCE.showChatMessageNextFrame(
-					"Distant Horizons data migration for ["+levelId+"] stopped. \n" +
-					"Some data may not have been migrated."
-				);
-		}
-	}
-	
-	
-	
-	//=======================//
-	// retrieval (world gen) //
-	//=======================//
-	
-	/**
-	 * Returns true if this provider can generate or retrieve
-	 * {@link FullDataSourceV2}'s that aren't currently in the database.
-	 */
-	public boolean canRetrieveMissingDataSources() 
-	{ 
-		// the base handler just handles basic reading/writing
-		// to the database and as such can't retrieve anything else.
-		return false; 
-	}
-	
-	/**
-	 * Returns false if this provider isn't accepting new requests,
-	 * this can be due to having a full queue or some other
-	 * limiting factor. <br><br>
-	 * 
-	 * Note: when overriding make sure to add: <br>
-	 * <code>
-	 * if (!super.canQueueRetrieval()) <br>
-	 * { <br>
-	 *      return false; <br>
-	 * } <br>
-	 * </code>
-	 * to the beginning of your override.
-	 * Otherwise, parent retrieval limits will be ignored.
-	 */
-	public boolean canQueueRetrieval()
-	{
-		// Retrieval shouldn't happen while an unknown number of
-		// legacy data sources are present.
-		// If retrieval was allowed we might run into concurrency issues.
-		return !this.migrationThreadRunning.get();
-	}
-	
-	/** 
-	 * @return null if this provider can't generate any positions and
-	 * an empty array if all positions were generated 
-	 */
-	@Nullable
-	public LongArrayList getPositionsToRetrieve(Long pos) { return null; }
-		
-	/** @return true if the position was queued, false if not */
-	@Nullable
-	public CompletableFuture<WorldGenResult> queuePositionForRetrieval(Long genPos) { return null; }
-	
-	/** does nothing if the given position isn't present in the queue */
-	public void removeRetrievalRequestIf(DhSectionPos.ICancelablePrimitiveLongConsumer removeIf) { }
-	
-	public void clearRetrievalQueue() { }
-	
-	/** Can be used to display how many total retrieval requests might be available. */
-	public void setTotalRetrievalPositionCount(int newCount) { }
-	/** Can be used to display how many total chunk retrieval requests should be available. */
-	public void setEstimatedRemainingRetrievalChunkCount(int newCount) { }
-	
-	public boolean fileExists(long pos) { return this.repo.getDataSizeInBytes(pos) > 0; }
-	
-	
-	
-	//========================//
-	// multiplayer networking //
-	//========================//
-	
-	@Nullable
-	public Long getTimestampForPos(long pos)
-	{ return this.repo.getTimestampForPos(pos); }
-	
-	
-	
-	//===========//
-	// overrides //
-	//===========//
-	
-	@Override
-	public void debugRender(DebugRenderer renderer)
-	{
-		this.lockedPosSet
-				.forEach((pos) -> { renderer.renderBox(new DebugRenderer.Box(pos, -32f, 74f, 0.15f, Color.PINK)); });
-		
-		this.queuedUpdateCountsByPos
-				.forEach((pos, updateCountRef) -> { renderer.renderBox(new DebugRenderer.Box(pos, -32f, 80f + (updateCountRef.get() * 16f), 0.20f, Color.WHITE)); });
-		this.updatingPosSet
-				.forEach((pos) -> { renderer.renderBox(new DebugRenderer.Box(pos, -32f, 80f, 0.20f, Color.MAGENTA)); });
-	}
-	
-	@Override 
-	public void close()
-	{
-		super.close();
-		if (this.updateQueueProcessor != null)
-		{
-			this.updateQueueProcessor.shutdownNow();
-		}
-		
-		this.legacyFileHandler.close();
-		
-		this.migrationThreadRunning.set(false);
-	}
-	
-}

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

@@ -23,28 +23,33 @@ import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiWorldGeneratio
 import com.seibel.distanthorizons.core.api.internal.SharedApi;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+import com.seibel.distanthorizons.core.file.fullDatafile.V2.FullDataSourceProviderV2;
+import com.seibel.distanthorizons.core.file.fullDatafile.V2.FullDataUpdatePropagatorV2;
 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.DataSourceRetrievalResult;
-import com.seibel.distanthorizons.core.generation.tasks.WorldGenResult;
+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;
 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.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;
 import it.unimi.dsi.fastutil.bytes.ByteArrayList;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
-import org.apache.logging.log4j.Logger;
 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;
@@ -54,7 +59,7 @@ import java.util.stream.IntStream;
 
 public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 implements IDebugRenderable
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();;
 	
 	/** 
 	 * Having this number too high causes the system to become overwhelmed by
@@ -64,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);
@@ -78,8 +85,10 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	// constructor //
 	//=============//
 	
-	public GeneratedFullDataSourceProvider(IDhLevel level, ISaveStructure saveStructure) { super(level, saveStructure); }
+	public GeneratedFullDataSourceProvider(IDhLevel level, ISaveStructure saveStructure) throws SQLException, IOException 
-	public GeneratedFullDataSourceProvider(IDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride) { super(level, saveStructure, saveDirOverride); }
+	{ this(level, saveStructure, null); }
+	public GeneratedFullDataSourceProvider(IDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride) throws SQLException, IOException
+	{ super(level, saveStructure, saveDirOverride); }
 	
 	
 	
@@ -108,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 != null)
-			if (!(exception instanceof CancellationException || exception.getCause() instanceof CancellationException))
 			{
-				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);
+			LOGGER.error("Unexpected issue during onWorldGenTaskComplete, error: ["+e.getMessage()+"].", e);
-			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));
 		}
 	}
 	
@@ -176,7 +196,7 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	{
 		boolean oldQueueExists = this.worldGenQueueRef.compareAndSet(null, newWorldGenQueue);
 		LodUtil.assertTrue(oldQueueExists, "previous world gen queue is still here!");
-		LOGGER.info("Set world gen queue for level [" + this.level.getLevelWrapper().getDhIdentifier() + "].");
+		LOGGER.info("Set world gen queue for level [" + this.levelId + "].");
 	}
 	
 	@Override
@@ -193,10 +213,10 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 	}
 	
 	@Override
-	public boolean canQueueRetrieval() { return this.canQueueRetrieval(false); }
+	public boolean canQueueRetrievalNow() { return this.canQueueRetrievalNow(false); }
-	public boolean canQueueRetrieval(boolean pruneWaitingTasksAboveLimit)
+	public boolean canQueueRetrievalNow(boolean pruneWaitingTasksAboveLimit)
 	{
-		if (!super.canQueueRetrieval())
+		if (!super.canQueueRetrievalNow())
 		{
 			return false;
 		}
@@ -212,7 +232,7 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 		
 		PriorityTaskPicker.Executor renderLoadExecutor = ThreadPoolUtil.getRenderLoadingExecutor();
 		if (renderLoadExecutor == null 
-			|| renderLoadExecutor.getQueueSize() >= getMaxUpdateTaskCount() / 2)
+			|| renderLoadExecutor.getQueueSize() >= FullDataUpdatePropagatorV2.getMaxPropagateTaskCount() / 2)
 		{
 			// don't queue additional world gen requests if the render loader handler is overwhelmed,
 			// otherwise LODs may not load in properly
@@ -221,7 +241,7 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 		
 		PriorityTaskPicker.Executor fileHandlerExecutor = ThreadPoolUtil.getFileHandlerExecutor();
 		if (fileHandlerExecutor == null 
-			|| fileHandlerExecutor.getQueueSize() >= getMaxUpdateTaskCount() / 2)
+			|| fileHandlerExecutor.getQueueSize() >= FullDataUpdatePropagatorV2.getMaxPropagateTaskCount() / 2)
 		{
 			// don't queue additional world gen requests if the file handler is overwhelmed,
 			// otherwise LODs may not load in properly
@@ -256,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);
+				AtomicInteger tasksToCancel = new AtomicInteger(availableTaskSlots * -1);
-				worldGenQueue.removeRetrievalRequestIf(x -> tasksToCancel.getAndDecrement() > 0);
+				worldGenQueue.removeRetrievalRequestIf(taskPos -> tasksToCancel.getAndDecrement() > 0);
 			}
 			else
 			{
@@ -274,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)
@@ -282,28 +306,12 @@ public class GeneratedFullDataSourceProvider extends FullDataSourceProviderV2 im
 			return null;
 		}
 		
-		WorldGenTaskTracker genTaskTracker = new WorldGenTaskTracker(genPos);
+		CompletableFuture<DataSourceRetrievalResult> worldGenFuture = worldGenQueue.submitRetrievalTask(genPos, (byte) (DhSectionPos.getDetailLevel(genPos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL));
-		CompletableFuture<WorldGenResult> worldGenFuture = worldGenQueue.submitRetrievalTask(genPos, (byte) (DhSectionPos.getDetailLevel(genPos) - DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL), genTaskTracker);
+		worldGenFuture.whenComplete((r, e) -> this.onWorldGenTaskComplete(genPos, r, e));
-		worldGenFuture.whenComplete((genTaskResult, ex) ->
-		{
-			//LOGGER.info("gen task complete ["+DhSectionPos.toString(genPos)+"]");
-			//this.onWorldGenTaskComplete(genTaskResult, ex);
-		});
 		
 		return worldGenFuture;
 	}
 	
-	@Override
-	protected void updateDataSourceAtPos(long updatePos, @NotNull FullDataSourceV2 inputData, boolean lockOnUpdatePos)
-	{
-		super.updateDataSourceAtPos(updatePos, inputData, lockOnUpdatePos);
-		
-		//if (SharedApi.getEnvironment() != EWorldEnvironment.CLIENT_ONLY)
-		//	LOGGER.info("updated ["+DhSectionPos.toString(updatePos)+"]");
-		
-		this.onWorldGenTaskComplete(WorldGenResult.CreateSuccess(updatePos), null);
-	}
-	
 	@Override
 	public void removeRetrievalRequestIf(DhSectionPos.ICancelablePrimitiveLongConsumer removeIf)
 	{
@@ -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 ->
+			.noneMatch((int intValue) ->
-				{
+			{
-					byte value = columnGenerationSteps.getByte(i);
+				byte value = columnGenerationSteps.getByte(intValue);
-					return value == EDhApiWorldGenerationStep.EMPTY.value
+				return value == EDhApiWorldGenerationStep.EMPTY.value
-							|| value == EDhApiWorldGenerationStep.DOWN_SAMPLED.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,
+			worldGenQueue.lowestDataDetail() + DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL,
-				DhSectionPos.getDetailLevel(pos));
+			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/IDataSourceUpdateListenerFunc.java

@@ -0,0 +1,7 @@
+package com.seibel.distanthorizons.core.file.fullDatafile;
+
+@FunctionalInterface
+public interface IDataSourceUpdateListenerFunc<TDataSource>
+{
+	void OnDataSourceUpdated(TDataSource updatedFullDataSource);
+}

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

@@ -23,25 +23,29 @@ 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 org.apache.logging.log4j.Logger;
+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
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	@Nullable
 	private final SyncOnLoadRequestQueue syncOnLoadRequestQueue;
@@ -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.syncOnLoadRequestQueue.submitRequest(pos, timestamp)
-			{
+				.thenAccept((DataSourceRetrievalResult result) ->
-				this.updateDataSourceAsync(fullDataSource).whenComplete((result, throwable) -> fullDataSource.close());
+				{
-			});
+					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

@@ -1,4 +1,4 @@
-package com.seibel.distanthorizons.core.file.fullDatafile;
+package com.seibel.distanthorizons.core.file.fullDatafile.V1;
 
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV1;
 import com.seibel.distanthorizons.core.file.structure.ISaveStructure;
@@ -12,7 +12,7 @@ import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
 import com.seibel.distanthorizons.core.util.objects.dataStreams.DhDataInputStream;
 import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
@@ -27,7 +27,7 @@ import java.util.concurrent.locks.ReentrantLock;
 public class FullDataSourceProviderV1<TDhLevel extends IDhLevel>
 		implements AutoCloseable
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	protected final ReentrantLock closeLock = new ReentrantLock();
 	protected volatile boolean isShutdown = false;
@@ -43,16 +43,16 @@ public class FullDataSourceProviderV1<TDhLevel extends IDhLevel>
 	// constructor //
 	//=============//
 	
-	public FullDataSourceProviderV1(TDhLevel level, ISaveStructure saveStructure, @Nullable File saveDirOverride)
+	public FullDataSourceProviderV1(TDhLevel level, File saveDir) throws SQLException, IOException
 	{
 		this.level = level;
-		this.saveDir = (saveDirOverride == null) ? saveStructure.getSaveFolder(level.getLevelWrapper()) : saveDirOverride;
+		this.saveDir = saveDir;
 		if (!this.saveDir.exists() && !this.saveDir.mkdirs())
 		{
 			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

@@ -0,0 +1,349 @@
+package com.seibel.distanthorizons.core.file.fullDatafile.V2;
+
+import com.seibel.distanthorizons.core.api.internal.ClientApi;
+import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV1;
+import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+import com.seibel.distanthorizons.core.file.fullDatafile.V1.FullDataSourceProviderV1;
+import com.seibel.distanthorizons.core.level.IDhLevel;
+import com.seibel.distanthorizons.core.logging.DhLogger;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.logging.f3.F3Screen;
+import com.seibel.distanthorizons.core.pos.DhSectionPos;
+import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
+import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
+import com.seibel.distanthorizons.core.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;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class DataMigratorV1 implements IDebugRenderable, AutoCloseable
+{
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
+	
+	/** how many data sources should be pulled down for migration at once */
+	private static final int MIGRATION_BATCH_COUNT = FullDataUpdatePropagatorV2.NUMBER_OF_PARENT_UPDATE_TASKS_PER_THREAD;
+	/**
+	 * 5 minutes <br>
+	 * This should be much longer than any update should take. This is just
+	 * to make sure the thread doesn't get stuck.
+	 */
+	private static final int MIGRATION_MAX_UPDATE_TIMEOUT_IN_MS = 5 * 60 * 1_000;
+	
+	
+	
+	private final FullDataUpdaterV2 dataUpdater;
+	
+	
+	private boolean migrationStartMessageQueued = false;
+	
+	private long legacyDeletionCount = -1;
+	private long migrationCount = -1;
+	private boolean migrationStoppedWithError = false;
+	
+	/**
+	 * Interrupting the migration thread pool doesn't work well and may corrupt the database
+	 * vs gracefully shutting down the thread ourselves. 
+	 */
+	public final AtomicBoolean migrationThreadRunning = new AtomicBoolean(true);
+	private final FullDataSourceProviderV1<IDhLevel> v1DataSourceProvider;
+	
+	private final String levelId;
+	private final File saveDir;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public DataMigratorV1(
+			FullDataUpdaterV2 dataUpdater,
+			IDhLevel level, String levelId, File saveDir
+		) throws SQLException, IOException
+	{
+		this.dataUpdater = dataUpdater;
+		this.saveDir = saveDir;
+		this.v1DataSourceProvider = new FullDataSourceProviderV1<>(level, saveDir);
+		
+		this.levelId = levelId;
+		
+		
+		// start migrating any legacy data sources present in the background
+		ThreadPoolExecutor executor = ThreadPoolUtil.getFullDataMigrationExecutor();
+		if (executor != null)
+		{
+			executor.execute(this::convertLegacyDataSources);
+		}
+		else
+		{
+			// shouldn't happen, but just in case
+			LOGGER.error("Unable to start migration for level: ["+this.levelId+"] due to missing executor.");
+		}
+		
+	}
+	
+	
+	//=======================//
+	// data source migration //
+	//=======================//
+	
+	private void convertLegacyDataSources()
+	{
+		try
+		{
+			LOGGER.debug("Attempting to migrate data sources for: [" + this.levelId + "]-[" + this.saveDir + "]...");
+			this.migrationThreadRunning.set(true);
+			
+			
+			
+			//============================//
+			// delete unused data sources //
+			//============================//
+			
+			// this could be done all at once via SQL, 
+			// but doing it in chunks prevents locking the database for long periods of time 
+			long unusedCount = 0;
+			long totalDeleteCount = this.v1DataSourceProvider.repo.getUnusedDataSourceCount();
+			if (totalDeleteCount != 0)
+			{
+				// this should only be shown once per session but should be shown during 
+				// either when the deletion or migration phases start
+				this.showMigrationStartMessage();
+				
+				
+				LOGGER.info("deleting [" + this.levelId + "] - [" + totalDeleteCount + "] unused data sources...");
+				this.legacyDeletionCount = totalDeleteCount;
+				
+				ArrayList<String> unusedDataPosList = this.v1DataSourceProvider.repo.getUnusedDataSourcePositionStringList(50);
+				while (unusedDataPosList.size() != 0)
+				{
+					unusedCount += unusedDataPosList.size();
+					this.legacyDeletionCount -= unusedDataPosList.size();
+					
+					
+					long startTime = System.currentTimeMillis();
+					
+					// delete batch and get next batch 
+					this.v1DataSourceProvider.repo.deleteUnusedLegacyData(unusedDataPosList);
+					unusedDataPosList = this.v1DataSourceProvider.repo.getUnusedDataSourcePositionStringList(50);
+					
+					long endStart = System.currentTimeMillis();
+					long deleteTime = endStart - startTime;
+					LOGGER.info("Deleting [" + this.levelId + "] - [" + unusedCount + "/" + totalDeleteCount + "] in [" + deleteTime + "]ms ...");
+					
+					
+					// a slight delay is added to prevent accidentally locking the database when deleting a lot of rows
+					// (that shouldn't be the case since we're using WAL journaling, but just in case)
+					try
+					{
+						// use the delete time so we don't make powerful computers wait super long
+						// and weak computers wait no time at all
+						Thread.sleep(deleteTime / 2);
+					}
+					catch (InterruptedException ignore)
+					{
+					}
+				}
+				LOGGER.info("Done deleting [" + this.levelId + "] - [" + totalDeleteCount + "] unused data sources.");
+				
+			}
+			
+			
+			
+			//===========//
+			// migration //
+			//===========//
+			
+			long totalMigrationCount = this.v1DataSourceProvider.getDataSourceMigrationCount();
+			this.migrationCount = totalMigrationCount;
+			LOGGER.debug("Found [" + totalMigrationCount + "] data sources that need migration.");
+			
+			ArrayList<FullDataSourceV1> legacyDataSourceList = this.v1DataSourceProvider.getDataSourcesToMigrate(MIGRATION_BATCH_COUNT);
+			if (!legacyDataSourceList.isEmpty())
+			{
+				this.showMigrationStartMessage();
+				
+				try
+				{
+					// keep going until every data source has been migrated
+					int progressCount = 0;
+					while (!legacyDataSourceList.isEmpty() && this.migrationThreadRunning.get())
+					{
+						NumberFormat numFormat = F3Screen.NUMBER_FORMAT;
+						LOGGER.info("Migrating [" + this.levelId + "] - [" + numFormat.format(progressCount) + "/" + numFormat.format(totalMigrationCount) + "]...");
+						
+						ArrayList<CompletableFuture<Void>> updateFutureList = new ArrayList<>();
+						for (int i = 0; i < legacyDataSourceList.size() && this.migrationThreadRunning.get(); i++)
+						{
+							FullDataSourceV1 legacyDataSource = legacyDataSourceList.get(i);
+							
+							try
+							{
+								// convert the legacy data source to the new format,
+								// this is a relatively cheap operation
+								FullDataSourceV2 newDataSource = FullDataSourceV2.createFromLegacyDataSourceV1(legacyDataSource);
+								newDataSource.applyToParent = true;
+								
+								// the actual update process can be moderately expensive due to having to update
+								// the render data along with the full data, so running it async on the update threads gains us a good bit of speed
+								CompletableFuture<Void> future = this.dataUpdater.updateDataSourceAsync(newDataSource);
+								updateFutureList.add(future);
+								future.thenRun(() ->
+								{
+									// after the update finishes the legacy data source can be safely deleted
+									this.v1DataSourceProvider.repo.deleteWithKey(legacyDataSource.getPos());
+									newDataSource.close();
+								});
+							}
+							catch (Exception e)
+							{
+								long migrationPos = legacyDataSource.getPos();
+								LOGGER.warn("Unexpected issue migrating data source at pos [" + DhSectionPos.toString(migrationPos) + "]. Error: " + e.getMessage(), e);
+								this.v1DataSourceProvider.markMigrationFailed(migrationPos);
+							}
+						}
+						
+						
+						try
+						{
+							// wait for each thread to finish updating
+							CompletableFuture<Void> combinedFutures = CompletableFuture.allOf(updateFutureList.toArray(new CompletableFuture[0]));
+							combinedFutures.get(MIGRATION_MAX_UPDATE_TIMEOUT_IN_MS, TimeUnit.MILLISECONDS);
+						}
+						catch (InterruptedException | TimeoutException e)
+						{
+							LOGGER.warn("Migration update timed out after [" + MIGRATION_MAX_UPDATE_TIMEOUT_IN_MS + "] milliseconds. Migration will re-try the same positions again in a moment.", e);
+						}
+						catch (ExecutionException e)
+						{
+							LOGGER.warn("Migration update failed. Migration will re-try the same positions again. Error:" + e.getMessage(), e);
+						}
+						
+						legacyDataSourceList = this.v1DataSourceProvider.getDataSourcesToMigrate(MIGRATION_BATCH_COUNT);
+						
+						progressCount += legacyDataSourceList.size();
+						this.migrationCount -= legacyDataSourceList.size();
+					}
+				}
+				catch (Exception e)
+				{
+					LOGGER.info("migration stopped due to error for: [" + this.levelId + "]-[" + this.saveDir + "], error: [" + e.getMessage() + "].", e);
+					this.showMigrationEndMessage(false);
+					this.migrationStoppedWithError = true;
+				}
+				finally
+				{
+					if (this.migrationThreadRunning.get())
+					{
+						LOGGER.info("migration complete for: [" + this.levelId + "]-[" + this.saveDir + "].");
+						this.showMigrationEndMessage(true);
+						this.migrationCount = 0;
+					}
+					else
+					{
+						LOGGER.info("migration stopped for: [" + this.levelId + "]-[" + this.saveDir + "].");
+						this.showMigrationEndMessage(false);
+						this.migrationStoppedWithError = true;
+					}
+				}
+			}
+			else
+			{
+				LOGGER.info("No migration necessary.");
+			}
+		}
+		finally
+		{
+			this.migrationThreadRunning.set(false);
+		}
+	}
+	
+	
+	private void showMigrationStartMessage()
+	{
+		if (this.migrationStartMessageQueued)
+		{
+			return;
+		}
+		this.migrationStartMessageQueued = true;
+		
+		ClientApi.INSTANCE.showChatMessageNextFrame(
+				"Old Distant Horizons data is being migrated for ["+this.levelId+"]. \n" +
+				"While migrating LODs may load slowly \n" +
+				"and DH world gen will be disabled. \n" +
+				"You can see migration progress in the F3 menu."
+		);
+	}
+	
+	private void showMigrationEndMessage(boolean success)
+	{
+		if (success)
+		{
+			ClientApi.INSTANCE.showChatMessageNextFrame("Distant Horizons data migration for ["+this.levelId+"] completed.");
+		}
+		else
+		{
+			ClientApi.INSTANCE.showChatMessageNextFrame(
+					"Distant Horizons data migration for ["+this.levelId+"] stopped. \n" +
+					"Some data may not have been migrated."
+			);
+		}
+	}
+	
+	
+	
+	//===========//
+	// debugging //
+	//===========//
+	
+	public void addDebugMenuStringsToList(List<String> messageList)
+	{
+		// migration
+		boolean migrationErrored = this.migrationStoppedWithError;
+		if (!migrationErrored)
+		{
+			long legacyDeletionCount = this.legacyDeletionCount;
+			if (legacyDeletionCount > 0)
+			{
+				messageList.add("  Migrating - Deleting #: " + F3Screen.NUMBER_FORMAT.format(legacyDeletionCount));
+			}
+			
+			long migrationCount = this.migrationCount;
+			if (migrationCount > 0)
+			{
+				messageList.add("  Migrating - Conversion #: " + F3Screen.NUMBER_FORMAT.format(migrationCount));
+			}
+		}
+		else
+		{
+			messageList.add("  Migration Failed");
+		}
+	}
+	
+	
+	
+	//===========//
+	// overrides //
+	//===========//
+	
+	@Override
+	public void debugRender(DebugRenderer renderer)
+	{
+		// nothing currently needed
+	}
+	
+	@Override
+	public void close()
+	{
+		//LOGGER.info("Closing [" + this.getClass().getSimpleName() + "] for level: [" + this.levelId + "].");
+	}
+	
+	
+	
+}

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

@@ -0,0 +1,473 @@
+/*
+ *    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.file.fullDatafile.V2;
+
+import com.seibel.distanthorizons.api.enums.config.EDhApiDataCompressionMode;
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+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.DataSourceRetrievalResult;
+import com.seibel.distanthorizons.core.level.IDhLevel;
+import com.seibel.distanthorizons.core.logging.DhLogger;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.pos.DhSectionPos;
+import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
+import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
+import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV2DTO;
+import com.seibel.distanthorizons.core.sql.repo.AbstractDhRepo;
+import com.seibel.distanthorizons.core.sql.repo.FullDataSourceV2Repo;
+import com.seibel.distanthorizons.core.util.LodUtil;
+import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
+import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
+import it.unimi.dsi.fastutil.longs.LongArrayList;
+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.AtomicBoolean;
+
+/**
+ * Handles reading/writing {@link FullDataSourceV2} 
+ * to and from the database.
+ */
+public class FullDataSourceProviderV2 implements IDebugRenderable, AutoCloseable
+{
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
+
+	private static final Set<String> CORRUPT_DATA_ERRORS_LOGGED = Collections.newSetFromMap(new ConcurrentHashMap<>());
+	
+	/**
+	 * The highest numerical detail level possible. 
+	 * Used when determining which positions to update. 
+	 *
+	 * @see FullDataSourceProviderV2#LEAF_SECTION_DETAIL_LEVEL
+	 */
+	public static final byte ROOT_SECTION_DETAIL_LEVEL
+			= DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL
+			+ LodUtil.REGION_DETAIL_LEVEL;
+	/**
+	 * The lowest numerical detail level possible. 
+	 *
+	 * @see FullDataSourceProviderV2#ROOT_SECTION_DETAIL_LEVEL
+	 */
+	public static final byte LEAF_SECTION_DETAIL_LEVEL = DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL;
+	
+	
+	public final FullDataSourceV2Repo repo;
+	
+	
+	protected final AtomicBoolean isShutdownRef = new AtomicBoolean(false);
+	protected final File saveDir;
+	protected final IDhLevel level;
+	protected final String levelId;
+	
+	
+	protected final FullDataUpdaterV2 dataUpdater;
+	protected final FullDataUpdatePropagatorV2 updatePropagator;
+	protected final DataMigratorV1 dataMigratorV1;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	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 = 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();
+		
+		this.dataUpdater = new FullDataUpdaterV2(this, this.levelId);
+		this.updatePropagator = new FullDataUpdatePropagatorV2(this, this.dataUpdater, this.levelId);
+		this.dataMigratorV1 = new DataMigratorV1(this.dataUpdater, this.level, this.levelId, this.saveDir);
+		
+		DebugRenderer.register(this, Config.Client.Advanced.Debugging.DebugWireframe.showFullDataUpdateStatus);
+		
+	}
+	
+	
+	
+	//=================//
+	// event listeners //
+	//=================//
+	
+	public void addDataSourceUpdateListener(IDataSourceUpdateListenerFunc<FullDataSourceV2> listener)
+	{
+		synchronized (this.dataUpdater.dateSourceUpdateListeners)
+		{
+			this.dataUpdater.dateSourceUpdateListeners.add(listener);
+		}
+	}
+	public void removeDataSourceUpdateListener(IDataSourceUpdateListenerFunc<FullDataSourceV2> listener)
+	{
+		synchronized (this.dataUpdater.dateSourceUpdateListeners)
+		{
+			this.dataUpdater.dateSourceUpdateListeners.add(listener);
+		}
+	}
+	
+	
+	
+	//================//
+	// DTO converters //
+	//================//
+	
+	protected FullDataSourceV2 createDataSourceFromDto(FullDataSourceV2DTO dto) throws InterruptedException, IOException, DataCorruptedException
+	{ return dto.createDataSource(this.level.getLevelWrapper(), null); }
+	protected FullDataSourceV2 createAdjDataSourceFromDto(FullDataSourceV2DTO dto, EDhDirection direction) throws InterruptedException, IOException, DataCorruptedException
+	{ return dto.createDataSource(this.level.getLevelWrapper(), direction); }
+	
+	
+	
+	//=========================//
+	// basic DataSource getter //
+	//=========================//
+	
+	/**
+	 * Returns the {@link FullDataSourceV2} for the given section position. <Br>
+	 * The returned data source may be null if repo is in the process of shutting down. <Br> <Br>
+	 *
+	 * This call is concurrent. I.e. it supports being called by multiple threads at the same time.
+	 */
+	public CompletableFuture<FullDataSourceV2> getAsync(long pos)
+	{
+		if (this.isShutdownRef.get())
+		{
+			return CompletableFuture.completedFuture(null);
+		}
+		
+		AbstractExecutorService executor = ThreadPoolUtil.getFileHandlerExecutor();
+		if (executor == null || executor.isTerminated())
+		{
+			return CompletableFuture.completedFuture(null);
+		}
+		
+		
+		try
+		{
+			return CompletableFuture.supplyAsync(() -> this.get(pos), executor);
+		}
+		catch (RejectedExecutionException ignore)
+		{
+			// the thread pool was probably shut down because it's size is being changed, just wait a sec and it should be back
+			return CompletableFuture.completedFuture(null);
+		}
+	}
+	/**
+	 * Should only be used in internal file handler methods where we are already running on a file handler thread.
+	 * Can return null if the repo is in the process of being shut down
+	 * @see FullDataSourceProviderV2#getAsync(long)
+	 */
+	@Nullable
+	public FullDataSourceV2 get(long pos)
+	{
+		if (this.isShutdownRef.get())
+		{
+			return null;
+		}
+		
+		try(FullDataSourceV2DTO dto = this.repo.getByKey(pos))
+		{
+			if (dto == null)
+			{
+				return FullDataSourceV2.createEmpty(pos);
+			}
+			
+			FullDataSourceV2 dataSource = null;
+			try
+			{
+				dataSource = this.createDataSourceFromDto(dto);
+				
+				// automatically create and save adjacent data if missing
+				if (dto.dataFormatVersion == FullDataSourceV2DTO.DATA_FORMAT.V1_NO_ADJACENT_DATA)
+				{
+					EDhApiDataCompressionMode compressionMode = Config.Common.LodBuilding.dataCompression.get();
+					try(FullDataSourceV2DTO updatedDto = FullDataSourceV2DTO.CreateFromDataSource(dataSource, compressionMode))
+					{
+						this.repo.save(updatedDto);
+					}
+				}
+				
+				return dataSource; 
+			}
+			catch (DataCorruptedException e)
+			{
+				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)
+		{
+			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
+		return null;
+	}
+	
+	protected void tryLogCorruptedDataError(String whereClause, Exception e)
+	{
+		// there's a rare issue where the exception doesn't
+		// have a message, which can cause problems
+		String message = (e.getMessage() == null) ? e.getMessage() : "No Error message for exception ["+e.getClass().getSimpleName()+"]";
+		
+		// Only log each message type once.
+		// This is done to prevent logging "No compression mode with the value [2]" 10,000 times 
+		// if the user is migrating from a nightly build and used ZStd.
+		if (CORRUPT_DATA_ERRORS_LOGGED.add(message))
+		{
+			LOGGER.warn("Corrupted data found at [" + whereClause + "]. Data at will be deleted so it can be re-generated to prevent issues. Future errors with this same message won't be logged. Error: [" + message + "].", e);
+		}
+	}
+	
+	
+	
+	//=================//
+	// partial getters //
+	//=================//
+	
+	/** 
+	 * Only returns the data row/column for the given compass-cardinal
+	 * direction. <br>
+	 * This is generally used for generating LOD render data
+	 * where we only need the adjacent data, not the full thing.
+	 */
+	public FullDataSourceV2 getAdjForDirection(long pos, EDhDirection direction)
+	{
+		if (this.isShutdownRef.get())
+		{
+			return null;
+		}
+		
+		try(FullDataSourceV2DTO dto = this.repo.getAdjByPosAndDirection(pos, direction))
+		{
+			if (dto == null)
+			{
+				return FullDataSourceV2.createEmpty(pos);
+			}
+			
+			// migrate to the V2 format first if needed
+			if (dto.dataFormatVersion == FullDataSourceV2DTO.DATA_FORMAT.V1_NO_ADJACENT_DATA)
+			{
+				// get automatically converts from V1 to V2
+				FullDataSourceV2 migratedDataSource = this.get(pos);
+				if (migratedDataSource != null)
+				{
+					migratedDataSource.clearAllNonAdjData(direction);
+				}
+				
+				return migratedDataSource;
+			}
+			
+			try
+			{
+				// load from database
+				return this.createAdjDataSourceFromDto(dto, direction);
+			}
+			catch (DataCorruptedException e)
+			{
+				this.tryLogCorruptedDataError(DhSectionPos.toString(pos), e);
+				this.repo.deleteWithKey(pos);
+			}
+		}
+		catch (InterruptedException ignore) { }
+		catch (IOException e)
+		{
+			LOGGER.warn("File read Error for pos ["+DhSectionPos.toString(pos)+"], error: "+e.getMessage(), e);
+		}
+		
+		// an error occurred
+		return null;
+	}
+	
+	
+	
+	//=======================//
+	// retrieval (world gen) //
+	//=======================//
+	
+	/**
+	 * Returns true if this provider can generate or retrieve
+	 * {@link FullDataSourceV2}'s that aren't currently in the database.
+	 */
+	public boolean canRetrieveMissingDataSources() 
+	{ 
+		// the base handler just handles basic reading/writing
+		// to the database and as such can't retrieve anything else.
+		return false; 
+	}
+	
+	/**
+	 * Returns false if this provider isn't accepting new requests,
+	 * this can be due to having a full queue or some other
+	 * limiting factor. <br><br>
+	 * 
+	 * Note: when overriding make sure to add: <br>
+	 * <code>
+	 * if (!super.canQueueRetrieval()) <br>
+	 * { <br>
+	 *      return false; <br>
+	 * } <br>
+	 * </code>
+	 * to the beginning of your override.
+	 * Otherwise, parent retrieval limits will be ignored.
+	 */
+	public boolean canQueueRetrievalNow()
+	{
+		// Retrieval shouldn't happen while an unknown number of
+		// legacy data sources are present.
+		// If retrieval was allowed we might run into concurrency issues.
+		return !this.dataMigratorV1.migrationThreadRunning.get();
+	}
+	
+	/** 
+	 * @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; }
+		
+	/** @return null if the position couldn't be queued */
+	@Nullable
+	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) { }
+	
+	public void clearRetrievalQueue() { }
+	
+	/** Can be used to display how many total retrieval requests might be available. */
+	public void setTotalRetrievalPositionCount(int newCount) { }
+	/** Can be used to display how many total chunk retrieval requests should be available. */
+	public void setEstimatedRemainingRetrievalChunkCount(int newCount) { }
+	
+	
+	
+	//=============//
+	// data update //
+	//=============//
+	
+	public CompletableFuture<Void> updateDataSourceAsync(@NotNull FullDataSourceV2 inputData)
+	{ return this.dataUpdater.updateDataSourceAsync(inputData); }
+	
+	
+	
+	//========================//
+	// multiplayer networking //
+	//========================//
+	
+	@Nullable
+	public Long getTimestampForPos(long pos)
+	{
+		if (this.isShutdownRef.get())
+		{
+			return null;
+		}
+		
+		return this.repo.getTimestampForPos(pos); 
+	}
+	
+	
+	
+	//===========//
+	// debugging //
+	//===========//
+	
+	public void addDebugMenuStringsToList(List<String> messageList)
+	{
+		this.dataMigratorV1.addDebugMenuStringsToList(messageList);
+	}
+	
+	
+	
+	//===========//
+	// overrides //
+	//===========//
+	
+	@Override
+	public void debugRender(DebugRenderer renderer)
+	{
+		this.dataUpdater.debugRender(renderer);
+		this.updatePropagator.debugRender(renderer);
+		this.dataMigratorV1.debugRender(renderer);
+	}
+	
+	@Override 
+	public void close()
+	{
+		LOGGER.debug("Closing [" + this.getClass().getSimpleName() + "] for level: [" + this.levelId + "].");
+		
+		this.isShutdownRef.set(true);
+		
+		this.dataUpdater.close();
+		this.updatePropagator.close();
+		this.dataMigratorV1.close();
+		
+		this.repo.close();
+	}
+	
+	
+	
+}

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

@@ -0,0 +1,398 @@
+package com.seibel.distanthorizons.core.file.fullDatafile.V2;
+
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
+import com.seibel.distanthorizons.core.logging.DhLogger;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.pos.DhSectionPos;
+import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
+import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
+import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
+import com.seibel.distanthorizons.core.util.ThreadUtil;
+import com.seibel.distanthorizons.core.util.threading.PriorityTaskPicker;
+import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
+import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
+import it.unimi.dsi.fastutil.longs.LongArrayList;
+import org.jetbrains.annotations.Nullable;
+
+import java.awt.*;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class FullDataUpdatePropagatorV2 implements IDebugRenderable, AutoCloseable
+{
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
+	
+	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
+	
+	/** indicates how long the update queue thread should wait between queuing ticks */
+	protected static final int PROPAGATE_QUEUE_THREAD_DELAY_IN_MS = 250;
+	
+	public static final int NUMBER_OF_PARENT_UPDATE_TASKS_PER_THREAD = 5;
+	
+	/** how many parent update tasks can be in the queue at once */
+	public static int getMaxPropagateTaskCount() 
+	{ return NUMBER_OF_PARENT_UPDATE_TASKS_PER_THREAD * Config.Common.MultiThreading.numberOfThreads.get(); }
+	
+	
+	
+	/**
+	 * Tracks which positions are currently being updated
+	 * to prevent duplicate concurrent updates.
+	 */
+	private final Set<Long> updatingPosSet = ConcurrentHashMap.newKeySet();
+	
+	// TODO only run thread if modifications happened recently
+	/**
+	 * Will be null on the dedicated server since updates don't need to be propagated,
+	 * only the highest detail level is needed.
+	 */
+	@Nullable
+	public final ThreadPoolExecutor updateQueueProcessor;
+	
+	private final AtomicBoolean isShutdownRef = new AtomicBoolean(false);
+	private final String levelId;
+	
+	
+	private final FullDataSourceProviderV2 provider;
+	private final FullDataUpdaterV2 dataUpdater;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public FullDataUpdatePropagatorV2(FullDataSourceProviderV2 provider, FullDataUpdaterV2 dataUpdater, String levelId)
+	{
+		this.provider = provider;
+		this.dataUpdater = dataUpdater;
+		this.levelId = levelId;
+		
+		// update propagation doesn't need to be run on the server since only the highest detail level is needed
+		this.updateQueueProcessor = ThreadUtil.makeSingleThreadPool("Update Propagate Queue [" + this.levelId + "]");
+		this.updateQueueProcessor.execute(this::runUpdateQueue);
+	}
+	
+	
+	
+	//================//
+	// parent updates //
+	//================//
+	
+	private void runUpdateQueue()
+	{
+		while (!Thread.interrupted())
+		{
+			try
+			{
+				Thread.sleep(PROPAGATE_QUEUE_THREAD_DELAY_IN_MS);
+				
+				PriorityTaskPicker.Executor executor = ThreadPoolUtil.getUpdatePropagatorExecutor();
+				if (executor == null || executor.isTerminated())
+				{
+					continue;
+				}
+				
+				// TODO it might be worth skipping this logic if no parent updates happened
+				
+				// update positions closest to the player (if not on a server)
+				// to make world gen appear faster
+				DhBlockPos targetBlockPos = DhBlockPos.ZERO;
+				if (MC_CLIENT != null 
+					&& MC_CLIENT.playerExists())
+				{
+					targetBlockPos = MC_CLIENT.getPlayerBlockPos();
+				}
+				
+				this.runParentUpdates(executor, targetBlockPos);
+				
+				if (Config.Common.LodBuilding.Experimental.upsampleLowerDetailLodsToFillHoles.get())
+				{
+					this.runChildUpdates(executor, targetBlockPos);
+				}
+				
+			}
+			catch (InterruptedException ignored)
+			{
+				Thread.currentThread().interrupt();
+			}
+			catch (Exception e)
+			{
+				LOGGER.error("Unexpected error in the parent update queue thread. Error: " + e.getMessage(), e);
+			}
+		}
+	}
+	/** will always apply updates */
+	private void runParentUpdates(PriorityTaskPicker.Executor executor, DhBlockPos targetBlockPos)
+	{
+		int maxUpdateTaskCount = getMaxPropagateTaskCount();
+		
+		// queue parent updates
+		if (executor.getQueueSize() < maxUpdateTaskCount
+			&& this.updatingPosSet.size() < maxUpdateTaskCount)
+		{
+			// get the positions that need to be applied to their parents
+			LongArrayList parentUpdatePosList = this.provider.repo.getPositionsToUpdate(targetBlockPos.getX(), targetBlockPos.getZ(), maxUpdateTaskCount);
+			
+			// combine updates together based on their parent
+			HashMap<Long, HashSet<Long>> updatePosByParentPos = new HashMap<>();
+			for (Long pos : parentUpdatePosList)
+			{
+				updatePosByParentPos.compute(DhSectionPos.getParentPos(pos), (parentPos, updatePosSet) ->
+				{
+					if (updatePosSet == null)
+					{
+						updatePosSet = new HashSet<>();
+					}
+					updatePosSet.add(pos);
+					return updatePosSet;
+				});
+			}
+			
+			// queue the updates
+			for (Long parentUpdatePos : updatePosByParentPos.keySet())
+			{
+				// stop if there are already a bunch of updates queued
+				if (this.updatingPosSet.size() > maxUpdateTaskCount
+					|| executor.getQueueSize() > maxUpdateTaskCount
+					|| !this.updatingPosSet.add(parentUpdatePos))
+				{
+					break;
+				}
+				
+				try
+				{
+					executor.execute(() ->
+					{
+						ReentrantLock parentWriteLock = this.dataUpdater.updateLockProvider.getLock(parentUpdatePos);
+						boolean parentLocked = false;
+						try
+						{
+							//LOGGER.info("updating parent: "+parentUpdatePos);
+							
+							// Locking the parent before the children should prevent deadlocks.
+							// TryLock is used instead of lock so this thread can handle a different update.
+							if (parentWriteLock.tryLock())
+							{
+								parentLocked = true;
+								this.dataUpdater.lockedPosSet.add(parentUpdatePos);
+								
+								try (FullDataSourceV2 parentDataSource = this.provider.get(parentUpdatePos))
+								{
+									// will return null if the file handler is shutting down
+									if (parentDataSource != null)
+									{
+										// apply each child pos to the parent
+										for (Long childPos : updatePosByParentPos.get(parentUpdatePos))
+										{
+											ReentrantLock childReadLock = this.dataUpdater.updateLockProvider.getLock(childPos);
+											try
+											{
+												childReadLock.lock();
+												this.dataUpdater.lockedPosSet.add(childPos);
+												
+												try (FullDataSourceV2 childDataSource = this.provider.get(childPos))
+												{
+													// can return null when the file handler is being shut down
+													if (childDataSource != null)
+													{
+														parentDataSource.updateFromDataSource(childDataSource);
+													}
+												}
+											}
+											catch (Exception e)
+											{
+												LOGGER.error("Unexpected in parent update propagation for parent pos: ["+DhSectionPos.toString(parentUpdatePos)+"], child pos: [" + DhSectionPos.toString(parentUpdatePos) + "], Error: [" + e.getMessage() + "].", e);
+											}
+											finally
+											{
+												this.provider.repo.setApplyToParent(childPos, false);
+												
+												childReadLock.unlock();
+												this.dataUpdater.lockedPosSet.remove(childPos);
+											}
+										}
+										
+										
+										if (DhSectionPos.getDetailLevel(parentUpdatePos) < FullDataSourceProviderV2.ROOT_SECTION_DETAIL_LEVEL)
+										{
+											parentDataSource.applyToParent = true;
+										}
+										
+										this.dataUpdater.updateDataSource(parentDataSource);
+									}
+								}
+							}
+						}
+						finally
+						{
+							if (parentLocked)
+							{
+								parentWriteLock.unlock();
+								this.dataUpdater.lockedPosSet.remove(parentUpdatePos);
+							}
+							
+							this.updatingPosSet.remove(parentUpdatePos);
+						}
+					});
+				}
+				catch (RejectedExecutionException ignore)
+				{ /* the executor was shut down, it should be back up shortly and able to accept new jobs */ }
+				catch (Exception e)
+				{
+					this.updatingPosSet.remove(parentUpdatePos);
+					throw e;
+				}
+			}
+		}
+	}
+	/** stops if it finds any LOD data */
+	private void runChildUpdates(PriorityTaskPicker.Executor executor, DhBlockPos targetBlockPos)
+	{
+		int maxUpdateTaskCount = getMaxPropagateTaskCount();
+		
+		// queue child updates
+		if (executor.getQueueSize() < maxUpdateTaskCount
+			&& this.updatingPosSet.size() < maxUpdateTaskCount)
+		{
+			// get the positions that need to be applied to their children
+			LongArrayList childUpdatePosList = this.provider.repo.getChildPositionsToUpdate(targetBlockPos.getX(), targetBlockPos.getZ(), maxUpdateTaskCount);
+			
+			// queue the updates
+			for (long parentUpdatePos : childUpdatePosList)
+			{
+				// stop if there are already a bunch of updates queued
+				if (this.updatingPosSet.size() > maxUpdateTaskCount
+					|| executor.getQueueSize() > maxUpdateTaskCount)
+				{
+					break;
+				}
+				
+				// skip already updating positions
+				if (!this.updatingPosSet.add(parentUpdatePos))
+				{
+					continue;
+				}
+				
+				try
+				{
+					executor.execute(() ->
+					{
+						ReentrantLock parentReadLock = this.dataUpdater.updateLockProvider.getLock(parentUpdatePos);
+						boolean parentLocked = false;
+						try
+						{
+							//LOGGER.info("updating parent: "+parentUpdatePos);
+							
+							// Locking the parent before the children should prevent deadlocks.
+							// TryLock is used instead of lock so this thread can handle a different update.
+							if (parentReadLock.tryLock())
+							{
+								parentLocked = true;
+								this.dataUpdater.lockedPosSet.add(parentUpdatePos);
+								
+								try (FullDataSourceV2 parentDataSource = this.provider.get(parentUpdatePos))
+								{
+									// will return null if the file handler is shutting down
+									if (parentDataSource != null)
+									{
+										// apply parent to each child
+										for (int i = 0; i < 4; i++)
+										{
+											long childPos = DhSectionPos.getChildByIndex(parentUpdatePos, i);
+											
+											ReentrantLock childWriteLock = this.dataUpdater.updateLockProvider.getLock(childPos);
+											try
+											{
+												childWriteLock.lock();
+												this.dataUpdater.lockedPosSet.add(childPos);
+												
+												try (FullDataSourceV2 childDataSource = this.provider.get(childPos))
+												{
+													// will return null if the file handler is shutting down
+													if (childDataSource != null)
+													{
+														childDataSource.updateFromDataSource(parentDataSource);
+														
+														// don't propagate child updates past the bottom of the tree
+														if (DhSectionPos.getDetailLevel(childPos) != DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL)
+														{
+															childDataSource.applyToChildren = true;
+														}
+														
+														this.dataUpdater.updateDataSource(childDataSource);
+													}
+												}
+											}
+											catch (Exception e)
+											{
+												LOGGER.error("Unexpected in child update propagation for parent pos: ["+DhSectionPos.toString(parentUpdatePos)+"], child pos: [" + DhSectionPos.toString(parentUpdatePos) + "], Error: [" + e.getMessage() + "].", e);
+											}
+											finally
+											{
+												this.provider.repo.setApplyToChild(parentUpdatePos, false);
+												
+												childWriteLock.unlock();
+												this.dataUpdater.lockedPosSet.remove(childPos);
+											}
+										}
+									}
+								}
+							}
+						}
+						finally
+						{
+							if (parentLocked)
+							{
+								parentReadLock.unlock();
+								this.dataUpdater.lockedPosSet.remove(parentUpdatePos);
+							}
+							
+							this.updatingPosSet.remove(parentUpdatePos);
+						}
+					});
+				}
+				catch (RejectedExecutionException ignore)
+				{ /* the executor was shut down, it should be back up shortly and able to accept new jobs */ }
+				catch (Exception e)
+				{
+					this.updatingPosSet.remove(parentUpdatePos);
+					throw e;
+				}
+			}
+		}
+	}
+	
+	
+	
+	//===========//
+	// overrides //
+	//===========//
+	
+	@Override
+	public void debugRender(DebugRenderer renderer)
+	{
+		this.updatingPosSet
+				.forEach((pos) -> { renderer.renderBox(new DebugRenderer.Box(pos, -32f, 80f, 0.20f, Color.MAGENTA)); });
+	}
+	
+	@Override
+	public void close()
+	{
+		if (this.updateQueueProcessor != null)
+		{
+			this.updateQueueProcessor.shutdownNow();
+		}
+	}
+	
+	
+	
+}

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

@@ -0,0 +1,244 @@
+package com.seibel.distanthorizons.core.file.fullDatafile.V2;
+
+import com.seibel.distanthorizons.api.enums.config.EDhApiDataCompressionMode;
+import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
+import com.seibel.distanthorizons.core.file.fullDatafile.IDataSourceUpdateListenerFunc;
+import com.seibel.distanthorizons.core.logging.DhLogger;
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.pos.DhSectionPos;
+import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
+import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
+import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV2DTO;
+import com.seibel.distanthorizons.core.util.threading.PositionalLockProvider;
+import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class FullDataUpdaterV2 implements IDebugRenderable, AutoCloseable
+{
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
+	
+	protected final PositionalLockProvider updateLockProvider = new PositionalLockProvider();
+	/**
+	 * generally just used for debugging,
+	 * keeps track of which positions are currently locked.
+	 */
+	public final Set<Long> lockedPosSet = ConcurrentHashMap.newKeySet();
+	private final ConcurrentHashMap<Long, AtomicInteger> queuedUpdateCountsByPos = new ConcurrentHashMap<>();
+	
+	public final ArrayList<IDataSourceUpdateListenerFunc<FullDataSourceV2>> dateSourceUpdateListeners = new ArrayList<>();
+	
+	private final String levelId;
+	private final AtomicBoolean isShutdownRef = new AtomicBoolean(false);
+	
+	private final FullDataSourceProviderV2 provider;
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public FullDataUpdaterV2(FullDataSourceProviderV2 provider, String levelId)
+	{
+		this.provider = provider;
+		this.levelId = levelId;
+		
+	}
+	
+	
+	
+	//===============//
+	// data updating //
+	//===============//
+	
+	/**
+	 * Can be used if you don't want to lock the current thread
+	 * Otherwise the sync version {@link FullDataUpdaterV2#updateDataSource(FullDataSourceV2)} may be a better choice.
+	 */
+	public CompletableFuture<Void> updateDataSourceAsync(@NotNull FullDataSourceV2 inputDataSource)
+	{
+		if (this.isShutdownRef.get())
+		{
+			return CompletableFuture.completedFuture(null);
+		}
+		
+		AbstractExecutorService executor = ThreadPoolUtil.getChunkToLodBuilderExecutor();
+		if (executor == null || executor.isTerminated())
+		{
+			return CompletableFuture.completedFuture(null);
+		}
+		
+		
+		try
+		{
+			this.markUpdateStart(inputDataSource.getPos());
+			return CompletableFuture.runAsync(() ->
+			{
+				try
+				{
+					this.updateDataSource(inputDataSource);
+				}
+				catch (Exception e)
+				{
+					LOGGER.error("Unexpected error in async data source update at pos: ["+ DhSectionPos.toString(inputDataSource.getPos())+"], error: ["+e.getMessage()+"].", e);
+				}
+				finally
+				{
+					this.markUpdateEnd(inputDataSource.getPos());
+				}
+			}, executor);
+		}
+		catch (RejectedExecutionException ignore)
+		{
+			// can happen if the executor was shutdown while this task was queued
+			this.markUpdateEnd(inputDataSource.getPos());
+			return CompletableFuture.completedFuture(null);
+		}
+	}
+	
+	/** After this method returns the inputData will be written to file. */
+	public void updateDataSource(@NotNull FullDataSourceV2 inputData)
+	{
+		if (this.isShutdownRef.get())
+		{
+			return;
+		}
+		
+		
+		long updatePos = inputData.getPos();
+		
+		// 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
+		{
+			updateLock.lock();
+			this.lockedPosSet.add(updatePos);
+			
+			
+			// get or create the data source
+			try (FullDataSourceV2 recipientDataSource = this.provider.get(updatePos))
+			{
+				if (recipientDataSource != null) // will be null if the repo was shut down
+				{
+					boolean dataModified = recipientDataSource.updateFromDataSource(inputData);
+					if (dataModified)
+					{
+						// save the updated data to the database
+						try (FullDataSourceV2DTO dto = this.createDtoFromDataSource(recipientDataSource))
+						{
+							if (dto != null)
+							{
+								this.provider.repo.save(dto);
+							}
+						}
+						
+						
+						synchronized (this.dateSourceUpdateListeners)
+						{
+							for (IDataSourceUpdateListenerFunc<FullDataSourceV2> listener : this.dateSourceUpdateListeners)
+							{
+								if (listener != null)
+								{
+									listener.OnDataSourceUpdated(recipientDataSource);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		catch (Exception e)
+		{
+			LOGGER.error("Error updating pos ["+DhSectionPos.toString(updatePos)+"], error: "+e.getMessage(), e);
+		}
+		finally
+		{
+			updateLock.unlock();
+			this.lockedPosSet.remove(updatePos);
+		}
+	}
+	
+	private FullDataSourceV2DTO createDtoFromDataSource(FullDataSourceV2 dataSource)
+	{
+		try
+		{
+			// when creating new data use the compressor currently selected in the config
+			EDhApiDataCompressionMode compressionModeEnum = Config.Common.LodBuilding.dataCompression.get();
+			return FullDataSourceV2DTO.CreateFromDataSource(dataSource, compressionModeEnum);
+		}
+		catch (IOException e)
+		{
+			LOGGER.warn("Unable to create DTO, error: ["+e.getMessage() + "].", e);
+			return null;
+		}
+	}
+	
+	
+	
+	
+	//==================//
+	// debugger methods //
+	//==================//
+	
+	/** used for debugging to track which positions are queued for updating */
+	private void markUpdateStart(long dataSourcePos)
+	{
+		this.queuedUpdateCountsByPos.compute(dataSourcePos, (pos, atomicCount) ->
+		{
+			if (atomicCount == null)
+			{
+				atomicCount = new AtomicInteger(0);
+			}
+			atomicCount.incrementAndGet();
+			return atomicCount;
+		});
+	}
+	/** used for debugging to track which positions are queued for updating */
+	private void markUpdateEnd(long dataSourcePos)
+	{
+		this.queuedUpdateCountsByPos.compute(dataSourcePos, (pos, atomicCount) ->
+		{
+			if (atomicCount != null && atomicCount.decrementAndGet() <= 0)
+			{
+				atomicCount = null;
+			}
+			return atomicCount;
+		});
+	}
+	
+	
+	
+	//===========//
+	// overrides //
+	//===========//
+	
+	@Override
+	public void debugRender(DebugRenderer renderer)
+	{
+		this.lockedPosSet
+				.forEach((pos) -> { renderer.renderBox(new DebugRenderer.Box(pos, -32f, 74f, 0.15f, Color.PINK)); });
+		
+		this.queuedUpdateCountsByPos
+				.forEach((pos, updateCountRef) -> { renderer.renderBox(new DebugRenderer.Box(pos, -32f, 80f + (updateCountRef.get() * 16f), 0.20f, Color.WHITE)); });
+	}
+	
+	@Override
+	public void close()
+	{
+		this.isShutdownRef.set(true);
+	}
+	
+	
+}

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

@@ -32,7 +32,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSha
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector;
 import com.seibel.distanthorizons.coreapi.util.StringUtil;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.io.File;
 import java.util.*;
@@ -47,7 +47,7 @@ public class ClientOnlySaveStructure implements ISaveStructure
 	public static final String REPLAY_SERVER_FOLDER_NAME = "REPLAY";
 	public static final String INVALID_FILE_CHARACTERS_REGEX = "[\\\\/:*?\"<>|]";
 	
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	private static final IMinecraftSharedWrapper MC_SHARED = SingletonInjector.INSTANCE.get(IMinecraftSharedWrapper.class);
@@ -81,13 +81,20 @@ public class ClientOnlySaveStructure implements ISaveStructure
 			{
 				IServerKeyedClientLevel keyedClientLevel = (IServerKeyedClientLevel) newLevelWrapper;
 				LOGGER.info("Loading level [" + newLevelWrapper.getDhIdentifier() + "] with key: [" + keyedClientLevel.getServerLevelKey() + "].");
-				// This world was identified by the server directly, so we can know for sure which folder to use.
+				
-				saveFolder = getSaveFolderByLevelId(keyedClientLevel.getServerLevelKey());
+				String serverKey = keyedClientLevel.getServerKey();
+				if (serverKey.isEmpty())
+				{
+					serverKey = getServerFolderName();
+				}
+				
+				// This world was identified by the server directly, so we can know for sure which folder to use.				
+				saveFolder = getSaveFolderByLevelId(serverKey, keyedClientLevel.getServerLevelKey());
 			}
 			else
 			{
 				// get the default folder
-				saveFolder = getSaveFolderByLevelId(levelWrapper.getDhIdentifier());
+				saveFolder = getSaveFolderByLevelId(getServerFolderName(), levelWrapper.getDhIdentifier());
 			}
 			
 			// Allow API users to override the save folder
@@ -116,7 +123,7 @@ public class ClientOnlySaveStructure implements ISaveStructure
 			return this.getSaveFolder(levelWrapper);
 		}
 		
-		return getSaveFolderByLevelId(levelWrapper.getDimensionType().getName());
+		return getSaveFolderByLevelId(getServerFolderName(), levelWrapper.getDimensionType().getName());
 	}
 	
 	
@@ -173,11 +180,11 @@ public class ClientOnlySaveStructure implements ISaveStructure
 	}
 	
 	
-	private static File getSaveFolderByLevelId(String dimensionName)
+	private static File getSaveFolderByLevelId(String folderName, String dimensionName)
 	{
 		String path = MC_SHARED.getInstallationDirectory().getPath() + File.separatorChar
 				+ SERVER_DATA_FOLDER_NAME + File.separatorChar
-				+ getServerFolderName() + File.separatorChar
+				+ folderName + File.separatorChar
 				+ dimensionName.replaceAll(":", "@@");
 		
 		return new File(path);

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

@@ -26,7 +26,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
 import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector;
 import com.seibel.distanthorizons.coreapi.util.StringUtil;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.io.File;
 import java.util.concurrent.ConcurrentHashMap;
@@ -36,7 +36,7 @@ import java.util.concurrent.ConcurrentHashMap;
  */
 public class LocalSaveStructure implements ISaveStructure
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	private final ConcurrentHashMap<ILevelWrapper, File> levelWrapperToFileMap = new ConcurrentHashMap<>();
 	

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

@@ -24,13 +24,14 @@ 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 org.apache.logging.log4j.Logger;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
@@ -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 Logger LOGGER = DhLoggerBuilder.getLogger();
+	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,
+			int chunkPosMinX,
-			ExecutorService worldGeneratorThreadPool, Consumer<Object[]> resultConsumer)
+			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 PRE_EXISTING_ONLY: // Only load in existing chunks.
-			//case BIOME_ONLY: // No blocks. Require fake height in LodBuilder
+				targetStep = EDhApiWorldGenerationStep.EMPTY; // special logic
-				targetStep = EDhApiWorldGenerationStep.BIOMES; 
 				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(
+			return this.generationEnvironment.queueGenEvent(
-					chunkPosMinX, chunkPosMinZ, generationRequestChunkWidthCount, 
+					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...");
+		LOGGER.info("["+BatchGenerator.class.getSimpleName()+"] shutting down...");
-		this.generationEnvironment.stop();
+		this.generationEnvironment.close();
 	}
 	
 	
+	
 }

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

@@ -33,7 +33,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrappe
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IMutableBlockPosWrapper;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
-import org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 
 import java.awt.*;
 import java.util.*;
@@ -49,7 +49,7 @@ import org.jetbrains.annotations.NotNull;
  */
 public class DhLightingEngine
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	public static final DhLightingEngine INSTANCE = new DhLightingEngine();
 	
 	/** 
@@ -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);
+				IChunkWrapper neighborChunk = nearbyChunkList.get(chunkIndex);
-				if (chunk != null && requestedAdjacentPositions.contains(chunk.getChunkPos()))
+				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 maxY = neighborChunk.getMaxNonEmptyHeight();
-						int minY = chunk.getInclusiveMinBuildHeight();
+						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,
+				posIterations += this.propagateChunkLightPosList(blockLightWorldPosQueue, adjacentChunkHolder,
-						(neighbourChunk, relBlockPos) -> neighbourChunk.getDhBlockLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ()),
+					(neighbourChunk, relBlockPos) -> neighbourChunk.getDhBlockLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ()),
-						(neighbourChunk, relBlockPos, newLightValue) -> neighbourChunk.setDhBlockLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ(), newLightValue),
+					(neighbourChunk, relBlockPos, newLightValue) -> neighbourChunk.setDhBlockLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ(), newLightValue),
-						true);
+					true);
 			}
 			
 			// sky light
@@ -261,10 +268,10 @@ public class DhLightingEngine
 			{
 				centerChunk.clearDhSkyLighting();
 				
-				this.propagateChunkLightPosList(skyLightWorldPosQueue, adjacentChunkHolder,
+				posIterations += this.propagateChunkLightPosList(skyLightWorldPosQueue, adjacentChunkHolder,
-						(neighbourChunk, relBlockPos) -> neighbourChunk.getDhSkyLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ()),
+					(neighbourChunk, relBlockPos) -> neighbourChunk.getDhSkyLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ()),
-						(neighbourChunk, relBlockPos, newLightValue) -> neighbourChunk.setDhSkyLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ(), newLightValue),
+					(neighbourChunk, relBlockPos, newLightValue) -> neighbourChunk.setDhSkyLight(relBlockPos.getX(), relBlockPos.getY(), relBlockPos.getZ(), newLightValue),
-						false);
+					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,
+			// Walking down from the top light level to the bottom can reduce iterating over
-			// 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)
+			// the same positions multiple times.
-			lightPosQueue.popMutate(lightPos);
+			// 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;
 			
-			
+			// update each light position
-			// propagate the lighting in each cardinal direction, IE: -x, +x, -y, +y, -z, +z
+			while (!lightPosQueue.isLightLevelEmpty(currentLightLevel))
-			for (EDhDirection direction : EDhDirection.CARDINAL_DIRECTIONS) // since this is an array instead of an ArrayList this advanced for-loop shouldn't cause any GC issues
 			{
-				lightPos.mutateOffset(direction, neighbourBlockPos);
+				// since we don't care about the order the positions are processed,
-				neighbourBlockPos.mutateToChunkRelativePos(relNeighbourBlockPos);
+				// 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
+				// propagate the lighting in each cardinal direction, IE: -x, +x, -y, +y, -z, +z
-				IChunkWrapper neighbourChunk = adjacentChunkHolder.getByBlockPos(neighbourBlockPos.getX(), neighbourBlockPos.getZ());
+				for (EDhDirection direction : EDhDirection.ALL) // since this is an array instead of an ArrayList this advanced for-loop shouldn't cause any GC issues
-				if (neighbourChunk == null)
 				{
-					// the light pos is outside our generator's range, ignore it
+					lightPos.mutateOffset(direction, neighbourBlockPos);
-					continue;
+					neighbourBlockPos.mutateToChunkRelativePos(relNeighbourBlockPos);
-				}
-				
-				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);
 					
-					// now that light has been propagated to this blockPos
+					
-					// we need to queue it up so its neighbours can be propagated as well
+					// only continue if the light position is inside one of our chunks
-					lightPosQueue.push(neighbourBlockPos.getX(), neighbourBlockPos.getY(), neighbourBlockPos.getZ(), targetLevel);
+					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;
 	}
 	
 	
@@ -413,7 +458,7 @@ public class DhLightingEngine
 		{
 			for (int x = 0; x < FullDataSourceV2.WIDTH; x++)
 			{
-				LongArrayList dataPoints = dataSource.get(x, z);
+				LongArrayList dataPoints = dataSource.getColumnAtRelPos(x, z);
 				if (dataPoints != null && !dataPoints.isEmpty())
 				{
 					// iterate through the data points in this column top-down
@@ -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);
 						}
 					}
 				}
@@ -564,7 +609,7 @@ public class DhLightingEngine
 			// check if the adjacent position is within the bounds of this data source...
 			if (adjacentX >= 0 && adjacentX < FullDataSourceV2.WIDTH && adjacentZ >= 0 && adjacentZ < FullDataSourceV2.WIDTH)
 			{
-				LongArrayList adjacentDataPoints = chunk.get(adjacentX, adjacentZ);
+				LongArrayList adjacentDataPoints = chunk.getColumnAtRelPos(adjacentX, adjacentZ);
 				// ...and also check to make sure we have some data points
 				// (potentially transparent ones) to propagate through in the adjacent column.
 				if (adjacentDataPoints != null)
@@ -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. */
+		/** x, y, z */
-		public static final int INTS_PER_LIGHT_POS = 4;
+		public static final int INTS_PER_LIGHT_POS = 3;
 		
-		/**
+		private final IntArrayList[] lightPositionsByLightLevel = new IntArrayList[LodUtil.MAX_MC_LIGHT + 1];
-		 * 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.
+		
-		 */
+		public StableLightPosStack()
-		private final IntArrayList lightPositions = new IntArrayList(40_000 * INTS_PER_LIGHT_POS);
+		{
+			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 boolean isLightLevelEmpty(int lightLevel) { return this.indexByLightLevel[lightLevel] == -1; }
-		public int size() { return this.index+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++;
+			IntArrayList lightPositions = this.lightPositionsByLightLevel[lightLevel];
-			int subIndex = this.index * INTS_PER_LIGHT_POS;
+			
-			if (subIndex < this.lightPositions.size())
+			this.indexByLightLevel[lightLevel]++;
+			int subIndex = this.indexByLightLevel[lightLevel] * INTS_PER_LIGHT_POS;
+			if (subIndex < lightPositions.size())
 			{
-				this.lightPositions.set(subIndex, blockX);
+				lightPositions.set(subIndex, blockX);
-				this.lightPositions.set(subIndex + 1, blockY);
+				lightPositions.set(subIndex + 1, blockY);
-				this.lightPositions.set(subIndex + 2, blockZ);
+				lightPositions.set(subIndex + 2, blockZ);
-				this.lightPositions.set(subIndex + 3, lightValue);
 			}
 			else
 			{
 				// add a new pos
-				this.lightPositions.add(blockX);
+				lightPositions.add(blockX);
-				this.lightPositions.add(blockY);
+				lightPositions.add(blockY);
-				this.lightPositions.add(blockZ);
+				lightPositions.add(blockZ);
-				this.lightPositions.add(lightValue);
 			}
 		}
 		
 		/** 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.setX(lightPositions.getInt(subIndex));
-			pos.setY(this.lightPositions.getInt(subIndex + 1));
+			pos.setY(lightPositions.getInt(subIndex + 1));
-			pos.setZ(this.lightPositions.getInt(subIndex + 2));
+			pos.setZ(lightPositions.getInt(subIndex + 2));
-			pos.lightValue = this.lightPositions.getInt(subIndex + 3);
 			
-			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.DataSourceRetrievalResult;
-import com.seibel.distanthorizons.core.generation.tasks.WorldGenResult;
 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,15 +5,19 @@ 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 org.apache.logging.log4j.Logger;
+import com.seibel.distanthorizons.core.logging.DhLogger;
 import org.jetbrains.annotations.Nullable;
 
 import java.text.MessageFormat;
@@ -26,7 +30,9 @@ import java.util.concurrent.atomic.AtomicReference;
 
 public class PregenManager
 {
-	protected static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	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<>();
 	
@@ -38,7 +44,7 @@ public class PregenManager
 	)
 	{
 		PregenState pregenState = new PregenState(
-				(GeneratedFullDataSourceProvider) SharedApi.getIDhServerWorld().getLevel(levelWrapper).getFullDataProvider(),
+				(GeneratedFullDataSourceProvider) SharedApi.tryGetDhServerWorld().getLevel(levelWrapper).getFullDataProvider(),
 				DhSectionPos.convertToDetailLevel(
 						DhSectionPos.encode(LodUtil.BLOCK_DETAIL_LEVEL, origin.x, origin.z),
 						DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL
@@ -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();
 				})
@@ -140,21 +147,25 @@ public class PregenManager
 				}
 				
 				this.pendingGenerations.put(nextSectionPos, System.currentTimeMillis());
-				this.fullDataSourceProvider.getAsync(nextSectionPos).thenAccept(fullDataSource -> {
+				this.fullDataSourceProvider.getAsync(nextSectionPos)
-					if (this.fullDataSourceProvider.isFullyGenerated(fullDataSource.columnGenerationSteps))
+					.thenAccept(fullDataSource -> 
+				{
+					if (this.fullDataSourceProvider.generationStepsAreFullyGenerated(fullDataSource.columnGenerationSteps))
 					{
 						this.pendingGenerations.invalidate(fullDataSource.getPos());
 					}
 					else
 					{
-						this.fullDataSourceProvider.queuePositionForRetrieval(fullDataSource.getPos()).thenAccept(result -> {
+						this.fullDataSourceProvider.queuePositionForRetrieval(fullDataSource.getPos())
-							if (!result.success)
+							.whenComplete((DataSourceRetrievalResult result, Throwable throwable) ->
 							{
-								LOGGER.warn("Failed to generate section " + DhSectionPos.toString(result.pos));
+								if (throwable != null)
-							}
+								{
-							
+									LOGGER.warn("Failed to generate section " + DhSectionPos.toString(result.pos));
-							this.pendingGenerations.invalidate(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.DataSourceRetrievalResult;
-import com.seibel.distanthorizons.core.generation.tasks.WorldGenResult;
+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,17 +11,16 @@ 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 org.apache.logging.log4j.Logger;
+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
 {
-	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final DhLogger LOGGER = new DhLoggerBuilder().build();
 	
 	private int estimatedRemainingTaskCount;
 	private int estimatedTotalChunkCount;
@@ -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 -> {
+		CompletableFuture<DataSourceRetrievalResult> future = super.submitRequest(sectionPos, /* client timestamp */null);
-					Objects.requireNonNull(tracker.getDataSourceConsumer()).accept(fullDataSource);
+		future.thenAccept((DataSourceRetrievalResult result) -> 
-					fullDataSource.close();
+		{
-				})
+			if (result.state == ERetrievalResultState.SUCCESS)
-				.thenApply(requestResult ->
+			{
-				{
+				long totalGenTimeInMs = System.currentTimeMillis() - generationStartMsTime;
-					long totalGenTimeInMs = System.currentTimeMillis() - generationStartMsTime;
+
-					
+				int chunkWidth = DhSectionPos.getChunkWidth(sectionPos);
-					int chunkWidth = DhSectionPos.getChunkWidth(sectionPos);
+				int chunkCount = chunkWidth * chunkWidth;
-					int chunkCount = chunkWidth * chunkWidth;
+				double timePerChunk = (double) totalGenTimeInMs / (double) chunkCount;
-					double timePerChunk = (double)totalGenTimeInMs / (double)chunkCount;
+
-					this.rollingAverageChunkGenTimeInMs.addValue(timePerChunk);
+				// only add the time on successes
-					
+				// it won't be a perfect estimate but fails will often come back faster, skewing the time faster
-					switch (requestResult)
+				this.rollingAverageChunkGenTimeInMs.add(timePerChunk);
-					{
+			}
-						case SUCCEEDED:
+		});
-							return WorldGenResult.CreateSuccess(sectionPos);
+		return future;
-						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();
-					return WorldGenResult.CreateFail();
-				});
 	}
 	
 	@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(
+			boolean posInRange = WorldGenUtil.isPosInWorldGenRange(
-					this.networkState.sessionConfig.getGenerationBoundsX(),
+				sectionPos,
-					this.networkState.sessionConfig.getGenerationBoundsZ()
+				this.networkState.sessionConfig.getGenerationCenterChunkX(), this.networkState.sessionConfig.getGenerationCenterChunkZ(),
-			)) > this.networkState.sessionConfig.getGenerationBoundsRadius())
+				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
+		// split up large requests if N-sized gen isn't enabled
-				&& !Config.Server.Experimental.enableNSizedGeneration.get())
+		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.DataSourceRetrievalResult;
-import com.seibel.distanthorizons.core.generation.tasks.InProgressWorldGenTaskGroup;
+import com.seibel.distanthorizons.core.generation.tasks.DataSourceRetrievalTask;
-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.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 org.apache.logging.log4j.Logger;
 
 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 Logger LOGGER = DhLoggerBuilder.getLogger();
+	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, DataSourceRetrievalTask> waitingTasks = new ConcurrentHashMap<>();
-	
+	private final ConcurrentHashMap<Long, DataSourceRetrievalTask> inProgressGenTasksByLodPos = new ConcurrentHashMap<>();
-	private final ConcurrentHashMap<Long, InProgressWorldGenTaskGroup> 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);
 		
-		
+		DataSourceRetrievalTask genTask = new DataSourceRetrievalTask(pos, requiredDataDetail);
-		CompletableFuture<WorldGenResult> future = new CompletableFuture<>();
+		this.waitingTasks.put(pos, genTask);
-		this.waitingTasks.put(pos, new WorldGenTask(pos, requiredDataDetail, tracker, future));
+		return genTask.future;
-		return 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 this.inProgressGenTasksByLodPos.size() > worldGenThreadCount;
-		return executor.getQueueSize() > maxWorldGenTaskCount;
 	}
 	/**
 	 * @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,
+		if (closestTaskPair == null)
-				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)
 		{
-			// FIXME concurrency issue
+			// the waitingTasks was modified while this check was running
 			return false;
 		}
-		
+		DataSourceRetrievalTask closestTask = closestTaskPair.task;
-		WorldGenTask closestTask = closestTaskMap.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));
+			DataSourceRetrievalTask existingTask = this.inProgressGenTasksByLodPos.get(closestTask.pos);
-			closestTaskGroup.worldGenTasks.add(closestTask);
+			if (existingTask == null)
-			
-			if (!this.inProgressGenTasksByLodPos.containsKey(closestTask.pos))
 			{
 				// no task exists for this position, start one
-				InProgressWorldGenTaskGroup newTaskGroup = new InProgressWorldGenTaskGroup(closestTaskGroup);
+				this.startWorldGenTaskGroup(closestTask);
-				boolean taskStarted = this.tryStartingWorldGenTaskGroup(newTaskGroup);
-				if (!taskStarted)
-				{
-					//LOGGER.trace("Unable to start task: "+closestTask.pos+", skipping. Task position may have already been generated.");
-				}
 			}
 			else
 			{
-				// TODO replace the previous inProgress task if one exists
+				// shouldn't normally happen, but if
-				// Note: Due to concurrency reasons, even if the currently running task is compatible with 
+				// we somehow queued the same task twice:
-				// 		   the newly selected task, we cannot use it,
+				// merge the two futures so they both complete
-				//         as some chunks may have already been written into.
 				
-				//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
 			
-			
+			closestTask.future.complete(DataSourceRetrievalResult.CreateSplit());
-			// 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;
 		}
-	}
-	/** @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;
+		generationFuture.handle((FullDataSourceV2 fullDataSource, Throwable exception) ->
-		LodUtil.assertTrue(newTaskGroup.genFuture != null);
-		
-		newTaskGroup.genFuture.whenComplete((voidObj, 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(
+	private CompletableFuture<FullDataSourceV2> startGenerationEvent(DataSourceRetrievalTask task)
-		long requestPos, 
-		byte targetDataDetail,
-		int generationRequestChunkWidthCount,
-		Consumer<FullDataSourceV2> dataSourceConsumer
-		)
 	{
-		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(
+				return this.startVanillaChunkGenerationEvent(task, chunkPosMin, generatorMode);
-					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.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);
-						}
-					}
-				);
 			}
 			case API_CHUNKS: 
 			{
-				return this.generator.generateApiChunks(
+				return this.startApiChunkGenerationEvent(task, chunkPosMin, generatorMode);
-					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);
-						}
-					}
-				);
 			}
 			case API_DATA_SOURCES:
 			{
-				// done to reduce GC overhead
+				return this.startApiDataSourceGenerationEvent(task, chunkPosMin, generatorMode);
-				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);
-							}
-						}
-				);
 			}
 			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
+	@Override public byte lowestDataDetail() { return this.lowestDataDetail; }
-	public byte lowestDataDetail() { return this.lowestDataDetail; }
+	@Override public byte highestDataDetail() { return this.highestDataDetail; }
-	@Override
-	public byte highestDataDetail() { return this.highestDataDetail; }
 	
-	@Override
+	@Override public int getEstimatedRemainingTaskCount() { return this.estimatedRemainingTaskCount; }
-	public int getEstimatedRemainingTaskCount() { return this.estimatedRemainingTaskCount; }
+	@Override public void setEstimatedRemainingTaskCount(int newEstimate) { this.estimatedRemainingTaskCount = newEstimate; }
-	@Override
-	public void setEstimatedRemainingTaskCount(int newEstimate) { this.estimatedRemainingTaskCount = newEstimate; }
 	
-	@Override
+	@Override public int getRetrievalEstimatedRemainingChunkCount() { return this.estimatedRemainingChunkCount; }
-	public int getRetrievalEstimatedRemainingChunkCount() { return this.estimatedRemainingChunkCount; }
+	@Override public void setRetrievalEstimatedRemainingChunkCount(int newEstimate) { this.estimatedRemainingChunkCount = newEstimate; }
-	@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
+			CompletableFuture<DataSourceRetrievalResult> genFuture = genTask.future;
-			if (genFuture == null)
-			{
-				// genFuture's shouldn't be null, but sometimes they are...
-				LOGGER.info("Null gen future: "+runningTaskGroup.group.pos);
-				return;
-			}
-			
 			
 			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;
@@ -621,21 +712,19 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		LodUtil.assertTrue(this.generatorClosingFuture != null);
 		
 		
-		LOGGER.info("Awaiting world generator thread pool termination...");
+		LOGGER.info("Shutting down world generator thread pool...");
-		try
+		
+		PriorityTaskPicker.Executor executor = ThreadPoolUtil.getWorldGenExecutor();
+		if (executor != null)
 		{
-			int waitTimeInSeconds = 3;
+			int queueSize = executor.getQueueSize();
-			AbstractExecutorService executor = ThreadPoolUtil.getWorldGenExecutor();
+			executor.clearQueue();
-			if (executor != null && !executor.awaitTermination(waitTimeInSeconds, TimeUnit.SECONDS))
+			LOGGER.info("World generator thread pool shutdown with [" + queueSize + "] incomplete tasks.");
-			{
-				LOGGER.warn("World generator thread pool shutdown didn't complete after [" + waitTimeInSeconds + "] seconds. Some world generator requests may still be running.");
-			}
-		}
-		catch (InterruptedException e)
-		{
-			LOGGER.warn("World generator thread pool shutdown interrupted! Ignoring child threads...", e);
 		}
 		
+		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);
@@ -654,59 +743,22 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 		LOGGER.info("Finished closing " + WorldGenerationQueue.class.getSimpleName());
 	}
 	
-	
+	///endregion shutdown
-	
-	//=======//
-	// debug //
-	//=======//
-	
-	@Override
-	public void debugRender(DebugRenderer renderer)
-	{
-		// 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 = (this.level.getMaxY() - this.level.getMinY());
-		int maxY = this.level.getMaxY() - (levelHeightRange / 2);
-		
-		
-		// blue - queued
-		this.waitingTasks.keySet().forEach((pos) -> 
-		{ 
-			renderer.renderBox(
-					new DebugRenderer.Box(pos, this.level.getMinY(), maxY, 0.05f, Color.blue)); 
-		});
-		
-		// red - in progress
-		this.inProgressGenTasksByLodPos.forEach((pos, t) -> 
-		{ 
-			renderer.renderBox(
-					new DebugRenderer.Box(pos, this.level.getMinY(), 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);
-	}
 	
 	
 	
 	//================//
 	// 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;
@@ -714,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,48 +20,33 @@
 package com.seibel.distanthorizons.core.generation.tasks;
 
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
-
+import org.jetbrains.annotations.Nullable;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.function.Consumer;
 
 /**
- * @author Leetom
+ * @see DataSourceRetrievalTask
- * @version 2022-11-25
  */
-@Deprecated // TODO look into how these are used and if they should continue to be used
+public class DataSourceRetrievalResult
-public final class WorldGenTaskGroup
 {
+	public final ERetrievalResultState state;
+	/** the position that was generated, will be null if nothing was generated */
 	public final long pos;
-	public byte dataDetail;
+	@Nullable
-	/** Only accessed by the generator polling thread */
+	public final FullDataSourceV2 dataSource;
-	public final LinkedList<WorldGenTask> worldGenTasks = new LinkedList<>();
 	
 	
 	
-	public WorldGenTaskGroup(long pos, byte dataDetail)
+	//==============//
+ 	// 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.dataDetail = dataDetail;
+		this.dataSource = dataSource;
 	}
 	
-	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/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
+ * @see DataSourceRetrievalResult
- * @version 2022-11-25
  */
-public final class WorldGenTask
+public final class DataSourceRetrievalTask
 {
 	public final long pos;
-	public final byte dataDetailLevel;
+	/** 
-	public final IWorldGenTaskTracker taskTracker;
+	 * Usually the same as {@link DataSourceRetrievalTask#pos}, but
-	public final CompletableFuture<WorldGenResult> future;
+	 * 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.requestDetailLevel = dataDetail;
-		this.future = future;
+		this.widthInChunks = BitShiftUtil.powerOfTwo(DhSectionPos.getDetailLevel(this.pos) - this.requestDetailLevel - 4); // minus 4 is equal to dividing by 16 to convert to chunk scale 
 	}
 	
 }