Up version number 2.1.3-dev -> 2.2.0

Removed methods were originally used to cull LODs if MC had loaded chunks, however this turned out to be more trouble than it was worth and caused more problems than it solved.

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -91,10 +91,28 @@ public interface IDhApiWorldGenerator extends Closeable, IDhApiOverrideable
 	default byte getMaxGenerationGranularity() { return (byte) (EDhApiDetailLevel.CHUNK.detailLevel + 2); }
 	
 	/**
-	 * @return true if the generator is unable to accept new generation requests.
+	 * Starting in API 3.0.0 DH now handles future queuing/management internally. <br><br>
+	 * 
+	 * Previous description: <br>
+	 * true if the generator is unable to accept new generation requests. <br>
+	 * 
 	 * @since API 1.0.0
+	 * @deprecated API 3.0.0
 	 */
-	boolean isBusy();
+	@Deprecated
+	default boolean isBusy() { return false; }
+	
+	/** 
+	 * Only used if {@link #getReturnType()} returns {@link EDhApiWorldGeneratorReturnType#API_CHUNKS}. <Br> 
+	 * If true DH will run additional validation on the {@link DhApiChunk}'s returned. <Br>
+	 * This should be disabled during release but should be enabled during development to help spot issues with your data format.
+	 * 
+	 * @see #getReturnType()
+	 * @see DhApiChunk
+	 * @see EDhApiWorldGeneratorReturnType#API_CHUNKS
+	 * @since API 3.0.0
+	 */
+	default boolean runApiChunkValidation() { return true; }
 	
 	
 	

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

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

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

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

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

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

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

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

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

@@ -34,7 +34,7 @@ public final class ModInfo
 	public static final String NAME = "DistantHorizons";
 	/** Human-readable version of NAME */
 	public static final String READABLE_NAME = "Distant Horizons";
-	public static final String VERSION = "2.1.3-a-dev";
+	public static final String VERSION = "2.2.0-a";
 	/** Returns true if the current build is an unstable developer build, false otherwise. */
 	public static boolean IS_DEV_BUILD = VERSION.toLowerCase().contains("dev");
 	

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

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

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

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

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

@@ -1,42 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser General Public License as published by
- *    the Free Software Foundation, version 3.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.core.api.external.methods.config.client;
-
-import com.seibel.distanthorizons.api.interfaces.config.IDhApiConfigValue;
-import com.seibel.distanthorizons.api.interfaces.config.client.IDhApiGpuBuffersConfig;
-import com.seibel.distanthorizons.api.objects.config.DhApiConfigValue;
-import com.seibel.distanthorizons.core.config.Config;
-import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod;
-
-public class DhApiGpuBuffersConfig implements IDhApiGpuBuffersConfig
-{
-	public static DhApiGpuBuffersConfig INSTANCE = new DhApiGpuBuffersConfig();
-	
-	private DhApiGpuBuffersConfig() { }
-	
-	
-	
-	public IDhApiConfigValue<EDhApiGpuUploadMethod> gpuUploadMethod()
-	{ return new DhApiConfigValue<>(Config.Client.Advanced.GpuBuffers.gpuUploadMethod); }
-	
-	public IDhApiConfigValue<Integer> gpuUploadPerMegabyteInMilliseconds()
-	{ return new DhApiConfigValue<>(Config.Client.Advanced.GpuBuffers.gpuUploadPerMegabyteInMilliseconds); }
-	
-}

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

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

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

@@ -497,7 +497,7 @@ public class ClientApi
 	{
 		// logging //
 		
-		this.sendChatMessagesNow();
+		this.sendQueuedChatMessages();
 		
 		IProfilerWrapper profiler = MC.getProfiler();
 		profiler.pop(); // get out of "terrain"
@@ -660,7 +660,7 @@ public class ClientApi
 		}
 	}
 	
-	private void sendChatMessagesNow()
+	private void sendQueuedChatMessages()
 	{
 		// dev build
 		if (ModInfo.IS_DEV_BUILD && !this.configOverrideReminderPrinted && MC.playerExists())
@@ -668,10 +668,12 @@ public class ClientApi
 			this.configOverrideReminderPrinted = true;
 			
 			// remind the user that this is a development build
-			MC.sendChatMessage("\u00A72" + "Distant Horizons: nightly/unstable build, version: [" + ModInfo.VERSION+"]." + "\u00A7r");
-			MC.sendChatMessage("Issues may occur with this version.");
-			MC.sendChatMessage("Here be dragons!");
-			MC.sendChatMessage("");
+			String message = 
+					// green text
+					"\u00A72" + "Distant Horizons: nightly/unstable build, version: [" + ModInfo.VERSION+"]." + "\u00A7r\n" +
+					"Issues may occur with this version.\n" +
+					"Here be dragons!\n";
+			MC.sendChatMessage(message);
 		}
 		
 		// memory
@@ -686,11 +688,13 @@ public class ClientApi
 			long maxMemoryInBytes = Runtime.getRuntime().maxMemory();
 			if (maxMemoryInBytes < minimumRecommendedMemoryInBytes)
 			{
-				MC.sendChatMessage("\u00A76" + "Distant Horizons: Low memory detected." + "\u00A7r");
-				MC.sendChatMessage("Stuttering or low FPS may occur.");
-				MC.sendChatMessage("Please increase Minecraft's available memory to 4 gigabytes.");
-				MC.sendChatMessage("This warning can be disabled in DH's config under Advanced -> Logging.");
-				MC.sendChatMessage("");
+				String message =
+						// orange text		
+						"\u00A76" + "Distant Horizons: Low memory detected." + "\u00A7r \n" +
+						"Stuttering or low FPS may occur. \n" +
+						"Please increase Minecraft's available memory to 4 gigabytes. \n" +
+						"This warning can be disabled in DH's config under Advanced -> Logging. \n";
+				MC.sendChatMessage(message);
 			}
 		}
 		

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

@@ -24,6 +24,7 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.generation.DhLightingEngine;
 import com.seibel.distanthorizons.core.level.IDhLevel;
+import com.seibel.distanthorizons.core.level.IDhServerLevel;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.logging.f3.F3Screen;
 import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
@@ -31,6 +32,7 @@ import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
 import com.seibel.distanthorizons.core.sql.dto.BeaconBeamDTO;
 import com.seibel.distanthorizons.core.sql.repo.AbstractDhRepo;
+import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.TimerUtil;
 import com.seibel.distanthorizons.core.util.objects.Pair;
 import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
@@ -46,6 +48,7 @@ import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /** Contains code and variables used by both {@link ClientApi} and {@link ServerApi} */
 public class SharedApi
@@ -139,23 +142,13 @@ public class SharedApi
 	public static boolean isChunkAtBlockPosAlreadyUpdating(int blockPosX, int blockPosZ)
 	{ return UPDATING_CHUNK_POS_SET.contains(new DhChunkPos(new DhBlockPos2D(blockPosX, blockPosZ))); }
 	
+	public static boolean isChunkAtChunkPosAlreadyUpdating(int chunkPosX, int chunkPosZ)
+	{ return UPDATING_CHUNK_POS_SET.contains(new DhChunkPos(chunkPosX, chunkPosZ)); }
+	
 	
 	/** handles both block place and break events */
 	public void chunkBlockChangedEvent(IChunkWrapper chunk, ILevelWrapper level) { this.applyChunkUpdate(chunk, level, true); }
-	
 	public void chunkLoadEvent(IChunkWrapper chunk, ILevelWrapper level) { this.applyChunkUpdate(chunk, level, false); }
-	public void chunkUnloadEvent(IChunkWrapper chunk, ILevelWrapper level) 
-	{
-		// temporarily disabled since this was originally incorrectly designated as "chunkSaveEvent"
-		// but didn't actually fire on chunk save
-		// and generally this is unnecessary and drastically reduces LOD building performance
-		// when traveling around the world
-		if (false)
-		{
-			this.applyChunkUpdate(chunk, level, false);
-		}
-	}
-	
 	
 	public void applyChunkUpdate(IChunkWrapper chunkWrapper, ILevelWrapper level, boolean updateNeighborChunks)
 	{
@@ -328,36 +321,50 @@ public class SharedApi
 					}
 					
 					
-					// Save or populate the chunk wrapper's lighting
-					// this is done so we don't have to worry about MC unloading the lighting data for this chunk
-					boolean onlyUseDhLighting = Config.Client.Advanced.LodBuilding.onlyUseDhLightingEngine.get();
-					if (!onlyUseDhLighting && chunkWrapper.isLightCorrect())
+					// chunk light baking is disabled since profiling revealed it used
+					// roughly the same amount of time as generating the lighting ourselves and
+					// was much more likely to have issues with corrupt (all black or all bright) chunks
+					boolean tryUsingMcLightingEngine = false;
+					if (tryUsingMcLightingEngine)
 					{
-						try
+						// Save or populate the chunk wrapper's lighting
+						// this is done so we don't have to worry about MC unloading the lighting data for this chunk
+						boolean chunkLightPopulated = false;
+						boolean onlyUseDhLighting = Config.Client.Advanced.LodBuilding.onlyUseDhLightingEngine.get();
+						if (!onlyUseDhLighting && chunkWrapper.isLightCorrect())
 						{
 							// If MC's lighting engine isn't thread safe this may cause the server thread to lag
-							chunkWrapper.bakeDhLightingUsingMcLightingEngine();
+							chunkLightPopulated = chunkWrapper.bakeDhLightingUsingMcLightingEngine(dhLevel.getLevelWrapper());
+							if (!chunkLightPopulated)
+							{
+								// clear any existing data to prevent partial or corrupt lighting
+								// when re-generating it
+								chunkWrapper.clearDhBlockLighting();
+								chunkWrapper.clearDhSkyLighting();
+							}
 						}
-						catch (IllegalStateException e)
+						
+						// something went wrong during the baking process so we have to generate the lighting ourselves
+						if (!chunkLightPopulated)
 						{
-							LOGGER.warn("Chunk light baking error: " + e.getMessage(), e);
+							DhLightingEngine.INSTANCE.lightChunk(chunkWrapper, nearbyChunkList, dhLevel.hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT);
 						}
 					}
 					else
 					{
-						// generate the chunk's lighting, using neighboring chunks if present
-						DhLightingEngine.INSTANCE.lightChunk(chunkWrapper, nearbyChunkList, dhLevel.hasSkyLight() ? 15 : 0);
+						DhLightingEngine.INSTANCE.lightChunk(chunkWrapper, nearbyChunkList, dhLevel.hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT);
 					}
 					
 					
 					
+					
+					
 					// get this chunk's active beacons
 					List<BeaconBeamDTO> beaconBeamList = chunkWrapper.getAllActiveBeacons(nearbyChunkList);
 					dhLevel.setBeaconBeamsForChunk(chunkWrapper.getChunkPos(), beaconBeamList);
 					
 					
-					dhLevel.updateChunkAsync(chunkWrapper);
-					dhLevel.setChunkHash(chunkWrapper.getChunkPos(), newChunkHash);
+					dhLevel.updateChunkAsync(chunkWrapper, newChunkHash);
 				}
 				catch (Exception e)
 				{

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

@@ -54,7 +54,6 @@ import java.util.List;
  * Otherwise, you will have issues where only some of the config entries will exist when your listener is created.
  *
  * @author coolGi
- * @version 2023-7-16
  */
 
 public class Config
@@ -126,7 +125,6 @@ public class Config
 			public static ConfigCategory multiplayer = new ConfigCategory.Builder().set(Multiplayer.class).build();
 			public static ConfigCategory lodBuilding = new ConfigCategory.Builder().set(LodBuilding.class).build();
 			public static ConfigCategory multiThreading = new ConfigCategory.Builder().set(MultiThreading.class).build();
-			public static ConfigCategory buffers = new ConfigCategory.Builder().set(GpuBuffers.class).build();
 			public static ConfigCategory autoUpdater = new ConfigCategory.Builder().set(AutoUpdater.class).build();
 			
 			public static ConfigCategory logging = new ConfigCategory.Builder().set(Logging.class).build();
@@ -179,6 +177,7 @@ public class Config
 									+ "Lowest Quality: " + EDhApiVerticalQuality.HEIGHT_MAP + "\n"
 									+ "Highest Quality: " + EDhApiVerticalQuality.EXTREME)
 							.setPerformance(EConfigEntryPerformance.VERY_HIGH)
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 					public static ConfigEntry<EDhApiHorizontalQuality> horizontalQuality = new ConfigEntry.Builder<EDhApiHorizontalQuality>()
@@ -200,6 +199,7 @@ public class Config
 									+ EDhApiTransparency.DISABLED + ": LODs will be opaque. \n"
 									+ "")
 							.setPerformance(EConfigEntryPerformance.MEDIUM)
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 					public static ConfigEntry<EDhApiBlocksToAvoid> blocksToIgnore = new ConfigEntry.Builder<EDhApiBlocksToAvoid>()
@@ -211,6 +211,7 @@ public class Config
 									+ EDhApiBlocksToAvoid.NON_COLLIDING + ": Only represent solid blocks in the LODs (tall grass, torches, etc. won't count for a LOD's height) \n"
 									+ "")
 							.setPerformance(EConfigEntryPerformance.NONE)
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 					public static ConfigEntry<Boolean> tintWithAvoidedBlocks = new ConfigEntry.Builder<Boolean>()
@@ -222,6 +223,7 @@ public class Config
 									+ "False: skipped blocks will not change color of surface below them. "
 									+ "")
 							.setPerformance(EConfigEntryPerformance.NONE)
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 					// TODO fixme
@@ -587,6 +589,7 @@ public class Config
 									+ "0 = black \n"
 									+ "1 = normal \n"
 									+ "2 = near white")
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 					public static ConfigEntry<Double> saturationMultiplier = new ConfigEntry.Builder<Double>() // TODO: Make this a float (the ClassicConfigGUI doesnt support floats)
@@ -597,6 +600,7 @@ public class Config
 									+ "0 = black and white \n"
 									+ "1 = normal \n"
 									+ "2 = very saturated")
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 					public static ConfigEntry<Boolean> enableCaveCulling = new ConfigEntry.Builder<Boolean>()
@@ -611,14 +615,15 @@ public class Config
 									+ "Additional Info: Currently this cull all faces \n"
 									+ " with skylight value of 0 in dimensions that \n"
 									+ " does not have a ceiling.")
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
-					@Deprecated
 					public static ConfigEntry<Integer> caveCullingHeight = new ConfigEntry.Builder<Integer>()
-							.setMinDefaultMax(-4096, 40, 4096)
-							.setAppearance(EConfigEntryAppearance.ONLY_IN_API)
+							.setMinDefaultMax(-4096, 60, 4096)
 							.comment(""
-									+ "At what Y value should cave culling start?")
+									+ "At what Y value should cave culling start? \n"
+									+ "Lower this value if you get walls for areas with 0 light.")
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 					public static ConfigEntry<Integer> earthCurveRatio = new ConfigEntry.Builder<Integer>()
@@ -656,6 +661,7 @@ public class Config
 									+ EDhApiLodShading.DISABLED + ": All LOD sides will be rendered with the same brightness. \n"
 									+ "")
 							.setPerformance(EConfigEntryPerformance.NONE)
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 					public static ConfigEntry<Boolean> disableFrustumCulling = new ConfigEntry.Builder<Boolean>()
@@ -690,6 +696,7 @@ public class Config
 									+ EDhApiGrassSideRendering.AS_DIRT + ": sides render entirely as dirt. \n"
 									+ "")
 							.setPerformance(EConfigEntryPerformance.NONE)
+							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 				}
@@ -773,8 +780,10 @@ public class Config
 								+ "")
 						.build();
 				
+				@Deprecated
 				public static ConfigEntry<Boolean> onlyUseDhLightingEngine = new ConfigEntry.Builder<Boolean>()
 						.set(false)
+						.setAppearance(EConfigEntryAppearance.ONLY_IN_API)
 						.comment(""
 								+ "If false LODs will be lit by Minecraft's lighting engine when possible \n"
 								+ "and fall back to the DH lighting engine only when necessary. \n"
@@ -1062,53 +1071,6 @@ public class Config
 				
 			}
 			
-			public static class GpuBuffers
-			{
-				public static ConfigEntry<EDhApiGpuUploadMethod> gpuUploadMethod = new ConfigEntry.Builder<EDhApiGpuUploadMethod>()
-						.set(EDhApiGpuUploadMethod.AUTO)
-						.comment(""
-								+ "What method should be used to upload geometry to the GPU? \n"
-								+ "\n"
-								+ EDhApiGpuUploadMethod.AUTO + ": Picks the best option based on the GPU you have. \n"
-								+ "\n"
-								+ EDhApiGpuUploadMethod.BUFFER_STORAGE + ": Default if OpenGL 4.5 is supported. \n"
-								+ "    Fast rendering, no stuttering. \n"
-								+ "\n"
-								+ EDhApiGpuUploadMethod.SUB_DATA + ": Backup option for NVIDIA. \n"
-								+ "    Fast rendering but may stutter when uploading. \n"
-								+ "\n"
-								+ EDhApiGpuUploadMethod.BUFFER_MAPPING + ": Slow rendering but won't stutter when uploading. \n"
-								+ "    Generally the best option for integrated GPUs. \n"
-								+ "    Default option for AMD/Intel if OpenGL 4.5 isn't supported. \n"
-								+ "    May end up storing buffers in System memory. \n"
-								+ "    Fast rendering if in GPU memory, slow if in system memory, \n"
-								+ "    but won't stutter when uploading.  \n"
-								+ "\n"
-								+ EDhApiGpuUploadMethod.DATA + ": Fast rendering but will stutter when uploading. \n"
-								+ "    Backup option for AMD/Intel. \n"
-								+ "    Fast rendering but may stutter when uploading. \n"
-								+ "\n"
-								+ "If you don't see any difference when changing these settings, \n"
-								+ "or the world looks corrupted: restart your game."
-								+ "")
-						.build();
-				
-				public static ConfigEntry<Integer> gpuUploadPerMegabyteInMilliseconds = new ConfigEntry.Builder<Integer>()
-						.setMinDefaultMax(0, 0, 50)
-						.comment(""
-								+ "How long should a buffer wait per Megabyte of data uploaded? \n"
-								+ "Helpful resource for frame times: https://fpstoms.com \n"
-								+ "\n"
-								+ "Longer times may reduce stuttering but will make LODs \n"
-								+ "transition and load slower. Change this to [0] for no timeout. \n"
-								+ "\n"
-								+ "NOTE:\n"
-								+ "Before changing this config, try changing the \"GPU Upload method\" first. \n"
-								+ "")
-						.build();
-				
-			}
-			
 			public static class AutoUpdater
 			{
 				public static ConfigEntry<Boolean> enableAutoUpdater = new ConfigEntry.Builder<Boolean>()
@@ -1140,63 +1102,63 @@ public class Config
 				// TODO add change all option
 				// TODO default to error chat and info file
 				public static ConfigEntry<EDhApiLoggerMode> logWorldGenEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
-						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
 						.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>()
-						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
+						.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>()
-						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
 						.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> logLodBuilderEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
-						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
 						.comment(""
 								+ "If enabled, the mod will log information about the LOD generation process. \n"
 								+ "This can be useful for debugging.")
 						.build();
 				
 				public static ConfigEntry<EDhApiLoggerMode> logRendererBufferEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
-						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
 						.comment(""
 								+ "If enabled, the mod will log information about the renderer buffer process. \n"
 								+ "This can be useful for debugging.")
 						.build();
 				
 				public static ConfigEntry<EDhApiLoggerMode> logRendererGLEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
-						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
 						.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> logFileReadWriteEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
-						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
 						.comment(""
 								+ "If enabled, the mod will log information about file read/write operations. \n"
 								+ "This can be useful for debugging.")
 						.build();
 				
 				public static ConfigEntry<EDhApiLoggerMode> logFileSubDimEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
-						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
 						.comment(""
 								+ "If enabled, the mod will log information about file sub-dimension operations. \n"
 								+ "This can be useful for debugging.")
 						.build();
 				
 				public static ConfigEntry<EDhApiLoggerMode> logNetworkEvent = new ConfigEntry.Builder<EDhApiLoggerMode>()
-						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT_AND_INFO_TO_FILE)
 						.comment(""
 								+ "If enabled, the mod will log information about network operations. \n"
 								+ "This can be useful for debugging.")
@@ -1217,6 +1179,13 @@ public class Config
 								+ "giving some basic information about how DH will function.")
 						.build();
 				
+				public static ConfigEntry<Boolean> showModCompatibilityWarningsOnStartup = new ConfigEntry.Builder<Boolean>()
+						.set(true)
+						.comment(""
+								+ "If enabled, a chat message will be displayed when a potentially problematic \n"
+								+ "mod is installed alongside DH.")
+						.build();
+				
 			}
 			
 			public static class Debugging
@@ -1303,22 +1272,38 @@ public class Config
 				public static ConfigEntry<Boolean> columnBuilderDebugEnable = new ConfigEntry.Builder<Boolean>()
 						.set(false)
 						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
-						.addListener(DebugColumnConfigEventHandler.INSTANCE)
+						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 						.build();
 				public static ConfigEntry<Integer> columnBuilderDebugDetailLevel = new ConfigEntry.Builder<Integer>()
 						.set((int) DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL)
 						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
-						.addListener(DebugColumnConfigEventHandler.INSTANCE)
+						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 						.build();
 				public static ConfigEntry<Integer> columnBuilderDebugXPos = new ConfigEntry.Builder<Integer>()
 						.set(0)
 						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
-						.addListener(DebugColumnConfigEventHandler.INSTANCE)
+						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 						.build();
 				public static ConfigEntry<Integer> columnBuilderDebugZPos = new ConfigEntry.Builder<Integer>()
 						.set(0)
 						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
-						.addListener(DebugColumnConfigEventHandler.INSTANCE)
+						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
+						.build();
+				
+				public static ConfigEntry<Integer> columnBuilderDebugXRow = new ConfigEntry.Builder<Integer>()
+						.set(-1)
+						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
+						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
+						.build();
+				public static ConfigEntry<Integer> columnBuilderDebugZRow = new ConfigEntry.Builder<Integer>()
+						.set(-1)
+						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
+						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
+						.build();
+				public static ConfigEntry<Integer> columnBuilderDebugColumnIndex = new ConfigEntry.Builder<Integer>()
+						.set(-1)
+						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
+						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 						.build();
 				
 				

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

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

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

@@ -168,7 +168,7 @@ public abstract class AbstractPresetConfigEventHandler<TPresetEnum extends Enum<
 		
 		if (newPreset != currentPreset)
 		{
-			this.getPresetConfigEntry().set(this.getCustomPresetEnum());
+			this.getPresetConfigEntry().set(newPreset);
 		}
 	}
 	

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

@@ -182,7 +182,7 @@ public class ColumnRenderSource implements IDataSource<IDhClientLevel>
 						EDhApiWorldGenerationStep worldGenStep = inputFullDataSource.getWorldGenStepAtRelativePos(x, z);
 						if (dataColumn != null && worldGenStep != EDhApiWorldGenerationStep.EMPTY)
 						{
-							FullDataToRenderDataTransformer.updateRenderDataViewWithFullDataColumn(
+							FullDataToRenderDataTransformer.updateOrReplaceRenderDataViewColumnWithFullDataColumn(
 									level, inputFullDataSource.mapping,
 									minBlockPos.x + x,
 									minBlockPos.z + z,
@@ -288,7 +288,7 @@ public class ColumnRenderSource implements IDataSource<IDhClientLevel>
 		String SUBDATA_DELIMITER = ",";
 		StringBuilder stringBuilder = new StringBuilder();
 		
-		stringBuilder.append(this.pos);
+		stringBuilder.append(DhSectionPos.toString(this.pos));
 		stringBuilder.append(LINE_DELIMITER);
 		
 		int size = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -20,7 +20,6 @@
 package com.seibel.distanthorizons.core.dataObjects.transformers;
 
 import com.seibel.distanthorizons.api.enums.config.EDhApiBlocksToAvoid;
-import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.FullDataPointIdMap;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
@@ -39,6 +38,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
+import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
 import org.apache.logging.log4j.Logger;
@@ -122,7 +122,12 @@ public class FullDataToRenderDataTransformer
 				
 				ColumnArrayView columnArrayView = columnSource.getVerticalDataPointView(x, z);
 				LongArrayList dataColumn = fullDataSource.get(x, z);
-				updateRenderDataViewWithFullDataColumn(level, fullDataSource.mapping, baseX + x, baseZ + z, columnArrayView, dataColumn);
+				
+				updateOrReplaceRenderDataViewColumnWithFullDataColumn(
+						level, fullDataSource.mapping, 
+						// bitshift is to account for LODs with a detail level greater than 0 so the block pos is correct
+						baseX + BitShiftUtil.pow(x,dataDetail), baseZ + BitShiftUtil.pow(z,dataDetail), 
+						columnArrayView, dataColumn);
 			}
 		}
 		
@@ -132,40 +137,48 @@ public class FullDataToRenderDataTransformer
 	}
 	
 	/** Updates the given {@link ColumnArrayView} to match the incoming Full data {@link LongArrayList} */
-	public static void updateRenderDataViewWithFullDataColumn(
+	public static void updateOrReplaceRenderDataViewColumnWithFullDataColumn(
 			IDhClientLevel level, 
 			FullDataPointIdMap fullDataMapping, int blockX, int blockZ, 
 			ColumnArrayView columnArrayView, 
 			LongArrayList fullDataColumn)
 	{
+		// we can't do anything if the full data is missing or empty
 		if (fullDataColumn == null || fullDataColumn.size() == 0)
 		{
 			return;
 		}
 		
-		int dataTotalLength = fullDataColumn.size();
-		if (dataTotalLength > columnArrayView.verticalSize())
+		int fullDataLength = fullDataColumn.size();
+		if (fullDataLength <= columnArrayView.verticalSize())
 		{
-			ColumnArrayView totalColumnData = new ColumnArrayView(new LongArrayList(new long[dataTotalLength]), dataTotalLength, 0, dataTotalLength);
-			iterateAndConvert(level, fullDataMapping, blockX, blockZ, totalColumnData, fullDataColumn);
-			columnArrayView.changeVerticalSizeFrom(totalColumnData);
+			// Directly use the arrayView since it fits.
+			setRenderColumnView(level, fullDataMapping, blockX, blockZ, columnArrayView, fullDataColumn);
 		}
 		else
 		{
-			iterateAndConvert(level, fullDataMapping, blockX, blockZ, columnArrayView, fullDataColumn); //Directly use the arrayView since it fits.
+			// expand the ColumnArrayView to fit the new larger max vertical size
+			ColumnArrayView newColumnArrayView = new ColumnArrayView(new LongArrayList(new long[fullDataLength]), fullDataLength, 0, fullDataLength);
+			setRenderColumnView(level, fullDataMapping, blockX, blockZ, newColumnArrayView, fullDataColumn);
+			columnArrayView.changeVerticalSizeFrom(newColumnArrayView);
 		}
 	}
-	private static void iterateAndConvert(
+	private static void setRenderColumnView(
 			IDhClientLevel level, FullDataPointIdMap fullDataMapping,
 			int blockX, int blockZ,
 			ColumnArrayView renderColumnData, LongArrayList fullColumnData)
 	{
+		//===============//
+		// config values //
+		//===============//
+		
 		boolean ignoreNonCollidingBlocks = (Config.Client.Advanced.Graphics.Quality.blocksToIgnore.get() == EDhApiBlocksToAvoid.NON_COLLIDING);
 		boolean colorBelowWithAvoidedBlocks = Config.Client.Advanced.Graphics.Quality.tintWithAvoidedBlocks.get();
 		
 		HashSet<IBlockStateWrapper> blockStatesToIgnore = WRAPPER_FACTORY.getRendererIgnoredBlocks(level.getLevelWrapper());
 		HashSet<IBlockStateWrapper> caveBlockStatesToIgnore = WRAPPER_FACTORY.getRendererIgnoredCaveBlocks(level.getLevelWrapper());
 		
+		int caveCullingMaxY = Config.Client.Advanced.Graphics.AdvancedGraphics.caveCullingHeight.get() - level.getMinY();
 		boolean caveCullingEnabled = 
 			Config.Client.Advanced.Graphics.AdvancedGraphics.enableCaveCulling.get()
 			&& (
@@ -176,30 +189,36 @@ public class FullDataToRenderDataTransformer
 				&& !level.getLevelWrapper().getDimensionType().isTheEnd()
 			);
 		
-		boolean isVoid = true;
+		boolean isColumnVoid = true;
 		
 		int colorToApplyToNextBlock = -1;
 		int lastColor = 0;
-		int lastBottom = -10000;
+		int lastBottom = -10_000;
 		
 		int skylightToApplyToNextBlock = -1;
 		int blocklightToApplyToNextBlock = -1;
-		int columnOffset = 0;
+		int renderDataIndex = 0;
 		
-		IBiomeWrapper biome = null;
-		IBlockStateWrapper block = null;
 		
 		
+		//==================================//
+		// convert full data to render data //
+		//==================================//
+		
 		// goes from the top down
-		for (int i = 0; i < fullColumnData.size(); i++)
+		for (int fullDataIndex = 0; fullDataIndex < fullColumnData.size(); fullDataIndex++)
 		{
-			long fullData = fullColumnData.getLong(i);
+			long fullData = fullColumnData.getLong(fullDataIndex);
+			
 			int bottomY = FullDataPointUtil.getBottomY(fullData);
 			int blockHeight = FullDataPointUtil.getHeight(fullData);
+			int topY = bottomY + blockHeight;
 			int id = FullDataPointUtil.getId(fullData);
 			int blockLight = FullDataPointUtil.getBlockLight(fullData);
 			int skyLight = FullDataPointUtil.getSkyLight(fullData);
 			
+			IBiomeWrapper biome;
+			IBlockStateWrapper block;
 			try
 			{
 				biome = fullDataMapping.getBiomeWrapper(id);
@@ -207,7 +226,6 @@ public class FullDataToRenderDataTransformer
 			}
 			catch (IndexOutOfBoundsException e)
 			{
-				// FIXME sometimes the data map has a length of 0
 				if (!brokenPos.contains(fullDataMapping.getPos()))
 				{
 					brokenPos.add(fullDataMapping.getPos());
@@ -219,11 +237,12 @@ public class FullDataToRenderDataTransformer
 							"Further errors for this position won't be logged.");
 				}
 				
-				// skip rendering broken data
+				// don't render broken data
 				continue;
 			}
 			
 			
+			
 			//====================//
 			// ignored block and  //
 			// cave culling check //
@@ -236,23 +255,25 @@ public class FullDataToRenderDataTransformer
 				if (caveCullingEnabled
 					// assume this data point is underground if it has no sky-light
 					&& skyLight == LodUtil.MIN_MC_LIGHT	
+					// ignore caves above a certain height to prevent floating islands from having walls underneath them
+					&& topY < caveCullingMaxY
 					// cave culling shouldn't happen when at the top of the world
-					&& columnOffset != 0
+					&& renderDataIndex != 0 && fullDataIndex != 0
 					// cave culling can't happen when at the bottom of the world
-					&& columnOffset != 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(i+1);
+					long nextFullData = fullColumnData.getLong(fullDataIndex+1);
 					int nextSkyLight = FullDataPointUtil.getSkyLight(nextFullData);
 					
 					if (nextSkyLight == LodUtil.MIN_MC_LIGHT
 							&& ColorUtil.getAlpha(lastColor) == 255)
 					{
 						// replace the previous block with new bottom
-						long columnData = renderColumnData.get(columnOffset - 1);
+						long columnData = renderColumnData.get(renderDataIndex - 1);
 						columnData = RenderDataPointUtil.setYMin(columnData, bottomY);
-						renderColumnData.set(columnOffset - 1, columnData);
+						renderColumnData.set(renderDataIndex - 1, columnData);
 					}
 					
 					continue;
@@ -272,27 +293,28 @@ public class FullDataToRenderDataTransformer
 			}
 			
 			
-			//===================//
-			// solid block check //
-			//===================//
 			
-			if (ignoreNonCollidingBlocks && !block.isSolid() && !block.isLiquid() && block.getOpacity() != LodUtil.BLOCK_FULLY_OPAQUE)
+			//=======================//
+			// non-solid block check //
+			//=======================//
+			
+			if (ignoreNonCollidingBlocks 
+				&& !block.isSolid() && !block.isLiquid() && block.getOpacity() != LodUtil.BLOCK_FULLY_OPAQUE)
 			{
 				if (colorBelowWithAvoidedBlocks)
 				{
 					int tempColor = level.computeBaseColor(new DhBlockPos(blockX, bottomY + level.getMinY(), blockZ), biome, block);
 					// don't transfer the color when alpha is 0
+					// this prevents issues if grass is transparent
 					if (ColorUtil.getAlpha(tempColor) != 0)
 					{
-						// don't transfer alpha if for some reason grass is semi transparent
 						colorToApplyToNextBlock = ColorUtil.setAlpha(tempColor,255);
-						
 						skylightToApplyToNextBlock = skyLight;
 						blocklightToApplyToNextBlock = blockLight;
 					}
 				}
 				
-				// don't add this block
+				// skip this non-colliding block
 				continue;
 			}
 			
@@ -312,31 +334,36 @@ public class FullDataToRenderDataTransformer
 				blockLight = blocklightToApplyToNextBlock;
 			}
 			
-			//check if they share a top-bottom face and if they have same color
-			if (color == lastColor && bottomY + blockHeight == lastBottom  && columnOffset > 0)
+			
+			
+			//=============================//
+			// merge same-colored adjacent //
+			//=============================//
+			
+			// check if they share a top-bottom face and if they have same color
+			if (color == lastColor && bottomY + blockHeight == lastBottom  && renderDataIndex > 0)
 			{
 				//replace the previous block with new bottom
-				long columnData = renderColumnData.get(columnOffset - 1);
+				long columnData = renderColumnData.get(renderDataIndex - 1);
 				columnData = RenderDataPointUtil.setYMin(columnData, bottomY);
-				renderColumnData.set(columnOffset - 1, columnData);
+				renderColumnData.set(renderDataIndex - 1, columnData);
 			}
 			else
 			{
 				// add the block
-				isVoid = false;
+				isColumnVoid = false;
 				long columnData = RenderDataPointUtil.createDataPoint(bottomY + blockHeight, bottomY, color, skyLight, blockLight, block.getMaterialId());
-				renderColumnData.set(columnOffset, columnData);
-				columnOffset++;
+				renderColumnData.set(renderDataIndex, columnData);
+				renderDataIndex++;
 			}
 			lastBottom = bottomY;
 			lastColor = color;
-			
 		}
 		
 		
-		if (isVoid)
+		if (isColumnVoid)
 		{
-			renderColumnData.set(0, RenderDataPointUtil.createVoidDataPoint());
+			renderColumnData.set(0, RenderDataPointUtil.EMPTY_DATA);
 		}
 	}
 	

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

@@ -19,6 +19,7 @@
 
 package com.seibel.distanthorizons.core.dataObjects.transformers;
 
+import java.util.Collections;
 import java.util.List;
 
 import com.seibel.distanthorizons.api.enums.config.EDhApiWorldCompressionMode;
@@ -34,6 +35,7 @@ import com.seibel.distanthorizons.core.pos.DhBlockPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.util.FullDataPointUtil;
 import com.seibel.distanthorizons.core.util.LodUtil;
+import com.seibel.distanthorizons.core.util.RenderDataPointUtil;
 import com.seibel.distanthorizons.core.util.objects.DataCorruptedException;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
@@ -152,8 +154,8 @@ public class LodDataBuilder
 					else
 					{
 						//we are at the height limit. There are no torches here, and sky is not obscured.
-						blockLight = 0;
-						skyLight = 15;
+						blockLight = LodUtil.MIN_MC_LIGHT;
+						skyLight = LodUtil.MAX_MC_LIGHT;
 					}
 					
 					
@@ -295,7 +297,7 @@ public class LodDataBuilder
 	
 	
 	/** @throws ClassCastException if an API user returns the wrong object type(s) */
-	public static FullDataSourceV2 createFromApiChunkData(DhApiChunk apiChunk) throws ClassCastException, DataCorruptedException
+	public static FullDataSourceV2 createFromApiChunkData(DhApiChunk apiChunk, boolean runAdditionalValidation) throws ClassCastException, DataCorruptedException, IllegalArgumentException
 	{
 		// get the section position
 		int sectionPosX = getXOrZSectionPosFromChunkPos(apiChunk.chunkPosX);
@@ -312,6 +314,10 @@ public class LodDataBuilder
 			for (int relBlockX = 0; relBlockX < LodUtil.CHUNK_WIDTH; relBlockX++)
 			{
 				List<DhApiTerrainDataPoint> columnDataPoints = apiChunk.getDataPoints(relBlockX, relBlockZ);
+				if (runAdditionalValidation)
+				{
+					validateOrThrowDataColumn(columnDataPoints);
+				}
 				
 				
 				// this null check does 2 nice things at the same time:
@@ -320,6 +326,8 @@ public class LodDataBuilder
 				// AND the below loop won't run.
 				int size = (columnDataPoints != null) ? columnDataPoints.size() : 0;
 				
+				// TODO make missing air LODs
+				// TODO merge duplicate datapoints
 				LongArrayList packedDataPoints = new LongArrayList(new long[size]);
 				for (int index = 0; index < size; index++)
 				{
@@ -350,6 +358,75 @@ public class LodDataBuilder
 		}
 		return dataSource;
 	}
+	private static void validateOrThrowDataColumn(List<DhApiTerrainDataPoint> dataPoints) throws IllegalArgumentException
+	{
+		// order doesn't need to be checked if there is 0 or 1 items
+		if (dataPoints.size() > 1)
+		{
+			// DH expects datapoints to be in a top-down order
+			DhApiTerrainDataPoint first = dataPoints.get(0);
+			DhApiTerrainDataPoint last = dataPoints.get(dataPoints.size() - 1);
+			if (first.bottomYBlockPos < last.bottomYBlockPos)
+			{
+				// flip the array if it's in bottom-up order
+				Collections.reverse(dataPoints);
+			}
+			
+		}
+		
+		
+		
+		// check that each datapoint is valid
+		int lastBottomYPos = Integer.MIN_VALUE;
+		for (int i = 0; i < dataPoints.size(); i++) // standard for-loop used instead of an enhanced for-loop to slightly reduce GC overhead due to iterator allocation
+		{
+			DhApiTerrainDataPoint dataPoint = dataPoints.get(i);
+			
+			if (dataPoint == null)
+			{
+				throw new IllegalArgumentException("Datapoint: ["+i+"] is null DhApiTerrainDataPoints are not allowed. If you want to represent empty terrain, please use AIR.");
+			}
+			
+			if (dataPoint.detailLevel != 0)
+			{
+				throw new IllegalArgumentException("Datapoint: ["+i+"] has the wrong detail level ["+dataPoint.detailLevel+"], all data points must be block sized; IE their detail level must be [0].");
+			}
+			
+			
+			
+			int bottomYPos = dataPoint.bottomYBlockPos;
+			int topYPos = dataPoint.topYBlockPos;
+			int height = (dataPoint.topYBlockPos - dataPoint.bottomYBlockPos);
+			
+			// is the datapoint right side up?
+			if (bottomYPos > topYPos)
+			{
+				throw new IllegalArgumentException("Datapoint: ["+i+"] is upside down. Top Pos: ["+topYPos+"], bottom pos: ["+bottomYPos+"].");
+			}
+			// valid height?
+			if (height <= 0 || height >= RenderDataPointUtil.MAX_WORLD_Y_SIZE)
+			{
+				throw new IllegalArgumentException("Datapoint: ["+i+"] has invalid height. Height must be in the range [1 - "+RenderDataPointUtil.MAX_WORLD_Y_SIZE+"] (inclusive).");
+			}
+			
+			// is this datapoint overlapping the last one?
+			if (lastBottomYPos > topYPos)
+			{
+				throw new IllegalArgumentException("DhApiTerrainDataPoint ["+i+"] is overlapping with the last datapoint, this top Y: ["+topYPos+"], lastBottomYPos: ["+lastBottomYPos+"].");
+			}
+			// is there a gap between the last datapoint?
+			if (topYPos != lastBottomYPos
+				&& lastBottomYPos != Integer.MIN_VALUE)
+			{
+				throw new IllegalArgumentException("DhApiTerrainDataPoint ["+i+"] has a gap between it and index ["+(i-1)+"]. Empty spaces should be filled by air, otherwise DH's downsampling won't calculate lighting correctly.");
+			}
+			
+			
+			lastBottomYPos = bottomYPos; 
+		}
+		
+	}
+	
 	
 	
 	

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

@@ -26,12 +26,12 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.api.enums.config.EDhApiServerFolderNameMode;
 import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel;
 import com.seibel.distanthorizons.core.util.objects.ParsedIp;
-import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IDimensionTypeWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
+import com.seibel.distanthorizons.coreapi.util.StringUtil;
 
 import java.io.File;
 import java.util.*;
@@ -138,7 +138,7 @@ public class ClientOnlySaveStructure extends AbstractSaveStructure
 		{
 			// use the first existing sub-dimension
 			String folderName = folders.get(0).getName();
-			LOGGER.info("Default Sub Dimension set to: [" + LodUtil.shortenString(folderName, 8) + "...]");
+			LOGGER.info("Default Sub Dimension set to: [" + StringUtil.shortenString(folderName, 8) + "...]");
 			return folders.get(0);
 		}
 		else

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

@@ -40,6 +40,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftCli
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
+import com.seibel.distanthorizons.coreapi.util.StringUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import org.apache.logging.log4j.LogManager;
 
@@ -92,7 +93,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		if (potentialLevelFolders.size() == 0)
 		{
 			String newId = UUID.randomUUID().toString();
-			LOGGER.info("No potential level files found. Creating a new sub dimension with the ID ["+LodUtil.shortenString(newId, 8)+"]...");
+			LOGGER.info("No potential level files found. Creating a new sub dimension with the ID ["+ StringUtil.shortenString(newId, 8)+"]...");
 			this.foundLevelFile = this.CreateSubDimFolder(newId);
 		}
 	}
@@ -207,7 +208,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		SubDimCompare mostSimilarSubDim = null;
 		for (File testLevelFolder : this.potentialLevelFolders)
 		{
-			LOGGER.info("Testing level folder: [" + LodUtil.shortenString(testLevelFolder.getName(), 8) + "]");
+			LOGGER.info("Testing level folder: [" + StringUtil.shortenString(testLevelFolder.getName(), 8) + "]");
 			
 			FullDataSourceV2 testFullDataSource = null;
 			try
@@ -328,8 +329,8 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 				}
 				
 				
-				String subDimShortName = LodUtil.shortenString(testLevelFolder.getName(), 8); // variables are separated out for easier debugging
-				String equalPercent = LodUtil.shortenString(mostSimilarSubDim.getPercentEqual()+"", 5);
+				String subDimShortName = StringUtil.shortenString(testLevelFolder.getName(), 8); // variables are separated out for easier debugging
+				String equalPercent = StringUtil.shortenString(mostSimilarSubDim.getPercentEqual()+"", 5);
 				LOGGER.info("Sub dimension ["+subDimShortName+"...] is current dimension probability: "+equalPercent+" ("+equalDataPoints+"/"+totalDataPointCount+")");
 			}
 			catch (Exception e)
@@ -359,7 +360,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		{
 			// we found a sub dim folder that is similar, use it
 			
-			LOGGER.info("Sub Dimension set to: [" + LodUtil.shortenString(mostSimilarSubDim.folder.getName(), 8) + "...] with an equality of [" + mostSimilarSubDim.getPercentEqual() + "]");
+			LOGGER.info("Sub Dimension set to: [" + StringUtil.shortenString(mostSimilarSubDim.folder.getName(), 8) + "...] with an equality of [" + mostSimilarSubDim.getPercentEqual() + "]");
 			return mostSimilarSubDim.folder;
 		}
 		else
@@ -369,7 +370,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 			String newId = UUID.randomUUID().toString();
 			
 			double highestEqualityPercent = mostSimilarSubDim != null ? mostSimilarSubDim.getPercentEqual() : 0;
-			String message = "No suitable sub dimension found. The highest equality was [" + LodUtil.shortenString(highestEqualityPercent + "", 5) + "]. Creating a new sub dimension with ID: " + LodUtil.shortenString(newId, 8) + "...";
+			String message = "No suitable sub dimension found. The highest equality was [" + StringUtil.shortenString(highestEqualityPercent + "", 5) + "]. Creating a new sub dimension with ID: " + StringUtil.shortenString(newId, 8) + "...";
 			LOGGER.info(message);
 			
 			File folder = this.CreateSubDimFolder(newId);

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

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

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

@@ -147,7 +147,7 @@ public class DhLightingEngine
 						{
 							for (int relZ = 0; relZ < LodUtil.CHUNK_WIDTH; relZ++)
 							{
-								// set each pos' sky light all the way down until a opaque block is hit
+								// set each pos' sky light all the way down until an opaque block is hit
 								for (int y = maxY; y >= minY; y--)
 								{
 									IBlockStateWrapper block = chunk.getBlockState(relX, y, relZ);

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

@@ -55,6 +55,16 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	private static final IWrapperFactory WRAPPER_FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
 	
+	/**
+	 * Defines how many tasks can be queued per thread. <br><br>
+	 *
+	 * TODO the multiplier here should change dynamically based on how fast the generator is vs the queuing thread,
+	 *  if this is too high it may cause issues when moving,
+	 *  but if it is too low the generator threads won't have enough tasks to work on
+	 */
+	private static final int MAX_QUEUED_TASKS_PER_THREAD = 3;
+	
+	
 	private final IDhApiWorldGenerator generator;
 	
 	/** contains the positions that need to be generated */
@@ -206,7 +216,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 					
 					// queue generation tasks until the generator is full, or there are no more tasks to generate
 					boolean taskStarted = true;
-					while (!this.generator.isBusy() && taskStarted)
+					while (!this.isGeneratorBusy() && taskStarted)
 					{
 						taskStarted = this.startNextWorldGenTask(this.generationTargetPos);
 						if (!taskStarted)
@@ -233,6 +243,19 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 			}
 		});
 	}
+	public boolean isGeneratorBusy()
+	{
+		ThreadPoolExecutor executor = ThreadPoolUtil.getWorldGenExecutor();
+		if (executor == null)
+		{
+			// shouldn't happen, but just in case, don't queue more tasks
+			return true;
+		}
+		
+		int worldGenThreadCount = Math.max(Config.Client.Advanced.MultiThreading.numberOfWorldGenerationThreads.get(), 1);
+		int maxWorldGenTaskCount = worldGenThreadCount * MAX_QUEUED_TASKS_PER_THREAD;
+		return executor.getQueue().size() > maxWorldGenTaskCount;
+	}
 	
 	/**
 	 * @param targetPos the position to center the generation around
@@ -469,10 +492,10 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 					{
 						try
 						{
-							FullDataSourceV2 dataSource = LodDataBuilder.createFromApiChunkData(dataPoints);
+							FullDataSourceV2 dataSource = LodDataBuilder.createFromApiChunkData(dataPoints, this.generator.runApiChunkValidation());
 							chunkDataConsumer.accept(dataSource);
 						}
-						catch (DataCorruptedException e)
+						catch (DataCorruptedException | IllegalArgumentException e)
 						{
 							LOGGER.error("World generator returned a corrupt chunk. Error: [" + e.getMessage() + "]. World generator disabled.", e);
 							Config.Client.Advanced.WorldGenerator.enableDistantGeneration.set(false);

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

@@ -19,28 +19,19 @@
 
 package com.seibel.distanthorizons.core.level;
 
-import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup;
 import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiChunkModifiedEvent;
-import com.seibel.distanthorizons.api.objects.math.DhApiVec3f;
-import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox;
-import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading;
-import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
-import com.seibel.distanthorizons.core.dataObjects.transformers.ChunkToLodBuilder;
 import com.seibel.distanthorizons.core.file.fullDatafile.DelayedFullDataSourceSaveCache;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.renderer.generic.BeaconRenderHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.CloudRenderHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
-import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory;
 import com.seibel.distanthorizons.core.sql.dto.BeaconBeamDTO;
 import com.seibel.distanthorizons.core.sql.dto.ChunkHashDTO;
 import com.seibel.distanthorizons.core.sql.repo.BeaconBeamRepo;
 import com.seibel.distanthorizons.core.sql.repo.ChunkHashRepo;
-import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector;
 import org.apache.logging.log4j.Logger;
@@ -59,8 +50,6 @@ public abstract class AbstractDhLevel implements IDhLevel
 {
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	
-	public final ChunkToLodBuilder chunkToLodBuilder;
-	
 	/** if this is null then the other handler is probably null too, but just in case */
 	@Nullable
 	public ChunkHashRepo chunkHashRepo;
@@ -71,6 +60,7 @@ public abstract class AbstractDhLevel implements IDhLevel
 	protected final DelayedFullDataSourceSaveCache delayedFullDataSourceSaveCache = new DelayedFullDataSourceSaveCache(this::onDataSourceSave, 2_000);
 	/** contains the {@link DhChunkPos} for each {@link DhSectionPos} that are queued to save via {@link AbstractDhLevel#delayedFullDataSourceSaveCache} */
 	protected final ConcurrentHashMap<Long, HashSet<DhChunkPos>> updatedChunkPosSetBySectionPos = new ConcurrentHashMap<>();
+	protected final ConcurrentHashMap<DhChunkPos, Integer> updatedChunkHashesByChunkPos = new ConcurrentHashMap<>();
 	
 	/** Will be null if clouds shouldn't be rendered for this level. */
 	@Nullable
@@ -83,10 +73,7 @@ public abstract class AbstractDhLevel implements IDhLevel
 	// constructor //
 	//=============//
 	
-	protected AbstractDhLevel() 
-	{ 
-		this.chunkToLodBuilder = new ChunkToLodBuilder();
-	}
+	protected AbstractDhLevel() {  }
 	
 	/** 
 	 * Creating the repos requires access to the level file, which isn't
@@ -152,7 +139,7 @@ public abstract class AbstractDhLevel implements IDhLevel
 	public int getUnsavedDataSourceCount() { return this.delayedFullDataSourceSaveCache.getUnsavedCount(); }
 	
 	@Override
-	public void updateChunkAsync(IChunkWrapper chunkWrapper)
+	public void updateChunkAsync(IChunkWrapper chunkWrapper, int chunkHash)
 	{
 		FullDataSourceV2 dataSource = FullDataSourceV2.createFromChunk(chunkWrapper);
 		if (dataSource == null)
@@ -171,6 +158,7 @@ public abstract class AbstractDhLevel implements IDhLevel
 			chunkPosSet.add(chunkWrapper.getChunkPos());
 			return chunkPosSet;
 		});
+		this.updatedChunkHashesByChunkPos.put(chunkWrapper.getChunkPos(), chunkHash);
 		
 		// batch updates to reduce overhead when flying around or breaking/placing a lot of blocks in an area
 		this.delayedFullDataSourceSaveCache.queueDataSourceForUpdateAndSave(dataSource);
@@ -185,6 +173,13 @@ public abstract class AbstractDhLevel implements IDhLevel
 			{
 				for (DhChunkPos chunkPos : updatedChunkPosSet)
 				{
+					// save after the data source has been updated to prevent saving the hash without the associated datasource
+					Integer chunkHash = this.updatedChunkHashesByChunkPos.remove(chunkPos);
+					if (this.chunkHashRepo != null && chunkHash != null)
+					{
+						this.chunkHashRepo.save(new ChunkHashDTO(chunkPos, chunkHash));
+					}
+					
 					ApiEventInjector.INSTANCE.fireAllEvents(
 							DhApiChunkModifiedEvent.class,
 							new DhApiChunkModifiedEvent.EventParam(this.getLevelWrapper(), chunkPos.x, chunkPos.z));
@@ -212,14 +207,6 @@ public abstract class AbstractDhLevel implements IDhLevel
 		ChunkHashDTO dto = this.chunkHashRepo.getByKey(pos);
 		return (dto != null) ? dto.chunkHash : 0;
 	}
-	@Override
-	public void setChunkHash(DhChunkPos pos, int chunkHash)
-	{
-		if (this.chunkHashRepo != null)
-		{
-			this.chunkHashRepo.save(new ChunkHashDTO(pos, chunkHash));
-		}
-	}
 	
 	
 	
@@ -262,8 +249,6 @@ public abstract class AbstractDhLevel implements IDhLevel
 	@Override
 	public void close() 
 	{ 
-		this.chunkToLodBuilder.close();
-		
 		if (this.chunkHashRepo != null)
 		{
 			this.chunkHashRepo.close();

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

@@ -258,6 +258,8 @@ public class ClientLevelModule implements Closeable, AbstractDataSourceHandler.I
 	
 	public void clearRenderCache()
 	{
+		this.clientLevel.getClientLevelWrapper().clearBlockColorCache();
+		
 		ClientRenderState ClientRenderState = this.ClientRenderStateRef.get();
 		if (ClientRenderState != null && ClientRenderState.quadtree != null)
 		{

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

@@ -86,7 +86,6 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	{
 		try
 		{
-			this.chunkToLodBuilder.tick();
 			this.clientside.clientTick();
 		}
 		catch (Exception e)
@@ -110,7 +109,7 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	//================//
 	
 	@Override
-	public int computeBaseColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper block) { return this.levelWrapper.computeBaseColor(pos, biome, block); }
+	public int computeBaseColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper block) { return this.levelWrapper.getBlockColor(pos, biome, block); }
 	
 	@Override
 	public IClientLevelWrapper getClientLevelWrapper() { return this.levelWrapper; }

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

@@ -95,7 +95,7 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 	{ this.clientside.renderDeferred(renderEventParam, profiler); }
 	
 	@Override
-	public void serverTick() { this.chunkToLodBuilder.tick(); }
+	public void serverTick() {  }
 	
 	@Override
 	public void doWorldGen()
@@ -146,7 +146,7 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 		}
 		else
 		{
-			return clientLevel.computeBaseColor(pos, biome, block);
+			return clientLevel.getBlockColor(pos, biome, block);
 		}
 	}
 	
@@ -154,10 +154,7 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 	public IClientLevelWrapper getClientLevelWrapper() { return MC_CLIENT.getWrappedClientLevel(); }
 	
 	@Override
-	public void clearRenderCache()
-	{
-		clientside.clearRenderCache();
-	}
+	public void clearRenderCache() { this.clientside.clearRenderCache(); }
 	
 	@Override
 	public IServerLevelWrapper getServerLevelWrapper() { return serverLevelWrapper; }

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

@@ -65,7 +65,7 @@ public class DhServerLevel extends AbstractDhLevel implements IDhServerLevel
 	// methods //
 	//=========//
 	
-	public void serverTick() { this.chunkToLodBuilder.tick(); }
+	public void serverTick() {  }
 	
 	@Override
 	public CompletableFuture<Void> updateDataSourcesAsync(FullDataSourceV2 data) { return this.getFullDataProvider().updateDataSourceAsync(data); }

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

@@ -45,8 +45,7 @@ public interface IDhLevel extends AutoCloseable
 	
 	/** @return 0 if no hash is known */
 	int getChunkHash(DhChunkPos pos);
-	void setChunkHash(DhChunkPos pos, int chunkHash);
-	void updateChunkAsync(IChunkWrapper chunk);
+	void updateChunkAsync(IChunkWrapper chunk, int newChunkHash);
 	
 	void loadBeaconBeamsInPos(long pos);
 	void setBeaconBeamsForChunk(DhChunkPos chunkPos, List<BeaconBeamDTO> beamList);

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

@@ -72,6 +72,8 @@ public class F3Screen
 		ThreadPoolExecutor worldGenPool = ThreadPoolUtil.getWorldGenExecutor();
 		ThreadPoolExecutor fileHandlerPool = ThreadPoolUtil.getFileHandlerExecutor();
 		ThreadPoolExecutor updatePool = ThreadPoolUtil.getUpdatePropagatorExecutor();
+		ThreadPoolExecutor bufferBuilderPool = ThreadPoolUtil.getBufferBuilderExecutor();
+		ThreadPoolExecutor bufferUploaderPool = ThreadPoolUtil.getBufferUploaderExecutor();
 		
 		AbstractDhWorld world = SharedApi.getAbstractDhWorld();
 		Iterable<? extends IDhLevel> levelIterator = world.getAllLoadedLevels();
@@ -84,6 +86,8 @@ public class F3Screen
 		messageList.add(getThreadPoolStatString("World Gen", worldGenPool));//"World Gen Tasks: 40/5304, (in progress: 7)");
 		messageList.add(getThreadPoolStatString("File Handler", fileHandlerPool));
 		messageList.add(getThreadPoolStatString("Update Propagator", updatePool));
+		messageList.add(getThreadPoolStatString("Buffer Builder", bufferBuilderPool));
+		messageList.add(getThreadPoolStatString("Buffer Uploader", bufferUploaderPool));
 		messageList.add("");
 		// chunk updates
 		messageList.add(SharedApi.INSTANCE.getDebugMenuString());

core/src/main/java/com/seibel/distanthorizons/core/pos/DhSectionPos.java

@@ -34,11 +34,11 @@ import java.util.function.LongConsumer;
  * For the specifics of how they compare can be viewed in the constants {@link #SECTION_BLOCK_DETAIL_LEVEL},
  * {@link #SECTION_CHUNK_DETAIL_LEVEL}, and {@link #SECTION_REGION_DETAIL_LEVEL}).<br><br>
  *
- * <strong>Why does the smallest render section represent 2x2 MC chunks (section detail level 6)? </strong> <br>
+ * <strong>Why does the smallest render section represent 4x4 MC chunks (section detail level 6)? </strong> <br>
  * A section defines what unit the quad tree works in, because of that we don't want that unit to be too big or too small. <br>
  * <strong>Too small</strong>, and we'll have 1,000s of sections running around, all needing individual files and render buffers.<br>
  * <strong>Too big</strong>, and the LOD dropoff will be very noticeable.<br>
- * With those thoughts in mind we decided on a smallest section size of 32 data points square (IE 2x2 chunks).
+ * With those thoughts in mind we decided on a smallest section size of 64 data points square (IE 4x4 chunks).
  *
  * @author Leetom
  */

core/src/main/java/com/seibel/distanthorizons/core/render/DhFrustumBounds.java

@@ -54,10 +54,6 @@ public class DhFrustumBounds implements IDhApiCullingFrustum
 		Vector3f lodMin = new Vector3f(lodBlockPosMinX, this.worldMinY, lodBlockPosMinZ);
 		Vector3f lodMax = new Vector3f(lodBlockPosMinX + lodBlockWidth, this.worldMaxY, lodBlockPosMinZ + lodBlockWidth);
 		
-		if (lodMax.x < this.boundsMin.x || lodMin.x > this.boundsMax.x) return false;
-		if (lodMax.z < this.boundsMin.z || lodMin.z > this.boundsMax.z) return false;
-		if (this.worldMaxY < this.boundsMin.y || this.worldMinY > this.boundsMax.y) return false;
-		
 		return this.frustum.testAab(lodMin, lodMax);
 	}
 	

core/src/main/java/com/seibel/distanthorizons/core/render/LodQuadTree.java

@@ -74,7 +74,6 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 	 */
 	private final ConcurrentLinkedQueue<Long> sectionsToReload = new ConcurrentLinkedQueue<>();
 	private final IDhClientLevel level; //FIXME: Proper hierarchy to remove this reference!
-	private final ConfigChangeListener<EDhApiHorizontalQuality> horizontalScaleChangeListener;
 	private final ReentrantLock treeReadWriteLock = new ReentrantLock();
 	private final AtomicBoolean fullDataRetrievalQueueRunning = new AtomicBoolean(false);
 	
@@ -110,8 +109,6 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 		this.level = level;
 		this.fullDataSourceProvider = fullDataSourceProvider;
 		this.blockRenderDistanceDiameter = viewDiameterInBlocks;
-		
-		this.horizontalScaleChangeListener = new ConfigChangeListener<>(Config.Client.Advanced.Graphics.Quality.horizontalQuality, (newHorizontalScale) -> this.onHorizontalQualityChange());
 	}
 	
 	
@@ -151,7 +148,7 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 			}
 			catch (Exception e)
 			{
-				LOGGER.error("Quad Tree tick exception for dimension: " + this.level.getClientLevelWrapper().getDimensionType().getDimensionName() + ", exception: " + e.getMessage(), e);
+				LOGGER.error("Quad Tree tick exception for dimension: " + this.level.getLevelWrapper().getDimensionType().getDimensionName() + ", exception: " + e.getMessage(), e);
 			}
 			finally
 			{
@@ -192,7 +189,7 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 				try
 				{
 					LodRenderSection renderSection = this.getValue(pos);
-					if (renderSection != null && renderSection.renderingEnabled)
+					if (renderSection != null && renderSection.getRenderingEnabled())
 					{
 						renderSection.uploadRenderDataToGpuAsync();
 					}
@@ -293,13 +290,13 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 		//byte expectedDetailLevel = DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL + 3; // can be used instead of the following logic for testing
 		byte expectedDetailLevel = this.calculateExpectedDetailLevel(playerPos, sectionPos);
 		expectedDetailLevel = (byte) Math.min(expectedDetailLevel, this.minRenderDetailLevel);
-		expectedDetailLevel += DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL;
+		expectedDetailLevel += DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL;
 		
 		
 		if (DhSectionPos.getDetailLevel(sectionPos) > expectedDetailLevel)
 		{
 			// section detail level too high //
-			boolean thisPosIsRendering = renderSection.renderingEnabled;
+			boolean thisPosIsRendering = renderSection.getRenderingEnabled();
 			boolean allChildrenSectionsAreLoaded = true;
 			
 			// recursively update all child render sections
@@ -317,24 +314,8 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 			}
 			else
 			{
-				if (renderSection.renderingEnabled
-					&& Config.Client.Advanced.Debugging.DebugWireframe.showRenderSectionStatus.get())
-				{
-					// show that this position has just been disabled
-					DebugRenderer.makeParticle(
-						new DebugRenderer.BoxParticle(
-							new DebugRenderer.Box(renderSection.pos, 128f, 156f, 0.09f, Color.CYAN.darker()),
-							0.2, 32f
-						)
-					);
-				}
-				
 				// all child positions are loaded, disable this section and enable its children.
-				if (renderSection.renderingEnabled)
-				{
-					this.level.unloadBeaconBeamsInPos(renderSection.pos);
-				}
-				renderSection.renderingEnabled = false;
+				renderSection.setRenderingEnabled(false);
 				
 				// walk back down the tree and enable the child sections //TODO there are probably more efficient ways of doing this, but this will work for now
 				for (int i = 0; i < 4; i++)
@@ -385,17 +366,14 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 				if (!parentSectionIsRendering && renderSection.canRender())
 				{
 					// if rendering is already enabled we don't have to re-enable it
-					if (!renderSection.renderingEnabled)
+					if (!renderSection.getRenderingEnabled())
 					{
-						renderSection.renderingEnabled = true;
-						this.level.loadBeaconBeamsInPos(renderSection.pos);
-						
 						// delete/disable children, all of them will be a lower detail level than requested
 						quadNode.deleteAllChildren((childRenderSection) ->
 						{
 							if (childRenderSection != null)
 							{
-								if (childRenderSection.renderingEnabled)
+								if (childRenderSection.getRenderingEnabled())
 								{
 									// show that this position's rendering has been disabled due to a parent rendering
 									DebugRenderer.makeParticle(
@@ -406,10 +384,12 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 									);
 								}
 								
-								childRenderSection.renderingEnabled = false;
+								childRenderSection.setRenderingEnabled(false);
 								childRenderSection.close();
 							}
 						});
+						
+						renderSection.setRenderingEnabled(true);
 					}
 				}
 				
@@ -615,7 +595,7 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 	// config listeners //
 	//==================//
 	
-	private void onHorizontalQualityChange() { this.clearRenderDataCache(); }
+	private void onHorizontalQualityChange() { /*this.clearRenderDataCache();*/ }
 	
 	
 	//===========//
@@ -678,8 +658,6 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 	{
 		LOGGER.info("Shutting down " + LodQuadTree.class.getSimpleName() + "...");
 		
-		this.horizontalScaleChangeListener.close();
-		
 		DebugRenderer.unregister(this, Config.Client.Advanced.Debugging.DebugWireframe.showQuadTreeRenderStatus);
 		
 		Iterator<QuadNode<LodRenderSection>> nodeIterator = this.nodeIterator();

core/src/main/java/com/seibel/distanthorizons/core/render/LodRenderSection.java

@@ -23,17 +23,21 @@ import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.dataObjects.render.ColumnRenderSource;
 import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.ColumnRenderBufferBuilder;
+import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder;
 import com.seibel.distanthorizons.core.dataObjects.transformers.FullDataToRenderDataTransformer;
+import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.file.fullDatafile.FullDataSourceProviderV2;
 import com.seibel.distanthorizons.core.level.IDhClientLevel;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.glObject.GLProxy;
 import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
 import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.ColumnRenderBuffer;
 import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
 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;
@@ -54,6 +58,7 @@ import java.util.concurrent.locks.ReentrantLock;
 public class LodRenderSection implements IDebugRenderable, AutoCloseable
 {
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	
 	
 	
@@ -65,7 +70,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 	private final LodQuadTree quadTree;
 	
 	
-	public boolean renderingEnabled = false;
+	private boolean renderingEnabled = false;
 	private boolean canRender = false;
 	
 	/** this reference is necessary so we can determine what VBO to render */
@@ -76,7 +81,19 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 	 * Encapsulates everything between pulling data from the database (including neighbors)
 	 * up to the point when geometry data is uploaded to the GPU.
 	 */
-	private CompletableFuture<Void> uploadRenderDataToGpuFuture = null;
+	private CompletableFuture<Void> buildAndUploadRenderDataToGpuFuture = null;
+	/** 
+	 * Represents just building the {@link LodQuadBuilder}. <br>
+	 * Separate from {@link LodRenderSection#bufferUploadFuture} because they run on
+	 * different thread pools and need to be canceled separately.
+	 */
+	private CompletableFuture<LodQuadBuilder> bufferBuildFuture = null;
+	/** 
+	 * Represents just uploading the {@link LodQuadBuilder} to the GPU. <br>
+	 * Separate from {@link LodRenderSection#bufferBuildFuture} because they run on
+	 * different thread pools and need to be canceled separately.
+	 */
+	private CompletableFuture<ColumnRenderBuffer> bufferUploadFuture = null;
 	
 	private final ReentrantLock getRenderSourceLock = new ReentrantLock();
 	/** Stored as a class variable so we can reuse it's result across multiple LOD loads if necessary */
@@ -110,6 +127,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 	// render data loading/uploading //
 	//===============================//
 	
+	// TODO cleanup, there's a lot of nested futures and duplicate error handling here and it's hard to read
 	public synchronized void uploadRenderDataToGpuAsync()
 	{
 		if (!GLProxy.hasInstance())
@@ -119,7 +137,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			return;
 		}
 		
-		if (this.uploadRenderDataToGpuFuture != null)
+		if (this.buildAndUploadRenderDataToGpuFuture != null)
 		{
 			// don't accidentally queue multiple uploads at the same time
 			return;
@@ -133,7 +151,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			return;
 		}
 		
-		this.uploadRenderDataToGpuFuture = CompletableFuture.runAsync(() -> 
+		this.buildAndUploadRenderDataToGpuFuture = CompletableFuture.runAsync(() -> 
 		{
 			//==================//
 			// load render data //
@@ -141,15 +159,15 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			
 			this.tryDecrementingLoadFutureArray(this.adjacentLoadRefFutures);
 			
-			ReferencedFutureWrapper thisLoadFuture = this.getRenderSourceAsync();
-			ReferencedFutureWrapper[] adjLoadRefFutures = this.getNeighborRenderSourcesAsync();
+			ReferencedFutureWrapper thisRenderSourceLoadFuture = this.getRenderSourceAsync();
+			ReferencedFutureWrapper[] adjRenderSourceLoadRefFutures = this.getNeighborRenderSourcesAsync();
 			
 			
 			// wait for all futures to complete together,
 			// merging the futures makes loading significantly faster than loading this position then loading its neighbors
 			ArrayList<CompletableFuture<ColumnRenderSource>> futureList = new ArrayList<>();
-			futureList.add(thisLoadFuture.future);
-			for (ReferencedFutureWrapper refFuture : adjLoadRefFutures)
+			futureList.add(thisRenderSourceLoadFuture.future);
+			for (ReferencedFutureWrapper refFuture : adjRenderSourceLoadRefFutures)
 			{
 				futureList.add(refFuture.future);
 			}
@@ -158,72 +176,107 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			{
 				try
 				{
-					ColumnRenderSource renderSource = thisLoadFuture.future.get();
+					ColumnRenderSource renderSource = thisRenderSourceLoadFuture.future.get();
 					if (renderSource == null || renderSource.isEmpty())
 					{
-						thisLoadFuture.decrementRefCount();
-						for (ReferencedFutureWrapper futureWrapper : adjLoadRefFutures)
+						thisRenderSourceLoadFuture.decrementRefCount();
+						for (ReferencedFutureWrapper futureWrapper : adjRenderSourceLoadRefFutures)
 						{
 							futureWrapper.decrementRefCount();
 						}
 						
 						// nothing needs to be rendered
 						this.canRender = false;
-						this.uploadRenderDataToGpuFuture = null;
+						this.buildAndUploadRenderDataToGpuFuture = null;
+						this.bufferBuildFuture = null;
 						return;
 					}
 					
 					
 					
-					//==============================//
-					// build/upload new render data //
-					//==============================//
+					//=======================//
+					// build new render data //
+					//=======================//
 					
 					try
 					{
 						ColumnRenderBuffer previousBuffer = this.renderBuffer;
 						
 						ColumnRenderSource[] adjacentRenderSections = new ColumnRenderSource[EDhDirection.ADJ_DIRECTIONS.length];
+						boolean[] adjIsSameDetailLevel = new boolean[EDhDirection.ADJ_DIRECTIONS.length];
 						for (int i = 0; i < EDhDirection.ADJ_DIRECTIONS.length; i++)
 						{
-							adjacentRenderSections[i] = adjLoadRefFutures[i].future.getNow(null);
+							adjacentRenderSections[i] = adjRenderSourceLoadRefFutures[i].future.getNow(null);
+							
+							// if the adjacent position isn't the same detail level the buffer building logic
+							// will need to be slightly different in order to reduce holes in the LODs
+							EDhDirection direction = EDhDirection.ADJ_DIRECTIONS[i];
+							adjIsSameDetailLevel[direction.ordinal() - 2] = this.isAdjacentPosSameDetailLevel(direction);
 						}
-						ColumnRenderBufferBuilder.buildAndUploadBuffersAsync(this.level, renderSource, adjacentRenderSections).thenAccept((buffer) ->
+						
+						if (this.bufferBuildFuture != null)
+						{
+							// shouldn't normally happen, but just in case canceling the previous future
+							// prevents the CPU from working on something that won't be used
+							this.bufferBuildFuture.cancel(true);
+						}
+						this.bufferBuildFuture = ColumnRenderBufferBuilder.buildBuffersAsync(this.level, renderSource, adjacentRenderSections, adjIsSameDetailLevel);
+						this.bufferBuildFuture.thenAccept((lodQuadBuilder) ->
 						{
-							// upload complete, clean up the old data if 
-							this.renderBuffer = buffer;
-							this.canRender = true;
-							this.uploadRenderDataToGpuFuture = null;
 							
 							
-							if (previousBuffer != null)
+							
+							//===================================//
+							// upload new render data to the GPU //
+							//===================================//
+							
+							if (this.bufferUploadFuture != null)
 							{
-								previousBuffer.close();
+								// shouldn't normally happen, but just in case canceling the previous future
+								// prevents the CPU from working on something that won't be used
+								this.bufferUploadFuture.cancel(true);
 							}
+							this.bufferUploadFuture = ColumnRenderBufferBuilder.uploadBuffersAsync(this.level, renderSource, lodQuadBuilder);
+							this.bufferUploadFuture.thenAccept((buffer) ->
+							{
+								// upload complete, clean up the old data if 
+								this.renderBuffer = buffer;
+								this.canRender = (buffer != null);
+								this.buildAndUploadRenderDataToGpuFuture = null;
+								this.bufferBuildFuture = null;
 								
-							thisLoadFuture.decrementRefCount();
-							this.tryDecrementingLoadFutureArray(adjLoadRefFutures);
-							this.adjacentLoadRefFutures = null;
+								
+								if (previousBuffer != null)
+								{
+									previousBuffer.close();
+								}
+								
+								thisRenderSourceLoadFuture.decrementRefCount();
+								this.tryDecrementingLoadFutureArray(adjRenderSourceLoadRefFutures);
+								this.adjacentLoadRefFutures = null;
+							});
 						});
 					}
 					catch (Exception e)
 					{
-						thisLoadFuture.decrementRefCount();
-						this.tryDecrementingLoadFutureArray(adjLoadRefFutures);
+						thisRenderSourceLoadFuture.decrementRefCount();
+						this.tryDecrementingLoadFutureArray(adjRenderSourceLoadRefFutures);
 						this.adjacentLoadRefFutures = null;
 						
 						LOGGER.error("Unexpected error in LodRenderSection loading, Error: "+e.getMessage(), e);
-						this.uploadRenderDataToGpuFuture = null;
+						this.buildAndUploadRenderDataToGpuFuture = null;
+						this.bufferBuildFuture = null;
 					}
 				}
 				catch (Exception e)
 				{
-					thisLoadFuture.decrementRefCount();
-					this.tryDecrementingLoadFutureArray(adjLoadRefFutures);
+					thisRenderSourceLoadFuture.decrementRefCount();
+					this.tryDecrementingLoadFutureArray(adjRenderSourceLoadRefFutures);
 					this.adjacentLoadRefFutures = null;
 					
 					LOGGER.error("Unexpected error in LodRenderSection loading, Error: "+e.getMessage(), e);
-					this.uploadRenderDataToGpuFuture = null;
+					this.buildAndUploadRenderDataToGpuFuture = null;
+					this.bufferBuildFuture = null;
 				}
 			});
 		}, executor);
@@ -304,6 +357,32 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			this.getRenderSourceLock.unlock();
 		}
 	}
+	private boolean isAdjacentPosSameDetailLevel(EDhDirection direction)
+	{
+		long adjPos = DhSectionPos.getAdjacentPos(this.pos, direction);
+		byte detailLevel = this.quadTree.calculateExpectedDetailLevel(new DhBlockPos2D(MC.getPlayerBlockPos()), adjPos);
+		detailLevel += DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL;
+		boolean adjacentIsSameDetailLevel = (detailLevel == DhSectionPos.getDetailLevel(this.pos));
+		return adjacentIsSameDetailLevel;
+	}
+	
+	
+	/** 
+	 * Note: can cause issues with neighboring LOD sections 
+	 * if only some (vs all) futures are canceled.
+	 */
+	public void cancelGpuUpload()
+	{
+		CompletableFuture<Void> future = this.buildAndUploadRenderDataToGpuFuture;
+		this.buildAndUploadRenderDataToGpuFuture = null;
+		this.bufferBuildFuture = null;
+		if (future != null)
+		{
+			// interrupting the future speeds things up, but also causes
+			// some LODs to never load in properly
+			future.cancel(false);
+		}
+	}
 	
 	
 	
@@ -313,7 +392,39 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 	
 	public boolean canRender() { return this.canRender; }
 	
-	public boolean gpuUploadInProgress() { return this.uploadRenderDataToGpuFuture != null; }
+	public boolean getRenderingEnabled() { return this.renderingEnabled; }
+	public void setRenderingEnabled(boolean enabled) 
+	{
+		// some logic should only be run when enabling/disabling
+		// a section for the first time
+		boolean stateChanged = (this.renderingEnabled != enabled);
+		if (stateChanged)
+		{
+			if (enabled)
+			{
+				this.level.loadBeaconBeamsInPos(this.pos);
+			}
+			else
+			{
+				this.level.unloadBeaconBeamsInPos(this.pos);
+				
+				if (Config.Client.Advanced.Debugging.DebugWireframe.showRenderSectionStatus.get())
+				{
+					// show that this position has just been disabled
+					DebugRenderer.makeParticle(
+							new DebugRenderer.BoxParticle(
+									new DebugRenderer.Box(this.pos, 128f, 156f, 0.09f, Color.CYAN.darker()),
+									0.2, 32f
+							)
+					);
+				}
+			}
+		}
+		
+		this.renderingEnabled = enabled;
+	}
+	
+	public boolean gpuUploadInProgress() { return this.buildAndUploadRenderDataToGpuFuture != null; }
 	
 	
 	
@@ -423,9 +534,18 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			this.renderBuffer.close();
 		}
 		
-		if (this.uploadRenderDataToGpuFuture != null)
+		// cancel all in-progress futures since they aren't needed any more
+		if (this.buildAndUploadRenderDataToGpuFuture != null)
 		{
-			this.uploadRenderDataToGpuFuture.cancel(true);
+			this.buildAndUploadRenderDataToGpuFuture.cancel(true);
+		}
+		if (this.bufferBuildFuture != null)
+		{
+			this.bufferBuildFuture.cancel(true);
+		}
+		if (this.bufferUploadFuture != null)
+		{
+			this.bufferUploadFuture.cancel(true);
 		}
 		
 		// this render section won't be rendering, we don't need to load any data for it
@@ -460,7 +580,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 		{
 			color = Color.green;
 		}
-		else if (this.uploadRenderDataToGpuFuture != null)
+		else if (this.buildAndUploadRenderDataToGpuFuture != null)
 		{
 			color = Color.yellow;
 		}

core/src/main/java/com/seibel/distanthorizons/core/render/RenderBufferHandler.java

@@ -311,7 +311,7 @@ public class RenderBufferHandler implements AutoCloseable
 				}
 				
 				ColumnRenderBuffer buffer = renderSection.renderBuffer;
-				if (buffer == null || !renderSection.renderingEnabled)
+				if (buffer == null || !renderSection.getRenderingEnabled())
 				{
 					continue;
 				}

core/src/main/java/com/seibel/distanthorizons/core/render/glObject/GLProxy.java

@@ -193,17 +193,7 @@ public class GLProxy
 		return instance;
 	}
 	
-	public EDhApiGpuUploadMethod getGpuUploadMethod()
-	{
-		EDhApiGpuUploadMethod method = Config.Client.Advanced.GpuBuffers.gpuUploadMethod.get();
-		if (!this.bufferStorageSupported && method == EDhApiGpuUploadMethod.BUFFER_STORAGE)
-		{
-			// if buffer storage isn't supported
-			// default to DATA since that is the most compatible
-			method = EDhApiGpuUploadMethod.DATA;
-		}
-		return method == EDhApiGpuUploadMethod.AUTO ? this.preferredUploadMethod : method;
-	}
+	public EDhApiGpuUploadMethod getGpuUploadMethod() { return this.preferredUploadMethod; }
 	
 	public boolean runningOnRenderThread()
 	{

core/src/main/java/com/seibel/distanthorizons/core/render/glObject/buffer/GLBuffer.java

@@ -238,7 +238,7 @@ public class GLBuffer implements AutoCloseable
 	// buffer mapping //
 	//================//
 	
-	public ByteBuffer mapBuffer(int targetSize, EDhApiGpuUploadMethod uploadMethod, int maxExpensionSize, int bufferHint, int mapFlags)
+	public ByteBuffer mapBuffer(int targetSize, EDhApiGpuUploadMethod uploadMethod, int maxExpansionSize, int bufferHint, int mapFlags)
 	{
 		LodUtil.assertTrue(targetSize != 0, "MapBuffer targetSize is 0");
 		LodUtil.assertTrue(uploadMethod.useEarlyMapping, "Upload method must be one that use early mappings in order to call mapBuffer");
@@ -252,7 +252,7 @@ public class GLBuffer implements AutoCloseable
 		if (this.size < targetSize || this.size > targetSize * BUFFER_SHRINK_TRIGGER)
 		{
 			int newSize = (int) (targetSize * BUFFER_EXPANSION_MULTIPLIER);
-			if (newSize > maxExpensionSize) newSize = maxExpensionSize;
+			if (newSize > maxExpansionSize) newSize = maxExpansionSize;
 			this.size = newSize;
 			if (this.bufferStorage)
 			{

core/src/main/java/com/seibel/distanthorizons/core/render/glObject/buffer/GLVertexBuffer.java

@@ -77,9 +77,9 @@ public class GLVertexBuffer extends GLBuffer
 		this.vertexCount = vertCount;
 	}
 	
-	public ByteBuffer mapBuffer(int targetSize, EDhApiGpuUploadMethod uploadMethod, int maxExpensionSize)
+	public ByteBuffer mapBuffer(int targetSize, EDhApiGpuUploadMethod uploadMethod, int maxExpansionSize)
 	{
-		return super.mapBuffer(targetSize, uploadMethod, maxExpensionSize,
+		return super.mapBuffer(targetSize, uploadMethod, maxExpansionSize,
 				uploadMethod.useBufferStorage ? GL32.GL_MAP_WRITE_BIT :
 						uploadMethod.useEarlyMapping ? GL32.GL_DYNAMIC_DRAW : GL32.GL_STATIC_DRAW,
 				GL32.GL_MAP_WRITE_BIT | GL32.GL_MAP_UNSYNCHRONIZED_BIT | GL32.GL_MAP_INVALIDATE_BUFFER_BIT);

core/src/main/java/com/seibel/distanthorizons/core/render/glObject/buffer/QuadElementBuffer.java

@@ -25,6 +25,7 @@ import com.seibel.distanthorizons.core.render.glObject.GLEnums;
 import com.seibel.distanthorizons.core.render.glObject.GLProxy;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.opengl.GL32;
+import org.lwjgl.system.MemoryUtil;
 
 import java.lang.invoke.MethodHandles;
 import java.nio.ByteBuffer;
@@ -154,7 +155,7 @@ public class QuadElementBuffer extends GLElementBuffer
 		LOGGER.info("Quad IBO Resizing from [" + getCapacity() + "] to [" + quadCount + "]" + " with type: " +
 				GLEnums.getString(type));
 		
-		ByteBuffer buffer = ByteBuffer.allocateDirect(indicesCount * GLEnums.getTypeSize(type)).order(ByteOrder.nativeOrder());
+		ByteBuffer buffer = MemoryUtil.memAlloc(indicesCount * GLEnums.getTypeSize(type));
 		buildBuffer(quadCount, buffer, type);
 		if (!gl.bufferStorageSupported)
 		{
@@ -169,6 +170,8 @@ public class QuadElementBuffer extends GLElementBuffer
 			super.uploadBuffer(buffer, EDhApiGpuUploadMethod.BUFFER_STORAGE,
 					indicesCount * GLEnums.getTypeSize(type), 0);
 		}
+		
+		MemoryUtil.memFree(buffer);
 	}
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/render/renderer/ScreenQuad.java

@@ -24,6 +24,7 @@ import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer;
 import com.seibel.distanthorizons.core.render.glObject.vertexAttribute.AbstractVertexAttribute;
 import com.seibel.distanthorizons.core.render.glObject.vertexAttribute.VertexPointer;
 import org.lwjgl.opengl.GL32;
+import org.lwjgl.system.MemoryUtil;
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
@@ -86,14 +87,14 @@ public class ScreenQuad
 	
 	private void createBuffer()
 	{
-		ByteBuffer buffer = ByteBuffer.allocateDirect(box_vertices.length * Float.BYTES);
-		buffer.order(ByteOrder.nativeOrder());
+		ByteBuffer buffer = MemoryUtil.memAlloc(box_vertices.length * Float.BYTES);
 		buffer.asFloatBuffer().put(box_vertices);
 		buffer.rewind();
 		
 		this.boxBuffer = new GLVertexBuffer(false);
 		this.boxBuffer.bind();
 		this.boxBuffer.uploadBuffer(buffer, box_vertices.length, EDhApiGpuUploadMethod.DATA, box_vertices.length * Float.BYTES);
+		MemoryUtil.memFree(buffer);
 	}
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/render/renderer/generic/BeaconRenderHandler.java

@@ -22,7 +22,6 @@ package com.seibel.distanthorizons.core.render.renderer.generic;
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
 import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup;
 import com.seibel.distanthorizons.api.objects.math.DhApiVec3d;
-import com.seibel.distanthorizons.api.objects.math.DhApiVec3f;
 import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox;
 import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading;
 import com.seibel.distanthorizons.core.config.Config;
@@ -42,7 +41,6 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
 
 public class BeaconRenderHandler
 {
@@ -56,7 +54,7 @@ public class BeaconRenderHandler
 	private final BeaconBeamRepo beaconBeamRepo;
 	
 	private final IDhApiRenderableBoxGroup beaconBoxGroup;
-	private final HashMap<DhBlockPos, AtomicInteger> beaconRefCountByBlockPos = new HashMap<>();
+	private final HashSet<DhBlockPos> beaconBlockPosSet = new HashSet<>();
 	
 	
 	
@@ -96,8 +94,8 @@ public class BeaconRenderHandler
 			for (int i = 0; i < newBeamList.size(); i++)
 			{
 				BeaconBeamDTO beam = newBeamList.get(i);
-				newBeamByPos.put(beam.pos, beam);
-				allPosSet.add(beam.pos);
+				newBeamByPos.put(beam.blockPos, beam);
+				allPosSet.add(beam.blockPos);
 			}
 			
 			// get existing beams
@@ -106,8 +104,8 @@ public class BeaconRenderHandler
 			for (int i = 0; i < existingBeamList.size(); i++)
 			{
 				BeaconBeamDTO beam = existingBeamList.get(i);
-				existingBeamByPos.put(beam.pos, beam);
-				allPosSet.add(beam.pos);
+				existingBeamByPos.put(beam.blockPos, beam);
+				allPosSet.add(beam.blockPos);
 			}
 			
 			
@@ -168,7 +166,7 @@ public class BeaconRenderHandler
 		for (int i = 0; i < existingBeamList.size(); i++)
 		{
 			BeaconBeamDTO beam = existingBeamList.get(i);
-			this.stopRenderingBeaconAtPos(beam.pos);
+			this.stopRenderingBeaconAtPos(beam.blockPos);
 		}
 	}
 	
@@ -180,50 +178,37 @@ public class BeaconRenderHandler
 	
 	private void startRenderingBeacon(BeaconBeamDTO beacon)
 	{
-		this.beaconRefCountByBlockPos.compute(beacon.pos, (beamPos, beaconRefCount) ->
+		if (this.beaconBlockPosSet.add(beacon.blockPos))
 		{
-			if (beaconRefCount == null) { beaconRefCount = new AtomicInteger(); }
-			if (beaconRefCount.getAndIncrement() == 0)
-			{
-				DhApiRenderableBox beaconBox = new DhApiRenderableBox(
-						new DhApiVec3d(beacon.pos.x, beacon.pos.y+1, beacon.pos.z),
-						new DhApiVec3d(beacon.pos.x+1, BEAM_TOP_Y, beacon.pos.z+1),
-						beacon.color,
-						EDhApiBlockMaterial.ILLUMINATED
-				);
+			DhApiRenderableBox beaconBox = new DhApiRenderableBox(
+					new DhApiVec3d(beacon.blockPos.x, beacon.blockPos.y+1, beacon.blockPos.z),
+					new DhApiVec3d(beacon.blockPos.x+1, BEAM_TOP_Y, beacon.blockPos.z+1),
+					beacon.color,
+					EDhApiBlockMaterial.ILLUMINATED
+			);
 			
-				this.beaconBoxGroup.add(beaconBox);
-				this.beaconBoxGroup.triggerBoxChange();
-			}
-			return beaconRefCount;
-		});
+			this.beaconBoxGroup.add(beaconBox);
+			this.beaconBoxGroup.triggerBoxChange();
+		}
 	}
 	
 	private void stopRenderingBeaconAtPos(DhBlockPos beaconPos)
 	{
-		this.beaconRefCountByBlockPos.compute(beaconPos, (pos, beaconRefCount) ->
+		if (this.beaconBlockPosSet.remove(beaconPos))
 		{
-			if (beaconRefCount != null
-					&& beaconRefCount.decrementAndGet() <= 0)
+			this.beaconBoxGroup.removeIf((box) ->
 			{
-				this.beaconBoxGroup.removeIf((box) ->
-						box.minPos.x == beaconPos.x
-								&& box.minPos.y == beaconPos.y+1 // plus 1 because the beam starts above the beacon
-								&& box.minPos.z == beaconPos.z
-				);
-				this.beaconBoxGroup.triggerBoxChange();
-				return null;
-			}
-			else
-			{
-				return beaconRefCount;
-			}
-		});
+				return box.minPos.x == beaconPos.x
+						&& box.minPos.y == beaconPos.y+1 // plus 1 because the beam starts above the beacon
+						&& box.minPos.z == beaconPos.z;
+			});
+			this.beaconBoxGroup.triggerBoxChange();
+		}
 	}
 	
 	private void updateBeaconColor(BeaconBeamDTO newBeam)
 	{
-		DhBlockPos pos = newBeam.pos;
+		DhBlockPos pos = newBeam.blockPos;
 		for (int i = 0; i < this.beaconBoxGroup.size(); i++)
 		{
 			DhApiRenderableBox box = this.beaconBoxGroup.get(i);

core/src/main/java/com/seibel/distanthorizons/core/render/renderer/generic/GenericObjectRenderer.java

@@ -50,6 +50,7 @@ import org.apache.logging.log4j.Logger;
 import org.lwjgl.opengl.ARBInstancedArrays;
 import org.lwjgl.opengl.GL32;
 import org.lwjgl.opengl.GL33;
+import org.lwjgl.system.MemoryUtil;
 
 import java.awt.*;
 import java.nio.ByteBuffer;
@@ -192,24 +193,22 @@ public class GenericObjectRenderer implements IDhApiCustomRenderRegister
 	private void createBuffers()
 	{
 		// box vertices 
-		ByteBuffer boxVerticesBuffer = ByteBuffer.allocateDirect(BOX_VERTICES.length * Float.BYTES);
-		boxVerticesBuffer.order(ByteOrder.nativeOrder());
+		ByteBuffer boxVerticesBuffer = MemoryUtil.memAlloc(BOX_VERTICES.length * Float.BYTES);
 		boxVerticesBuffer.asFloatBuffer().put(BOX_VERTICES);
 		boxVerticesBuffer.rewind();
 		this.boxVertexBuffer = new GLVertexBuffer(false);
 		this.boxVertexBuffer.bind();
 		this.boxVertexBuffer.uploadBuffer(boxVerticesBuffer, 8, EDhApiGpuUploadMethod.DATA, BOX_VERTICES.length * Float.BYTES);
-		
+		MemoryUtil.memFree(boxVerticesBuffer);
 		
 		// box vertex indexes
-		ByteBuffer solidIndexBuffer = ByteBuffer.allocateDirect(BOX_INDICES.length * Integer.BYTES);
-		solidIndexBuffer.order(ByteOrder.nativeOrder());
+		ByteBuffer solidIndexBuffer = MemoryUtil.memAlloc(BOX_INDICES.length * Integer.BYTES);
 		solidIndexBuffer.asIntBuffer().put(BOX_INDICES);
 		solidIndexBuffer.rewind();
 		this.boxIndexBuffer = new GLElementBuffer(false);
 		this.boxIndexBuffer.uploadBuffer(solidIndexBuffer, EDhApiGpuUploadMethod.DATA, BOX_INDICES.length * Integer.BYTES, GL32.GL_STATIC_DRAW);
 		this.boxIndexBuffer.bind();
-		
+		MemoryUtil.memFree(solidIndexBuffer);
 	}
 	private void addGenericDebugObjects()
 	{

core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogApplyShader.java

@@ -94,6 +94,12 @@ public class FogApplyShader extends AbstractShaderRenderer
 		GL32.glBlendEquation(GL32.GL_FUNC_ADD);
 		GL32.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA);
 		
+		// Depth testing must be disabled otherwise this application shader won't apply anything.
+		// setting this isn't necessary in vanilla, but some mods may change this, requiring it to be set manually, 
+		// it should be automatically restored after rendering is complete.
+		GL32.glDisable(GL32.GL_DEPTH_TEST);
+		
+		
 		// apply the rendered Fog to DH's framebuffer
 		GL32.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, FogShader.INSTANCE.frameBuffer);
 		GL32.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, LodRenderer.getActiveFramebufferId());

core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/FogShader.java

@@ -167,6 +167,11 @@ public class FogShader extends AbstractShaderRenderer
 		GL32.glBindTexture(GL32.GL_TEXTURE_2D, LodRenderer.getActiveDepthTextureId());
 		GL32.glUniform1i(this.uDepthMap, 0);
 		
+		// this is necessary for MC 1.16 (IE Legacy OpenGL)
+		// otherwise the framebuffer isn't cleared correctly and the fog smears across the screen
+		GL32.glClear(GL32.GL_COLOR_BUFFER_BIT | GL32.GL_DEPTH_BUFFER_BIT);
+		
+		
 		ScreenQuad.INSTANCE.render();
 		
 		state.restore();

core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAOApplyShader.java

@@ -125,6 +125,12 @@ public class SSAOApplyShader extends AbstractShaderRenderer
 		GL32.glBlendEquation(GL32.GL_FUNC_ADD);
 		GL32.glBlendFuncSeparate(GL32.GL_ZERO, GL32.GL_SRC_ALPHA, GL32.GL_ZERO, GL32.GL_ONE);
 		
+		// Depth testing must be disabled otherwise this application shader won't apply anything.
+		// setting this isn't necessary in vanilla, but some mods may change this, requiring it to be set manually, 
+		// it should be automatically restored after rendering is complete.
+		GL32.glDisable(GL32.GL_DEPTH_TEST);
+		
+		
 		// apply the rendered SSAO to the LODs 
 		GL32.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, SSAOShader.INSTANCE.frameBuffer);
 		GL32.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, LodRenderer.getActiveFramebufferId());

core/src/main/java/com/seibel/distanthorizons/core/render/renderer/shaders/SSAOShader.java

@@ -103,17 +103,19 @@ public class SSAOShader extends AbstractShaderRenderer
 		this.shader.setUniform(this.gSampleCountUniform,
 				Config.Client.Advanced.Graphics.Ssao.sampleCount.get());
 		
-		this.shader.setUniform(this.gRadiusUniform,
-				Config.Client.Advanced.Graphics.Ssao.radius.get().floatValue());
+		// Implicit Number cast needs to be done to prevent issues with the default value being a int
+		Number radius = Config.Client.Advanced.Graphics.Ssao.radius.get(); 
+		this.shader.setUniform(this.gRadiusUniform, radius.floatValue());
 		
-		this.shader.setUniform(this.gStrengthUniform,
-				Config.Client.Advanced.Graphics.Ssao.strength.get().floatValue());
 		
-		this.shader.setUniform(this.gMinLightUniform,
-				Config.Client.Advanced.Graphics.Ssao.minLight.get().floatValue());
+		Number strength = Config.Client.Advanced.Graphics.Ssao.strength.get();
+		this.shader.setUniform(this.gStrengthUniform, strength.floatValue());
 		
-		this.shader.setUniform(this.gBiasUniform,
-				Config.Client.Advanced.Graphics.Ssao.bias.get().floatValue());
+		Number minLight = Config.Client.Advanced.Graphics.Ssao.minLight.get();
+		this.shader.setUniform(this.gMinLightUniform, minLight.floatValue());
+		
+		Number bias = Config.Client.Advanced.Graphics.Ssao.bias.get();
+		this.shader.setUniform(this.gBiasUniform, bias.floatValue());
 		
 		GL32.glActiveTexture(GL32.GL_TEXTURE0);
 		GL32.glBindTexture(GL32.GL_TEXTURE_2D, LodRenderer.getActiveDepthTextureId());

core/src/main/java/com/seibel/distanthorizons/core/sql/dto/BeaconBeamDTO.java

@@ -21,14 +21,13 @@ package com.seibel.distanthorizons.core.sql.dto;
 
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.pos.DhBlockPos;
-import com.seibel.distanthorizons.core.pos.DhBlockPos;
 
 import java.awt.*;
 
 /** handles storing {@link FullDataSourceV2}'s in the database. */
 public class BeaconBeamDTO implements IBaseDTO<DhBlockPos>
 {
-	public DhBlockPos pos;
+	public DhBlockPos blockPos;
 	public Color color;
 	
 	
@@ -37,9 +36,9 @@ public class BeaconBeamDTO implements IBaseDTO<DhBlockPos>
 	// constructor //
 	//=============//
 	
-	public BeaconBeamDTO(DhBlockPos pos, Color color)
+	public BeaconBeamDTO(DhBlockPos blockPos, Color color)
 	{
-		this.pos = pos;
+		this.blockPos = blockPos;
 		this.color = color;
 	}
 	
@@ -50,6 +49,6 @@ public class BeaconBeamDTO implements IBaseDTO<DhBlockPos>
 	//===========//
 	
 	@Override 
-	public DhBlockPos getKey() { return this.pos; }
+	public DhBlockPos getKey() { return this.blockPos; }
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/sql/repo/BeaconBeamRepo.java

@@ -100,9 +100,9 @@ public class BeaconBeamRepo extends AbstractDhRepo<DhBlockPos, BeaconBeamDTO>
 		PreparedStatement statement = this.createPreparedStatement(sql);
 		
 		int i = 1;
-		statement.setObject(i++, dto.pos.x);
-		statement.setObject(i++, dto.pos.y);
-		statement.setObject(i++, dto.pos.z);
+		statement.setObject(i++, dto.blockPos.x);
+		statement.setObject(i++, dto.blockPos.y);
+		statement.setObject(i++, dto.blockPos.z);
 		
 		statement.setObject(i++, dto.color.getRed());
 		statement.setObject(i++, dto.color.getGreen());
@@ -132,9 +132,9 @@ public class BeaconBeamRepo extends AbstractDhRepo<DhBlockPos, BeaconBeamDTO>
 		
 		statement.setObject(i++, System.currentTimeMillis()); // last modified unix time
 		
-		statement.setObject(i++, dto.pos.x);
-		statement.setObject(i++, dto.pos.y);
-		statement.setObject(i++, dto.pos.z);
+		statement.setObject(i++, dto.blockPos.x);
+		statement.setObject(i++, dto.blockPos.y);
+		statement.setObject(i++, dto.blockPos.z);
 		
 		return statement;
 	}

core/src/main/java/com/seibel/distanthorizons/core/util/LodUtil.java

@@ -20,7 +20,6 @@
 package com.seibel.distanthorizons.core.util;
 
 import java.util.Arrays;
-import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletionException;
@@ -29,11 +28,8 @@ import java.util.concurrent.RejectedExecutionException;
 import com.seibel.distanthorizons.api.enums.config.EDhApiVanillaOverdraw;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
-import com.seibel.distanthorizons.core.pos.DhChunkPos;
-import com.seibel.distanthorizons.core.pos.Pos2D;
 import com.seibel.distanthorizons.core.render.vertexFormat.DefaultLodVertexFormats;
 import com.seibel.distanthorizons.core.render.vertexFormat.LodVertexFormat;
-import com.seibel.distanthorizons.core.util.gridList.EdgeDistanceBooleanGrid;
 import com.seibel.distanthorizons.core.util.objects.UncheckedInterruptedException;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
@@ -44,9 +40,6 @@ import org.apache.logging.log4j.Logger;
 
 /**
  * This class holds methods and constants that may be used in multiple places.
- *
- * @author James Seibel
- * @version 2022-12-5
  */
 public class LodUtil
 {
@@ -54,31 +47,7 @@ public class LodUtil
 	private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class);
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	
-	/**
-	 * Vanilla render distances less than or equal to this will not allow partial
-	 * overdraw. The VanillaOverdraw will either be ALWAYS or NEVER.
-	 */
-	public static final int MINIMUM_RENDER_DISTANCE_FOR_PARTIAL_OVERDRAW = 4;
 	
-	/**
-	 * Vanilla render distances less than or equal to this will cause the overdraw to
-	 * run at a smaller fraction of the vanilla render distance.
-	 */
-	public static final int MINIMUM_RENDER_DISTANCE_FOR_FAR_OVERDRAW = 11;
-	
-	
-	
-	
-	/**
-	 * alpha used when drawing chunks in debug mode
-	 */
-	public static final int DEBUG_ALPHA = 255; // 0 - 25;
-	
-	public static final int COLOR_DEBUG_BLACK = ColorUtil.rgbToInt(DEBUG_ALPHA, 0, 0, 0);
-	public static final int COLOR_DEBUG_WHITE = ColorUtil.rgbToInt(DEBUG_ALPHA, 255, 255, 255);
-	public static final int COLOR_INVISIBLE = ColorUtil.rgbToInt(0, 0, 0, 0);
-	
-	//FIXME: WE NEED MORE COLORS!!!!
 	/**
 	 * In order of nearest to farthest: <br>
 	 * Red, Orange, Yellow, Green, Cyan, Blue, Magenta, white, gray, black
@@ -166,92 +135,9 @@ public class LodUtil
 	
 	
 	
-	
-	/**
-	 * Gets the ServerWorld for the relevant dimension.
-	 *
-	 * @return null if there is no ServerWorld for the given dimension
-	 */
-	public static ILevelWrapper getServerWorldFromDimension(IDimensionTypeWrapper newDimension)
-	{
-		if (!MC_CLIENT.hasSinglePlayerServer())
-			return null;
-		
-		Iterable<ILevelWrapper> worlds = MC_CLIENT.getAllServerWorlds();
-		ILevelWrapper returnWorld = null;
-		
-		for (ILevelWrapper world : worlds)
-		{
-			if (world.getDimensionType() == newDimension)
-			{
-				returnWorld = world;
-				break;
-			}
-		}
-		
-		return returnWorld;
-	}
-	
-	
-	public static int computeOverdrawOffset()
-	{
-		int chunkRenderDist = MC_RENDER.getRenderDistance() + 1;
-		EDhApiVanillaOverdraw overdraw = EDhApiVanillaOverdraw.ALWAYS; //Config.Client.Advanced.Graphics.AdvancedGraphics.vanillaOverdraw.get();
-		if (overdraw == EDhApiVanillaOverdraw.ALWAYS) return Integer.MAX_VALUE;
-		
-		int offset;
-		if (overdraw == EDhApiVanillaOverdraw.NEVER)
-		{
-			offset = 0; //Config.Client.Advanced.Graphics.AdvancedGraphics.overdrawOffset.get();
-		}
-		else
-		{
-			if (chunkRenderDist < MINIMUM_RENDER_DISTANCE_FOR_FAR_OVERDRAW)
-			{
-				offset = 1;
-			}
-			else
-			{
-				offset = chunkRenderDist / 5;
-			}
-		}
-		
-		if (chunkRenderDist - offset <= 1)
-		{
-			return Integer.MAX_VALUE;
-		}
-		return offset;
-	}
-	
-	/** not currently used since the new rendering system can't easily toggle single chunks to render */
-	@Deprecated
-	public static EdgeDistanceBooleanGrid readVanillaRenderedChunks()
-	{
-		int offset = computeOverdrawOffset();
-		if (offset == Integer.MAX_VALUE) return null;
-		int renderDist = MC_RENDER.getRenderDistance() + 1;
-		
-		Iterator<DhChunkPos> posIter = MC_RENDER.getVanillaRenderedChunks().iterator();
-		
-		return new EdgeDistanceBooleanGrid(new Iterator<Pos2D>()
-		{
-			@Override
-			public boolean hasNext()
-			{
-				return posIter.hasNext();
-			}
-			
-			@Override
-			public Pos2D next()
-			{
-				DhChunkPos pos = posIter.next();
-				return new Pos2D(pos.x, pos.z);
-			}
-		},
-				MC_CLIENT.getPlayerChunkPos().x - renderDist,
-				MC_CLIENT.getPlayerChunkPos().z - renderDist,
-				renderDist * 2 + 1);
-	}
+	//=========//
+	// methods //
+	//=========//
 	
 	/** Returns the chunk int position for the given double position */
 	public static int getChunkPosFromDouble(double value) { return (int) Math.floor(value / CHUNK_WIDTH); }
@@ -275,11 +161,6 @@ public class LodUtil
 		return true;
 	}
 	
-	public static void checkInterrupts() throws InterruptedException
-	{
-		if (Thread.interrupted()) throw new InterruptedException();
-	}
-	
 	/**
 	 * Format a given string with params using log4j's MessageFormat
 	 *
@@ -290,26 +171,7 @@ public class LodUtil
 	 * Do not use it for deserialization or naming of objects.</b>
 	 * @author leetom
 	 */
-	public static String formatLog(String str, Object... param)
-	{
-		return LOGGER.getMessageFactory().newMessage(str, param).getFormattedMessage();
-	}
-	
-	/**
-	 * Returns a shortened version of the given string that is no longer than maxLength. <br>
-	 * If null returns the empty string.
-	 */
-	public static String shortenString(String str, int maxLength)
-	{
-		if (str == null)
-		{
-			return "";
-		}
-		else
-		{
-			return str.substring(0, Math.min(str.length(), maxLength));
-		}
-	}
+	public static String formatLog(String str, Object... param) { return LOGGER.getMessageFactory().newMessage(str, param).getFormattedMessage(); }
 	
 	public static class AssertFailureException extends RuntimeException
 	{

core/src/main/java/com/seibel/distanthorizons/core/util/RenderDataPointReducingList.java

@@ -829,7 +829,7 @@ public class RenderDataPointReducingList
 		int size = view.size();
 		if (size <= 0)
 		{
-			return RenderDataPointUtil.createVoidDataPoint();
+			return RenderDataPointUtil.EMPTY_DATA;
 		}
 		
 		long highestDataPoint;
@@ -849,7 +849,7 @@ public class RenderDataPointReducingList
 				}
 			}
 			//no visible segments, return void.
-			return RenderDataPointUtil.createVoidDataPoint();
+			return RenderDataPointUtil.EMPTY_DATA;
 		}
 		
 		//second loop: merge the rest of the segments.
@@ -889,7 +889,7 @@ public class RenderDataPointReducingList
 		// so, if we didn't set any data points, add a void data point.
 		if (writeIndex == 0)
 		{
-			view.set(writeIndex++, RenderDataPointUtil.createVoidDataPoint());
+			view.set(writeIndex++, RenderDataPointUtil.EMPTY_DATA);
 		}
 		
 		for (int size = view.size(); writeIndex < size; writeIndex++)

core/src/main/java/com/seibel/distanthorizons/core/util/RenderDataPointUtil.java

@@ -19,6 +19,7 @@
 
 package com.seibel.distanthorizons.core.util;
 
+import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
 import com.seibel.distanthorizons.core.level.AbstractDhLevel;
 import com.seibel.distanthorizons.core.logging.SpamReducedLogger;
 import com.seibel.distanthorizons.core.dataObjects.render.columnViews.ColumnArrayView;
@@ -110,8 +111,6 @@ public class RenderDataPointUtil
 	// datapoint manipulation //
 	//========================//
 	
-	public static long createVoidDataPoint() { return EMPTY_DATA; }
-	
 	public static long createDataPoint(int height, int depth, int color, int lightSky, int lightBlock, int irisBlockMaterialId)
 	{
 		return createDataPoint(
@@ -249,7 +248,7 @@ public class RenderDataPointUtil
 					getBlue(dataPoint) +
 					" BL:" + getLightBlock(dataPoint) +
 					" SL:" + getLightSky(dataPoint) +
-					" BID:" + getBlockMaterialId(dataPoint);
+					" MAT:" + getBlockMaterialId(dataPoint) + "["+ EDhApiBlockMaterial.getFromIndex(getBlockMaterialId(dataPoint))+"]";
 		}
 	}
 	
@@ -303,352 +302,6 @@ public class RenderDataPointUtil
 			list.reduce(output.verticalSize());
 			list.copyTo(output);
 		}
-		
-		
-		//old logic left here in case it's ever needed again.
-		/*
-		if (output.dataCount() != 1)
-		{
-			throw new IllegalArgumentException("output must be only reserved for one datapoint!");
-		}
-		
-		int inputVerticalSize = sourceData.verticalSize();
-		int outputVerticalSize = output.verticalSize();
-		output.fill(0);
-		
-		//dataCount indicate how many position we are merging in one position
-		int dataCount = sourceData.dataCount();
-		
-		// We initialize the arrays that are going to be used
-		int heightAndDepthLength = (MAX_WORLD_Y_SIZE / 2 + 16) * 2;
-		short[] heightAndDepth = tLocalHeightAndDepth.get();
-		if (heightAndDepth == null || heightAndDepth.length != heightAndDepthLength)
-		{
-			heightAndDepth = new short[heightAndDepthLength];
-			tLocalHeightAndDepth.set(heightAndDepth);
-		}
-		
-		byte genMode = getGenerationMode(sourceData.get(0));
-		if (genMode == 0)
-		{
-			genMode = 1; // FIXME: Hack to make the version 10 genMode never be 0.
-		}
-		
-		boolean allEmpty = true;
-		boolean allVoid = true;
-		boolean limited = false;
-		boolean allDefault;
-		long singleData;
-		
-		short yMin;
-		short yMax;
-		int count = 0;
-		int i;
-		int ii;
-		
-		int[] indices = tLocalIndices.get();
-		if (indices == null || indices.length != dataCount)
-		{
-			indices = new int[dataCount];
-			tLocalIndices.set(indices);
-		}
-		Arrays.fill(indices, 0);
-		
-		boolean[] increaseIndex = tLocalIncreaseIndex.get();
-		if (increaseIndex == null || increaseIndex.length != dataCount)
-		{
-			increaseIndex = new boolean[dataCount];
-			tLocalIncreaseIndex.set(increaseIndex);
-		}
-		
-		boolean[] indexHandled = tLocalIndexHandled.get();
-		if (indexHandled == null || indexHandled.length != dataCount)
-		{
-			indexHandled = new boolean[dataCount];
-			tLocalIndexHandled.set(indexHandled);
-		}
-		
-		long tempData;
-		for (int index = 0; index < dataCount; index++)
-		{
-			tempData = sourceData.get(index * inputVerticalSize);
-			allVoid = allVoid && RenderDataPointUtil.isVoid(tempData);
-			allEmpty = allEmpty && !RenderDataPointUtil.doesDataPointExist(tempData);
-		}
-		
-		//We check if there is any data that's not empty or void
-		if (allEmpty)
-		{
-			return;
-		}
-		else if (allVoid)
-		{
-			output.set(0, createVoidDataPoint(genMode));
-			return;
-		}
-		
-		//this check is used only to see if we have checked all the values in the array
-		boolean stillHasDataToCheck = true;
-		short prevDepth;
-		
-		while (stillHasDataToCheck)
-		{
-			Arrays.fill(indexHandled, false);
-			boolean connected = true;
-			int newHeight = -10000;
-			int newDepth = -10000;
-			int tempYMax;
-			int tempYMin;
-			while (connected)
-			{
-				Arrays.fill(increaseIndex, false);
-				for (int index = 0; index < dataCount; index++)
-				{
-					if (indices[index] < inputVerticalSize)
-					{
-						tempData = sourceData.get(index * inputVerticalSize + indices[index]);
-						if (!RenderDataPointUtil.isVoid(tempData) && RenderDataPointUtil.doesDataPointExist(tempData))
-						{
-							tempYMax = RenderDataPointUtil.getYMax(tempData);
-							tempYMin = RenderDataPointUtil.getYMin(tempData);
-							if (tempYMin >= newHeight)
-							{
-								//First case
-								//the column we are checking is higher than the current column
-								newDepth = tempYMin;
-								newHeight = tempYMax;
-								Arrays.fill(increaseIndex, false);
-								Arrays.fill(indexHandled, false);
-								increaseIndex[index] = true;
-								indexHandled[index] = true;
-							}
-							else if ((tempYMin >= newDepth) && (tempYMax <= newHeight))
-							{
-								//the column we are checking is contained in the current column
-								//we simply increase this index
-								increaseIndex[index] = true;
-								indexHandled[index] = true;
-							}
-							else if (tempYMax > newHeight && tempYMin <= newDepth)
-							{
-								newDepth = tempYMin;
-								newHeight = tempYMax;
-								increaseIndex[index] = true;
-								indexHandled[index] = true;
-							}
-							else if (tempYMax > newDepth && tempYMax <= newHeight)
-							{
-								//the column we are checking touches the current column from the bottom
-								//for this reason we extend what's below
-								
-								//We want to avoid to expend this column if it has already been expanded by
-								//this index
-								if (!indexHandled[index])
-								{
-									newDepth = tempYMin;
-									increaseIndex[index] = true;
-									indexHandled[index] = true;
-								}
-								
-							}
-							else if (tempYMin < newHeight && tempYMin > newDepth)
-							{
-								//the column we are checking touches the current column from the top
-								//for this reason we extend the top
-								newHeight = tempYMax;
-								increaseIndex[index] = true;
-							}
-						}
-						else
-						{
-							indexHandled[index] = true;
-						}
-					}
-				}
-				
-				//if we added any new data there is a chance that we could add more
-				//for this reason we would continue
-				//if no data is added than the column hasn't changed.
-				//for this reason we can start working on a new column
-				connected = false;
-				for (int index = 0; index < dataCount; index++)
-				{
-					if (increaseIndex[index])
-					{
-						connected = true;
-						indices[index]++;
-					}
-				}
-			}
-			
-			//Now we add the height and depth data we extracted to the heightAndDepth array
-			if (newDepth != newHeight)
-			{
-				if (count != 0)
-				{
-					prevDepth = heightAndDepth[(count - 1) * 2 + 1];
-					if (newHeight > prevDepth)
-					{
-						newHeight = (short) Math.min(newHeight, prevDepth);
-					}
-				}
-				heightAndDepth[count * 2] = (short) newHeight;
-				heightAndDepth[count * 2 + 1] = (short) newDepth;
-				count++;
-			}
-			
-			//Here we check the condition that makes the loop continue
-			//We stop the loop only if there is no more data to check
-			stillHasDataToCheck = false;
-			for (int index = 0; index < dataCount; index++)
-			{
-				if (indices[index] < inputVerticalSize)
-				{
-					tempData = sourceData.get(index * inputVerticalSize + indices[index]);
-					stillHasDataToCheck |= !RenderDataPointUtil.isVoid(tempData) && RenderDataPointUtil.doesDataPointExist(tempData);
-				}
-			}
-		}
-		
-		//we limit the vertical portion to maxVerticalData
-		int j = 0;
-		while (count > outputVerticalSize)
-		{
-			limited = true;
-			ii = MAX_WORLD_Y_SIZE;
-			for (i = 0; i < count - 1; i++)
-			{
-				if (heightAndDepth[i * 2 + 1] - heightAndDepth[(i + 1) * 2] <= ii)
-				{
-					ii = heightAndDepth[i * 2 + 1] - heightAndDepth[(i + 1) * 2];
-					j = i;
-				}
-			}
-			
-			heightAndDepth[j * 2 + 1] = heightAndDepth[(j + 1) * 2 + 1];
-			for (i = j + 1; i < count - 1; i++)
-			{
-				heightAndDepth[i * 2] = heightAndDepth[(i + 1) * 2];
-				heightAndDepth[i * 2 + 1] = heightAndDepth[(i + 1) * 2 + 1];
-			}
-			
-			//System.arraycopy(heightAndDepth, j + 1, heightAndDepth, j, count - j - 1);
-			count--;
-		}
-		//As standard the vertical lods are ordered from top to bottom
-		
-		if (!limited && dataCount == 1) // This mean source vertSize < output vertSize AND both dataCount == 1
-		{
-			sourceData.copyTo(output.data, output.offset, output.vertSize);
-		}
-		else
-		{
-			
-			//We want to efficiently memorize indexes
-			int[] dataIndexesCache = tDataIndexCache.get();
-			if (dataIndexesCache == null || dataIndexesCache.length != dataCount)
-			{
-				dataIndexesCache = new int[dataCount];
-				tDataIndexCache.set(dataIndexesCache);
-			}
-			Arrays.fill(dataIndexesCache, 0);
-			
-			
-			//For each lod height-depth value we have found we now want to generate the rest of the data
-			//by merging all lods at lower level that are contained inside the new ones
-			for (j = 0; j < count; j++)
-			{
-				//We firstly collect height and depth data
-				//this will be added to each realtive long DataPoint
-				yMax = heightAndDepth[j * 2];
-				yMin = heightAndDepth[j * 2 + 1];
-				
-				//if both height and depth are at 0 then we finished
-				if ((yMin == 0 && yMax == 0) || j >= heightAndDepth.length / 2)
-				{
-					break;
-				}
-				
-				//We initialize data useful for the merge
-				int numberOfChildren = 0;
-				allEmpty = true;
-				allVoid = true;
-				
-				//We initialize all the new values that we are going to put in the dataPoint
-				int tempAlpha = 0;
-				int tempRed = 0;
-				int tempGreen = 0;
-				int tempBlue = 0;
-				int tempLightBlock = 0;
-				int tempLightSky = 0;
-				long data = 0;
-				
-				//For each position that we want to merge
-				for (int index = 0; index < dataCount; index++)
-				{
-					//we scan the lods in the position from top to bottom
-					while (dataIndexesCache[index] < inputVerticalSize)
-					{
-						singleData = sourceData.get(index * inputVerticalSize + dataIndexesCache[index]);
-						if (doesDataPointExist(singleData) && !isVoid(singleData))
-						{
-							dataIndexesCache[index]++;
-							if ((yMin <= getYMin(singleData) && getYMin(singleData) < yMax)
-									|| (yMin < getYMax(singleData) && getYMax(singleData) <= yMax))
-							{
-								data = singleData;
-								break;
-							}
-						}
-						else
-						{
-							break;
-						}
-					}
-					
-					if (!doesDataPointExist(data))
-					{
-						data = createVoidDataPoint(genMode);
-					}
-					
-					if (doesDataPointExist(data))
-					{
-						allEmpty = false;
-						if (!isVoid(data))
-						{
-							numberOfChildren++;
-							allVoid = false;
-							tempAlpha = Math.max(getAlpha(data), tempAlpha);
-							tempRed += getRed(data) * getRed(data);
-							tempGreen += getGreen(data) * getGreen(data);
-							tempBlue += getBlue(data) * getBlue(data);
-							tempLightBlock += getLightBlock(data);
-							tempLightSky += getLightSky(data);
-						}
-					}
-				}
-				
-				//we have at least 1 child
-				if (dataCount != 1)
-				{
-					tempRed = tempRed / numberOfChildren;
-					tempGreen = tempGreen / numberOfChildren;
-					tempBlue = tempBlue / numberOfChildren;
-					tempLightBlock = tempLightBlock / numberOfChildren;
-					tempLightSky = tempLightSky / numberOfChildren;
-				}
-				
-				//data = createDataPoint(tempAlpha, tempRed, tempGreen, tempBlue, height, depth, tempLightSky, tempLightBlock, tempGenMode, allDefault);
-				//if (j > 0 && getColor(data) == getColor(dataPoint[j]))
-				//{
-				//	add simplification at the end due to color
-				//}
-				
-				output.set(j, createDataPoint(tempAlpha, (int) Math.sqrt(tempRed), (int) Math.sqrt(tempGreen), (int) Math.sqrt(tempBlue), yMax, yMin, tempLightSky, tempLightBlock, genMode));
-				
-			}
-		}
-		*/
 	}
 	
 }

core/src/main/java/com/seibel/distanthorizons/core/util/RenderUtil.java

@@ -48,93 +48,6 @@ public class RenderUtil
 	
 	
 	
-	//=================//
-	// culling methods //
-	//=================//
-	
-	/**
-	 * Returns if the given ChunkPos is in the loaded area of the world.
-	 *
-	 * @param center the center of the loaded world (probably the player's ChunkPos)
-	 */
-	public static boolean isChunkPosInLoadedArea(DhChunkPos pos, DhChunkPos center)
-	{
-		return (pos.x >= center.x - MC_RENDER.getRenderDistance()
-				&& pos.x <= center.x + MC_RENDER.getRenderDistance())
-				&&
-				(pos.z >= center.z - MC_RENDER.getRenderDistance()
-				&& pos.z <= center.z + MC_RENDER.getRenderDistance());
-	}
-	
-	/**
-	 * Returns if the given coordinate is in the loaded area of the world.
-	 *
-	 * @param centerCoordinate the center of the loaded world
-	 */
-	public static boolean isCoordinateInLoadedArea(int x, int z, int centerCoordinate)
-	{
-		return (x >= centerCoordinate - MC_RENDER.getRenderDistance()
-				&& x <= centerCoordinate + MC_RENDER.getRenderDistance())
-				&&
-				(z >= centerCoordinate - MC_RENDER.getRenderDistance()
-				&& z <= centerCoordinate + MC_RENDER.getRenderDistance());
-	}
-	
-	/**
-	 * Find the coordinates that are in the center half of the given
-	 * 2D matrix, starting at (0,0) and going to (2 * lodRadius, 2 * lodRadius).
-	 */
-	public static boolean isCoordinateInNearFogArea(int i, int j, int lodRadius)
-	{
-		int halfRadius = lodRadius / 2;
-		
-		return (i >= lodRadius - halfRadius
-				&& i <= lodRadius + halfRadius)
-				&&
-				(j >= lodRadius - halfRadius
-				&& j <= lodRadius + halfRadius);
-	}
-	
-	/**
-	 * Returns true if one of the region's 4 corners is in front
-	 * of the camera.
-	 */
-	public static boolean isRegionInViewFrustum(DhBlockPos playerBlockPos, Vec3f cameraDir, int vboRegionX, int vboRegionZ)
-	{
-		// convert the vbo position into a direction vector
-		// starting from the player's position
-		Vec3f vboVec = new Vec3f(vboRegionX * LodUtil.REGION_WIDTH, 0, vboRegionZ * LodUtil.REGION_WIDTH);
-		Vec3f playerVec = new Vec3f(playerBlockPos.x, playerBlockPos.y, playerBlockPos.z);
-		
-		vboVec.subtract(playerVec);
-		
-		// calculate the 4 corners
-		Vec3f vboSeVec = new Vec3f(vboVec.x + LodUtil.REGION_WIDTH, vboVec.y, vboVec.z + LodUtil.REGION_WIDTH);
-		Vec3f vboSwVec = new Vec3f(vboVec.x, vboVec.y, vboVec.z + LodUtil.REGION_WIDTH);
-		Vec3f vboNwVec = new Vec3f(vboVec.x, vboVec.y, vboVec.z);
-		Vec3f vboNeVec = new Vec3f(vboVec.x + LodUtil.REGION_WIDTH, vboVec.y, vboVec.z);
-		
-		// if any corner is visible, this region should be rendered
-		return isNormalizedVectorInViewFrustum(vboSeVec, cameraDir) ||
-				isNormalizedVectorInViewFrustum(vboSwVec, cameraDir) ||
-				isNormalizedVectorInViewFrustum(vboNwVec, cameraDir) ||
-				isNormalizedVectorInViewFrustum(vboNeVec, cameraDir);
-	}
-	
-	/**
-	 * Currently takes the dot product of the two vectors,
-	 * but in the future could do more complicated frustum culling tests.
-	 */
-	private static boolean isNormalizedVectorInViewFrustum(Vec3f objectVector, Vec3f cameraDir)
-	{
-		// the -0.1 is to offer a slight buffer, so we are
-		// more likely to render LODs and thus, hopefully prevent
-		// flickering or odd disappearances
-		return objectVector.dotProduct(cameraDir) > -0.1;
-	}
-	
-	
-	
 	//=====================//
 	// matrix manipulation //
 	//=====================//
@@ -166,19 +79,6 @@ public class RenderUtil
 		return mcModelViewMat.copy();
 	}
 	
-	/**
-	 * create and return a new combined modelView/projection matrix based on MC's modelView and projection matrices
-	 *
-	 * @param mcProjMat Minecraft's current projection matrix
-	 * @param mcModelViewMat Minecraft's current model view matrix
-	 */
-	public static Mat4f createCombinedModelViewProjectionMatrix(Mat4f mcProjMat, Mat4f mcModelViewMat, float partialTicks)
-	{
-		Mat4f lodProj = createLodProjectionMatrix(mcProjMat, partialTicks);
-		lodProj.multiply(createLodModelViewMatrix(mcModelViewMat));
-		return lodProj;
-	}
-	
 	public static float getNearClipPlaneDistanceInBlocks(float partialTicks)
 	{
 		int chunkRenderDistance = MC_RENDER.getRenderDistance();

core/src/main/java/com/seibel/distanthorizons/core/util/gridList/EdgeDistanceBooleanGrid.java

@@ -1,100 +0,0 @@
-/*
- *    This file is part of the Distant Horizons mod
- *    licensed under the GNU LGPL v3 License.
- *
- *    Copyright (C) 2020-2023 James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU Lesser General Public License as published by
- *    the Free Software Foundation, version 3.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU Lesser General Public License for more details.
- *
- *    You should have received a copy of the GNU Lesser General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.distanthorizons.core.util.gridList;
-
-import com.seibel.distanthorizons.core.pos.Pos2D;
-import com.seibel.distanthorizons.core.util.objects.BoolType;
-
-import java.util.Iterator;
-import java.util.function.IntPredicate;
-
-public class EdgeDistanceBooleanGrid extends PosArrayGridList<BoolType>
-{
-	ArrayGridList<Integer> edgeCache = null;
-	
-	public EdgeDistanceBooleanGrid(Iterator<Pos2D> posIter, int offsetX, int offsetY, int gridSize)
-	{
-		super(gridSize, offsetX, offsetY);
-		while (posIter.hasNext())
-		{
-			Pos2D p = posIter.next();
-			this.set(p, BoolType.TRUE);
-		}
-	}
-	
-	// Return false if it is indeed updated
-	private static boolean updatePos(ArrayGridList<Integer> grid, int ox, int oy)
-	{
-		if (grid.get(ox, oy) < 0) return true;
-		if (ox == 0 || oy == 0 || ox == grid.gridSize - 1 || oy == grid.gridSize - 1)
-		{
-			return true;
-		}
-		
-		int v = grid.get(ox, oy);
-		if (
-				grid.get(ox, oy + 1) < v ||
-						grid.get(ox, oy - 1) < v ||
-						grid.get(ox + 1, oy) < v ||
-						grid.get(ox - 1, oy) < v
-		)
-		{
-			return true;
-		}
-		else
-		{
-			grid.set(ox, oy, v + 1);
-			return false;
-		}
-	}
-	
-	//FIXME: This is slow and expensive. Use queue to make this skip recheck done pos
-	private void computeEdgeCache()
-	{
-		if (edgeCache != null) return;
-		
-		edgeCache = new ArrayGridList<Integer>(gridSize, (ox, oy) -> {
-			BoolType b = get(ox + getOffsetX(), oy + getOffsetY());
-			return b == null ? -1 : 0;
-		});
-		
-		final boolean[] isDone = {false};
-		while (!isDone[0])
-		{
-			isDone[0] = true;
-			edgeCache.forEachPos((ox, oy) -> {
-				isDone[0] &= updatePos(edgeCache, ox, oy);
-			});
-		}
-	}
-	
-	// 0 means right on the edge, while 1 means 1 ceil away. Uses Manhattan Distance
-	public <T extends ArrayGridList<BoolType>> void flagAllWithDistance(T list, IntPredicate predicate)
-	{
-		computeEdgeCache();
-		edgeCache.forEachPos((ox, oy) -> {
-			int v = edgeCache.get(ox, oy);
-			if (v < 0 || !predicate.test(v)) return;
-			list.set(ox + getOffsetX(), oy + getOffsetY(), BoolType.TRUE);
-		});
-	}
-	
-	
-}

core/src/main/java/com/seibel/distanthorizons/core/wrapperInterfaces/chunk/ChunkLightStorage.java

@@ -141,6 +141,25 @@ public class ChunkLightStorage
 		lightSection.set(x, y, z, lightLevel);
 	}
 	
+	public void clear() 
+	{
+		if (this.lightSections != null)
+		{
+			for (int i = 0; i < this.lightSections.length; i++)
+			{
+				LightSection section = this.lightSections[i];
+				if (section != null)
+				{
+					section.constantValue = LodUtil.MIN_MC_LIGHT;
+					if (section.data != null)
+					{
+						Arrays.fill(section.data, 0L);
+					}
+				}
+			}
+		}
+	}
+	
 	
 	
 	//================//

core/src/main/java/com/seibel/distanthorizons/core/wrapperInterfaces/chunk/IChunkWrapper.java

@@ -25,6 +25,7 @@ import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.sql.dto.BeaconBeamDTO;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import com.seibel.distanthorizons.coreapi.interfaces.dependencyInjection.IBindable;
 import com.seibel.distanthorizons.core.util.LodUtil;
@@ -79,9 +80,11 @@ public interface IChunkWrapper extends IBindable
 	
 	int getDhSkyLight(int relX, int relY, int relZ);
 	void setDhSkyLight(int relX, int relY, int relZ, int lightValue);
+	void clearDhSkyLighting();
 	
 	int getDhBlockLight(int relX, int relY, int relZ);
 	void setDhBlockLight(int relX, int relY, int relZ, int lightValue);
+	void clearDhBlockLighting();
 	
 	int getBlockLight(int relX, int relY, int relZ);
 	int getSkyLight(int relX, int relY, int relZ);
@@ -150,29 +153,77 @@ public interface IChunkWrapper extends IBindable
 	 * This is generally done in cases where MC's lighting is correct now, but may not be later (like when a chunk is unloading).
 	 *
 	 * @throws IllegalStateException if the chunk's lighting isn't valid. This is done to prevent accidentally baking broken lighting.
+	 * @return true if the chunk's lighting was successfully populated, false otherwise
 	 */
-	default void bakeDhLightingUsingMcLightingEngine() throws IllegalStateException
+	@Deprecated
+	default boolean bakeDhLightingUsingMcLightingEngine(ILevelWrapper levelWrapper) throws IllegalStateException
 	{
 		if (!this.isLightCorrect())
 		{
-			throw new IllegalStateException("Unable to bake lighting for for chunk [" + this.getChunkPos() + "], Minecraft lighting not valid.");
+			return false;
 		}
 		
-		// get the lighting for every relative block pos
+		//=======================//
+		// get lighting for each //
+		// relative block pos    //
+		//=======================//
+		
+		boolean lightingFound = false;
+		// if the level doesn't have sky lights, then this check can be ignored
+		// since all sky light values will be 0 anyway
+		boolean skyLightingFound = !levelWrapper.hasSkyLight();
+		
 		for (int relX = 0; relX < LodUtil.CHUNK_WIDTH; relX++)
 		{
 			for (int relZ = 0; relZ < LodUtil.CHUNK_WIDTH; relZ++)
 			{
 				for (int y = this.getMinBuildHeight(); y < this.getMaxBuildHeight(); y++)
 				{
-					this.setDhSkyLight(relX, y, relZ, this.getSkyLight(relX, y, relZ));
-					this.setDhBlockLight(relX, y, relZ, this.getBlockLight(relX, y, relZ));
+					int skyLight = this.getSkyLight(relX, y, relZ);
+					this.setDhSkyLight(relX, y, relZ, skyLight);
+					int blockLight = this.getBlockLight(relX, y, relZ);
+					this.setDhBlockLight(relX, y, relZ, blockLight);
+					
+					// MC defaults to max sky light and no block light, including underground blocks.
+					// If any position has something different then those default values, it's likely that the
+					// lighting was properly populated for at least part of the chunk
+					if (!lightingFound &&
+						(skyLight != LodUtil.MAX_MC_LIGHT || blockLight != LodUtil.MIN_MC_LIGHT))
+					{
+						lightingFound = true;
+					}
+					
+					if (!skyLightingFound
+						&& skyLight != LodUtil.MIN_MC_LIGHT)
+					{
+						skyLightingFound = true;
+					}
 				}
 			}
 		}
 		
+		
+		
+		//=================//
+		// validate result //
+		//=================//
+		
+		// if no lighting was found or the sky is always black, the lighting is likely broken
+		if (!lightingFound || !skyLightingFound
+			// if lighting is no longer correct or doesn't match the saved values
+			// its very likely it broke halfway through and will need regenerating
+			|| !this.isLightCorrect()
+			|| this.getSkyLight(0, 0, 0) != this.getDhSkyLight(0,0,0)
+			|| this.getBlockLight(0, 0, 0) != this.getDhBlockLight(0,0,0))
+		{
+			return false;
+		}
+		
+		
+		// lighting is valid
 		this.setIsDhLightCorrect(true);
 		this.setUseDhLighting(true);
+		return true;
 	}
 	
 	
@@ -229,18 +280,42 @@ public interface IChunkWrapper extends IBindable
 		int hash = 31;
 		int primeBlockMultiplier = 227;
 		int primeBiomeMultiplier = 701;
+		int primeHeightMultiplier = 137;
 		
-		int minBuildHeight = this.getMinBuildHeight();
-		int maxBuildHeight = this.getMaxBuildHeight();
+		int minBuildHeight = this.getMaxNonEmptyHeight();
+		int maxBuildHeight = this.getMinNonEmptyHeight();
 		
+		
+		// most blocks (only some blocks are sampled since checking every block is a very slow operation)
+		for (int x = 0; x < LodUtil.CHUNK_WIDTH; x+=2)
+		{
+			for (int z = 0; z < LodUtil.CHUNK_WIDTH; z+=2)
+			{
+				for (int y = minBuildHeight; y < maxBuildHeight; y+=8)
+				{
+					hash = (hash * primeBlockMultiplier) + this.getBlockState(x, y, z).hashCode();
+					hash = (hash * primeBiomeMultiplier) + this.getBiome(x, y, z).hashCode();
+					hash = (hash * primeHeightMultiplier) + y;
+				}
+			}
+		}
+		
+		// surface (this should cover most cases for when users modify chunks)
 		for (int x = 0; x < LodUtil.CHUNK_WIDTH; x++)
 		{
 			for (int z = 0; z < LodUtil.CHUNK_WIDTH; z++)
 			{
-				for (int y = minBuildHeight; y < maxBuildHeight; y++)
+				int lightBlockingY = this.getLightBlockingHeightMapValue(x, z);
+				hash = (hash * primeBlockMultiplier) + this.getBlockState(x, lightBlockingY, z).hashCode();
+				hash = (hash * primeBiomeMultiplier) + this.getBiome(x, lightBlockingY, z).hashCode();
+				hash = (hash * primeHeightMultiplier) + lightBlockingY;
+				
+				int solidY = this.getSolidHeightMapValue(x, z);
+				if (solidY != lightBlockingY)
 				{
-					hash = (hash * primeBlockMultiplier) + this.getBlockState(x, y, z).hashCode();
-					hash = (hash * primeBiomeMultiplier) + this.getBiome(x, y, z).hashCode();
+					hash = (hash * primeBlockMultiplier) + this.getBlockState(x, solidY, z).hashCode();
+					hash = (hash * primeBiomeMultiplier) + this.getBiome(x, solidY, z).hashCode();
+					hash = (hash * primeHeightMultiplier) + solidY;
 				}
 			}
 		}

core/src/main/java/com/seibel/distanthorizons/core/wrapperInterfaces/minecraft/IMinecraftRenderWrapper.java

@@ -48,18 +48,10 @@ public interface IMinecraftRenderWrapper extends IBindable
 {
 	Vec3f getLookAtVector();
 	
-	DhBlockPos getCameraBlockPosition();
-	
 	boolean playerHasBlindingEffect();
 	
 	Vec3d getCameraExactPosition();
 	
-	Mat4f getWorldViewMatrix();
-	
-	Mat4f getDefaultProjectionMatrix(float partialTicks);
-	
-	double getGamma();
-	
 	Color getFogColor(float partialTicks);
 	
 	default Color getSpecialFogColor(float partialTicks) { return getFogColor(partialTicks); }
@@ -90,63 +82,6 @@ public interface IMinecraftRenderWrapper extends IBindable
 	 */
 	void clearTargetFrameBuffer();
 	
-	/**
-	 * This method returns the ChunkPos of all chunks that Minecraft
-	 * is going to render this frame.
-	 * <br>
-	 * If not implemented this calls {@link #getMaximumRenderedChunks()}.
-	 */
-	default HashSet<DhChunkPos> getVanillaRenderedChunks()
-	{
-		// FIXME: Is this actually required? Does it make a differance if it exists or not?
-		ISodiumAccessor sodium = ModAccessorInjector.INSTANCE.get(ISodiumAccessor.class);
-		return sodium == null ? getMaximumRenderedChunks() : sodium.getNormalRenderedChunks();
-	}
-	
-	static boolean correctedCheckRadius(int dx, int dz, int radius2Mul4)
-	{
-		dx = dx * 2;// + (dx < 0 ? -1 : 1);
-		dz = dz * 2;// + (dz < 0 ? -1 : 1);
-		return (dx * dx + dz * dz <= radius2Mul4);
-	}
-	
-	/**
-	 * <strong>Doesn't need to be implemented.</strong> <br>
-	 * Returns every chunk position within the vanilla render distance.
-	 */
-	default HashSet<DhChunkPos> getMaximumRenderedChunks()
-	{
-		IMinecraftClientWrapper mcWrapper = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
-		IWrapperFactory factory = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
-		IVersionConstants versionConstants = SingletonInjector.INSTANCE.get(IVersionConstants.class);
-		IMinecraftClientWrapper minecraft = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
-		ILevelWrapper clientWorld = minecraft.getWrappedClientLevel();
-		
-		int chunkDist = this.getRenderDistance() + 1; // For some reason having '+1' is actually closer to real value
-		
-		DhChunkPos centerChunkPos = mcWrapper.getPlayerChunkPos();
-		int centerChunkX = centerChunkPos.x;
-		int centerChunkZ = centerChunkPos.z;
-		int chunkDist2Mul4 = chunkDist * chunkDist * 4;
-		
-		// add every position within render distance
-		HashSet<DhChunkPos> renderedPos = new HashSet<DhChunkPos>();
-		for (int deltaChunkX = -chunkDist; deltaChunkX <= chunkDist; deltaChunkX++)
-		{
-			for (int deltaChunkZ = -chunkDist; deltaChunkZ <= chunkDist; deltaChunkZ++)
-			{
-				if (!versionConstants.isVanillaRenderedChunkSquare() &&
-						!correctedCheckRadius(deltaChunkX, deltaChunkZ, chunkDist2Mul4))
-				{
-					continue;
-				}
-				if (!clientWorld.hasChunkLoaded(centerChunkX + deltaChunkX, centerChunkZ + deltaChunkZ)) continue;
-				renderedPos.add(new DhChunkPos(centerChunkX + deltaChunkX, centerChunkZ + deltaChunkZ));
-			}
-		}
-		return renderedPos;
-	}
-	
 	/** Can return null if the given level hasn't had a light map assigned to it */
 	@Nullable
 	ILightMapWrapper getLightmapWrapper(ILevelWrapper level);

core/src/main/java/com/seibel/distanthorizons/core/wrapperInterfaces/modAccessor/ISodiumAccessor.java

@@ -25,8 +25,6 @@ import java.util.HashSet;
 
 public interface ISodiumAccessor extends IModAccessor
 {
-	HashSet<DhChunkPos> getNormalRenderedChunks();
-	
 	/** A temporary overwrite for a config in sodium 0.5 to fix their terrain from showing, will be removed once a proper fix is added */
 	void setFogOcclusion(boolean b); // FIXME
 	

core/src/main/java/com/seibel/distanthorizons/core/wrapperInterfaces/world/IClientLevelWrapper.java

@@ -19,8 +19,6 @@
 
 package com.seibel.distanthorizons.core.wrapperInterfaces.world;
 
-import com.seibel.distanthorizons.core.level.IDhClientLevel;
-import com.seibel.distanthorizons.core.level.IDhLevel;
 import com.seibel.distanthorizons.core.pos.DhBlockPos;
 import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
 import org.jetbrains.annotations.Nullable;
@@ -34,10 +32,10 @@ public interface IClientLevelWrapper extends ILevelWrapper
 	@Nullable
 	IServerLevelWrapper tryGetServerSideWrapper();
 	
-	int computeBaseColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper blockState);
-	
+	int getBlockColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper blockState);
 	/** @return -1 if there was a problem getting the color */
 	int getDirtBlockColor();
+	void clearBlockColorCache();
 	
 	/** Will return null if there was an issue finding the biome. */
 	@Nullable

core/src/main/resources/assets/distanthorizons/lang/en_us.json

@@ -491,14 +491,20 @@
   "distanthorizons.config.client.advanced.debugging.allowUnsafeValues.@tooltip":
     "If enabled, very limited config input validation will be performed. \n\nWarning: enabling this can cause instability or crashing, use at your own risk. \nNote: this option isn't saved between sessions.",
   
-    "distanthorizons.config.client.advanced.debugging.columnBuilderDebugEnable":
+  "distanthorizons.config.client.advanced.debugging.columnBuilderDebugEnable":
     "Enable Column Builder Limiting",
-    "distanthorizons.config.client.advanced.debugging.columnBuilderDebugDetailLevel":
+  "distanthorizons.config.client.advanced.debugging.columnBuilderDebugDetailLevel":
     "Column Builder Limit - Detail Level",
-    "distanthorizons.config.client.advanced.debugging.columnBuilderDebugXPos":
+  "distanthorizons.config.client.advanced.debugging.columnBuilderDebugXPos":
     "Column Builder Limit - X Pos",
-    "distanthorizons.config.client.advanced.debugging.columnBuilderDebugZPos":
+  "distanthorizons.config.client.advanced.debugging.columnBuilderDebugZPos":
     "Column Builder Limit - Z Pos",
+  "distanthorizons.config.client.advanced.debugging.columnBuilderDebugXRow":
+    "Column Builder Limit - X Row",
+  "distanthorizons.config.client.advanced.debugging.columnBuilderDebugZRow":
+    "Column Builder Limit - Z Row",
+  "distanthorizons.config.client.advanced.debugging.columnBuilderDebugColumnIndex":
+    "Column Builder Limit - Col Index",
   
     
   "distanthorizons.config.client.advanced.buffers":
@@ -560,6 +566,8 @@
     "Show Low Memory Warning",
   "distanthorizons.config.client.advanced.logging.showReplayWarningOnStartup":
     "Show Replay Warning",
+  "distanthorizons.config.client.advanced.logging.showModCompatibilityWarningsOnStartup":
+    "Show Mod Compatibility Warnings",
     
     
     

core/src/test/java/testItems/lightingEngine/LightingTestChunkWrapper.java

@@ -350,6 +350,8 @@ public class LightingTestChunkWrapper implements IChunkWrapper
 		}
 		return this.blockLightStorage;
 	}
+	@Override
+	public void clearDhBlockLighting() { throw new UnsupportedOperationException("Not implemented"); }
 	
 	
 	@Override
@@ -364,6 +366,8 @@ public class LightingTestChunkWrapper implements IChunkWrapper
 		this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, y, relZ);
 		this.getSkyLightStorage().set(relX, y, relZ, lightValue);
 	}
+	@Override
+	public void clearDhSkyLighting() { throw new UnsupportedOperationException("Not implemented"); }
 	
 	private ChunkLightStorage getSkyLightStorage()
 	{