Add complete multidraw

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 LOD
+ * Detail levels in Distant Horizons represent how large a section (of either LODs or MC chunks)
  * 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,12 +23,13 @@ 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 3.0.0
+ * @since API 2.0.0
  */
 public enum EDhApiGpuUploadMethod
 {
@@ -48,10 +49,7 @@ 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,7 +21,6 @@ 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,7 +19,6 @@
 
 package com.seibel.distanthorizons.api.interfaces.block;
 
-import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
 import com.seibel.distanthorizons.api.interfaces.IDhApiUnsafeWrapper;
 
 /**
@@ -45,11 +44,7 @@ public interface IDhApiBlockStateWrapper extends IDhApiUnsafeWrapper
 	 * @since API 3.0.0 
 	 */
 	String getSerialString();
-	/**
-	 * Returns the byte value representing the {@link EDhApiBlockMaterial} enum.
-	 * @see EDhApiBlockMaterial 
-	 * @since API 3.0.0 
-	 */
+	/** @since API 3.0.0 */
 	byte getMaterialId();
 	
 }

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

@@ -36,6 +36,7 @@ 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

@@ -0,0 +1,39 @@
+/*
+ *    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();
+	
+}

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

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

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

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

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

@@ -90,29 +90,11 @@ public interface IDhApiWorldGenerator extends Closeable, IDhApiOverrideable
 	 */
 	default byte getMaxGenerationGranularity() { return (byte) (EDhApiDetailLevel.CHUNK.detailLevel + 2); }
 	
-	/**
-	 * 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
-	 */
-	@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
+	 * @return true if the generator is unable to accept new generation requests.
+	 * @since API 1.0.0
 	 */
-	default boolean runApiChunkValidation() { return true; }
+	boolean isBusy();
 	
 	
 	
@@ -172,7 +154,6 @@ public interface IDhApiWorldGenerator extends Closeable, IDhApiOverrideable
 	 *
 	 * After the {@link DhApiChunk} has been generated, it should be passed into the
 	 * resultConsumer's {@link Consumer#accept(Object)} method.
-	 * Note: if air blocks aren't included in the with the {@link DhApiChunk} with proper lighting, lower detail levels will appear as black/unlit.
 	 *
 	 * @implNote the default implementation of this method throws an {@link UnsupportedOperationException},
 	 * and must be overridden when {@link #getReturnType()} returns {@link EDhApiWorldGeneratorReturnType#API_CHUNKS}.

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

@@ -26,7 +26,7 @@ import com.seibel.distanthorizons.api.objects.DhApiResult;
  * Used to interact with Distant Horizons' rendering system.
  *
  * @author James Seibel
- * @version 2024-7-27
+ * @version 2023-10-13
  * @since API 1.0.0
  */
 public interface IDhApiRenderProxy
@@ -39,8 +39,10 @@ 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>
-	 * 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>
+	 * 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.
 	 */
 	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 2024-7-28
+ * @version 2022-7-14
  * @since API 1.0.0
  */
 public interface IDhApiLevelWrapper extends IDhApiUnsafeWrapper
@@ -41,18 +41,7 @@ public interface IDhApiLevelWrapper extends IDhApiUnsafeWrapper
 	
 	boolean hasSkyLight();
 	
-	/** 
-	 * 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 
-	 */
+	/** Returns the max block height of the level(?) */
 	int getMaxHeight();
 	
 	/**
@@ -64,8 +53,6 @@ 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,17 +21,15 @@ package com.seibel.distanthorizons.api.objects.data;
 
 import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory;
 import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator;
-import org.apache.logging.log4j.LogManager;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 /**
  * Contains a list of {@link DhApiTerrainDataPoint} representing the blocks in a Minecraft chunk.
  *
  * @author Builderb0y, James Seibel
- * @version 2024-7-21
+ * @version 2023-12-21
  * @since API 2.0.0
  * 
  * @see IDhApiWrapperFactory
@@ -43,8 +41,8 @@ public class DhApiChunk
 	public final int chunkPosX;
 	public final int chunkPosZ;
 	
-	public final int bottomYBlockPos;
 	public final int topYBlockPos;
+	public final int bottomYBlockPos;
 	
 	private final List<List<DhApiTerrainDataPoint>> dataPoints;
 	
@@ -54,32 +52,12 @@ public class DhApiChunk
 	// constructors //
 	//==============//
 	
-	/** 
-	 * Deprecated due to the topYBlockPos and bottomYBlockPos variables being put in the wrong order. 
-	 * They should have been in bottom -> top order. 
-	 * 
-	 * @see DhApiChunk#create(int, int, int, int) 
-	 */
-	@Deprecated
 	public DhApiChunk(int chunkPosX, int chunkPosZ, int topYBlockPos, int bottomYBlockPos) 
-	{ this(chunkPosX, chunkPosZ, bottomYBlockPos, topYBlockPos, false); }
-	
-	/**
-	 * @since API 3.0.0 
-	 */
-	public static DhApiChunk create(int chunkPosX, int chunkPosZ, int bottomYBlockPos, int topYBlockPos)
-	{ return new DhApiChunk(chunkPosX, chunkPosZ, bottomYBlockPos, topYBlockPos, false); }
-	
-	/** 
-	 * Only visible to internal DH methods 
-	 * @param ignoredParameter is only present to differentiate the two constructors and isn't actually used
-	 */
-	private DhApiChunk(int chunkPosX, int chunkPosZ, int bottomYBlockPos, int topYBlockPos, boolean ignoredParameter)
 	{
 		this.chunkPosX = chunkPosX;
 		this.chunkPosZ = chunkPosZ;
-		this.bottomYBlockPos = bottomYBlockPos;
 		this.topYBlockPos = topYBlockPos;
+		this.bottomYBlockPos = bottomYBlockPos;
 		
 		// populate the array to prevent null pointers
 		this.dataPoints = new ArrayList<>(16 * 16); // 256
@@ -116,34 +94,27 @@ 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);
 		
-		if (dataPoints == null)
+		// validate the incoming datapoints
+		if (dataPoints != null)
 		{
-			// 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.");
+			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].");
+				}
+			}
 		}
 		
-		
-		
-		//================//
-		// set datapoints //
-		//================//
-		
-		List<DhApiTerrainDataPoint> column = this.dataPoints.get(internalArrayIndex);
-		if (column == null)
-		{
-			column = new ArrayList<>();
-			this.dataPoints.set(internalArrayIndex, column);
-		}
-		column.addAll(dataPoints); 
+		this.dataPoints.set((relZ << 4) | relX, dataPoints); 
 	}
 	
 	

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

@@ -19,17 +19,14 @@
 
 package com.seibel.distanthorizons.api.objects.data;
 
-import com.seibel.distanthorizons.api.enums.EDhApiDetailLevel;
 import com.seibel.distanthorizons.api.interfaces.block.IDhApiBiomeWrapper;
 import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper;
 
-import java.util.ArrayList;
-
 /**
  * Holds a single datapoint of terrain data.
  *
  * @author James Seibel
- * @version 2024-7-20
+ * @version 2022-11-13
  * @since API 1.0.0
  */
 public class DhApiTerrainDataPoint
@@ -40,79 +37,27 @@ public class DhApiTerrainDataPoint
 	 * 2 = 4x4 blocks <br>
 	 * 4 = chunk (16x16 blocks) <br>
 	 * 9 = region (512x512 blocks) <br>
-	 * 
-	 * @see EDhApiDetailLevel
 	 */
 	public final byte detailLevel;
 	
 	public final int blockLightLevel;
 	public final int skyLightLevel;
-	public final int bottomYBlockPos;
 	public final int topYBlockPos;
+	public final int bottomYBlockPos;
 	
 	public final IDhApiBlockStateWrapper blockStateWrapper;
 	public final 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
-		)
+	public DhApiTerrainDataPoint(byte detailLevel, int blockLightLevel, int skyLightLevel, int topYBlockPos, int bottomYBlockPos, IDhApiBlockStateWrapper blockStateWrapper, IDhApiBiomeWrapper biomeWrapper)
 	{
 		this.detailLevel = detailLevel;
 		
 		this.blockLightLevel = blockLightLevel;
 		this.skyLightLevel = skyLightLevel;
-		this.bottomYBlockPos = bottomYBlockPos;
 		this.topYBlockPos = topYBlockPos;
+		this.bottomYBlockPos = bottomYBlockPos;
 		
 		this.blockStateWrapper = blockStateWrapper;
 		this.biomeWrapper = biomeWrapper;

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.2.0-a";
+	public static final String VERSION = "2.1.3-a-dev";
 	/** Returns true if the current build is an unstable developer build, false otherwise. */
 	public static boolean IS_DEV_BUILD = VERSION.toLowerCase().contains("dev");
 	

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

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

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

@@ -19,17 +19,18 @@
 
 package com.seibel.distanthorizons.coreapi.util;
 
-import java.util.ArrayList;
+import java.text.CharacterIterator;
+import java.text.StringCharacterIterator;
 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,6 +68,8 @@ 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
@@ -84,19 +87,24 @@ public class StringUtil
 	}
 	
 	/**
-	 * Returns a shortened version of the given string that is no longer than maxLength. <br>
-	 * If null returns the empty string.
+	 * Source:
+	 * https://stackoverflow.com/questions/3758606/how-can-i-convert-byte-size-into-a-human-readable-format-in-java#3758880
 	 */
-	public static String shortenString(String str, int maxLength)
+	public static String convertByteCountToHumanReadableSI(long bytes)
 	{
-		if (str == null)
+		if (-1000 < bytes && bytes < 1000)
 		{
-			return "";
+			return bytes + " B";
 		}
-		else
+		
+		CharacterIterator ci = new StringCharacterIterator("kMGTPE");
+		while (bytes <= -999_950 || bytes >= 999_950)
 		{
-			return str.substring(0, Math.min(str.length(), maxLength));
+			bytes /= 1000;
+			ci.next();
 		}
+		
+		return String.format("%.1f %cB", bytes / 1000.0, ci.current());
 	}
 	
 }

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

@@ -42,6 +42,8 @@ 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

@@ -0,0 +1,39 @@
+/*
+ *    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); }
+	
+}

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

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

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

@@ -23,7 +23,6 @@ import com.seibel.distanthorizons.api.DhApi;
 import com.seibel.distanthorizons.api.enums.rendering.EDhApiRenderPass;
 import com.seibel.distanthorizons.api.methods.events.abstractEvents.*;
 import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
-import com.seibel.distanthorizons.core.file.structure.ClientOnlySaveStructure;
 import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager;
 import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.render.DhApiRenderProxy;
@@ -54,7 +53,6 @@ import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.Nullable;
 import org.lwjgl.glfw.GLFW;
 
-import java.io.File;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Queue;
@@ -127,28 +125,9 @@ public class ClientApi
 	public synchronized void onClientOnlyConnected()
 	{
 		// only continue if the client is connected to a different server
-		boolean connectedToServer = MC.clientConnectedToDedicatedServer();
-		boolean connectedToReplay = MC.connectedToReplay();
-		if (connectedToServer || connectedToReplay)
+		if (MC.clientConnectedToDedicatedServer())
 		{
-			if (connectedToServer)
-			{
-				LOGGER.info("Client on ClientOnly mode connecting.");
-			}
-			else
-			{
-				LOGGER.info("Replay on ClientServer mode connecting.");
-				
-				if (Config.Client.Advanced.Logging.showReplayWarningOnStartup.get())
-				{
-					MC.sendChatMessage("\u00A76" + "Distant Horizons: Replay detected." + "\u00A7r"); // gold color
-					MC.sendChatMessage("DH may behave strangely or have missing functionality.");
-					MC.sendChatMessage("In order to use pre-generated LODs, put your DH database(s) in:");
-					MC.sendChatMessage("\u00A77"+".Minecraft" + File.separator + ClientOnlySaveStructure.SERVER_DATA_FOLDER_NAME + File.separator + ClientOnlySaveStructure.REPLAY_SERVER_FOLDER_NAME + File.separator + "DIMENSION_NAME"+"\u00A7r"); // light gray color
-					MC.sendChatMessage("This can be disabled in DH's config under Advanced -> Logging.");
-					MC.sendChatMessage("");
-				}
-			}
+			LOGGER.info("Client on ClientOnly mode connecting.");
 			
 			// firing after clientLevelLoadEvent
 			// TODO if level has prepped to load it should fire level load event
@@ -497,7 +476,7 @@ public class ClientApi
 	{
 		// logging //
 		
-		this.sendQueuedChatMessages();
+		this.sendChatMessagesNow();
 		
 		IProfilerWrapper profiler = MC.getProfiler();
 		profiler.pop(); // get out of "terrain"
@@ -660,7 +639,7 @@ public class ClientApi
 		}
 	}
 	
-	private void sendQueuedChatMessages()
+	private void sendChatMessagesNow()
 	{
 		// dev build
 		if (ModInfo.IS_DEV_BUILD && !this.configOverrideReminderPrinted && MC.playerExists())
@@ -668,12 +647,10 @@ public class ClientApi
 			this.configOverrideReminderPrinted = true;
 			
 			// remind the user that this is a development build
-			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);
+			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("");
 		}
 		
 		// memory
@@ -688,13 +665,11 @@ public class ClientApi
 			long maxMemoryInBytes = Runtime.getRuntime().maxMemory();
 			if (maxMemoryInBytes < minimumRecommendedMemoryInBytes)
 			{
-				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);
+				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("");
 			}
 		}
 		

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

@@ -24,7 +24,6 @@ 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;
@@ -32,7 +31,6 @@ 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;
@@ -48,7 +46,6 @@ 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
@@ -142,13 +139,23 @@ 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)
 	{
@@ -321,50 +328,36 @@ public class SharedApi
 					}
 					
 					
-					// 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)
+					// 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())
 					{
-						// 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())
+						try
 						{
 							// If MC's lighting engine isn't thread safe this may cause the server thread to lag
-							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();
-							}
+							chunkWrapper.bakeDhLightingUsingMcLightingEngine();
 						}
-						
-						// something went wrong during the baking process so we have to generate the lighting ourselves
-						if (!chunkLightPopulated)
+						catch (IllegalStateException e)
 						{
-							DhLightingEngine.INSTANCE.lightChunk(chunkWrapper, nearbyChunkList, dhLevel.hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT);
+							LOGGER.warn("Chunk light baking error: " + e.getMessage(), e);
 						}
 					}
 					else
 					{
-						DhLightingEngine.INSTANCE.lightChunk(chunkWrapper, nearbyChunkList, dhLevel.hasSkyLight() ? LodUtil.MAX_MC_LIGHT : LodUtil.MIN_MC_LIGHT);
+						// generate the chunk's lighting, using neighboring chunks if present
+						DhLightingEngine.INSTANCE.lightChunk(chunkWrapper, nearbyChunkList, dhLevel.hasSkyLight() ? 15 : 0);
 					}
 					
 					
 					
-					
-					
 					// get this chunk's active beacons
 					List<BeaconBeamDTO> beaconBeamList = chunkWrapper.getAllActiveBeacons(nearbyChunkList);
 					dhLevel.setBeaconBeamsForChunk(chunkWrapper.getChunkPos(), beaconBeamList);
 					
 					
-					dhLevel.updateChunkAsync(chunkWrapper, newChunkHash);
+					dhLevel.updateChunkAsync(chunkWrapper);
+					dhLevel.setChunkHash(chunkWrapper.getChunkPos(), newChunkHash);
 				}
 				catch (Exception e)
 				{

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

@@ -20,20 +20,17 @@
 package com.seibel.distanthorizons.core.config;
 
 
-import com.seibel.distanthorizons.api.DhApi;
 import com.seibel.distanthorizons.api.enums.config.*;
 import com.seibel.distanthorizons.api.enums.config.quickOptions.*;
 import com.seibel.distanthorizons.api.enums.rendering.*;
 import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiDistantGeneratorMode;
 import com.seibel.distanthorizons.core.config.eventHandlers.*;
 import com.seibel.distanthorizons.core.config.eventHandlers.presets.*;
-import com.seibel.distanthorizons.core.config.listeners.ConfigChangeListener;
 import com.seibel.distanthorizons.core.config.types.*;
 import com.seibel.distanthorizons.core.config.types.enums.*;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
-import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
 import com.seibel.distanthorizons.coreapi.ModInfo;
 import com.seibel.distanthorizons.coreapi.util.StringUtil;
@@ -54,6 +51,7 @@ 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
@@ -125,6 +123,7 @@ 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();
@@ -177,7 +176,6 @@ 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>()
@@ -199,7 +197,6 @@ 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,7 +208,6 @@ 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>()
@@ -223,7 +219,6 @@ public class Config
 									+ "False: skipped blocks will not change color of surface below them. "
 									+ "")
 							.setPerformance(EConfigEntryPerformance.NONE)
-							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 					// TODO fixme
@@ -589,7 +584,6 @@ 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)
@@ -600,7 +594,6 @@ 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>()
@@ -615,15 +608,12 @@ 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();
 					
 					public static ConfigEntry<Integer> caveCullingHeight = new ConfigEntry.Builder<Integer>()
-							.setMinDefaultMax(-4096, 60, 4096)
+							.setMinDefaultMax(-4096, 40, 4096)
 							.comment(""
-									+ "At what Y value should cave culling start? \n"
-									+ "Lower this value if you get walls for areas with 0 light.")
-							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
+									+ "At what Y value should cave culling start?")
 							.build();
 					
 					public static ConfigEntry<Integer> earthCurveRatio = new ConfigEntry.Builder<Integer>()
@@ -661,7 +651,6 @@ 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>()
@@ -696,7 +685,6 @@ public class Config
 									+ EDhApiGrassSideRendering.AS_DIRT + ": sides render entirely as dirt. \n"
 									+ "")
 							.setPerformance(EConfigEntryPerformance.NONE)
-							.addListener(ReloadLodsConfigEventHandler.INSTANCE)
 							.build();
 					
 				}
@@ -780,10 +768,8 @@ 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"
@@ -857,47 +843,13 @@ public class Config
 								+ "")
 						.build();
 				
-				public static ConfigEntry<String> ignoredRenderBlockCsv = new ConfigEntry.Builder<String>()
-						.set("minecraft:barrier,minecraft:structure_void,minecraft:light,minecraft:tripwire")
-						.comment(""
-								+ "A comma separated list of block resource locations that won't be rendered by DH. \n"
-								+ "Note: air is always included in this list. \n"
-								+ "")
-						.build();
+				//public static ConfigEntry<Boolean> showMigrationChatWarning = new ConfigEntry.Builder<Boolean>()
+				//		.set(true)
+				//		.comment(""
+				//				+ "Determines if a message should be displayed in the chat when LOD migration starts. \n"
+				//				+ "")
+				//		.build();
 				
-				public static ConfigEntry<String> ignoredRenderCaveBlockCsv = new ConfigEntry.Builder<String>()
-						.set("minecraft:glow_lichen,minecraft:rail,minecraft:water,minecraft:lava,minecraft:bubble_column")
-						.comment(""
-								+ "A comma separated list of block resource locations that shouldn't be rendered \n"
-								+ "if they are in a 0 sky light underground area. \n"
-								+ "Note: air is always included in this list. \n"
-								+ "")
-						.build();
-				
-				static
-				{
-					ignoredRenderBlockCsv.addListener(new ConfigChangeListener<String>(Config.Client.Advanced.LodBuilding.ignoredRenderBlockCsv, 
-							(blockCsv) -> 
-							{
-								IWrapperFactory wrapperFactory = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
-								if (wrapperFactory != null)
-								{
-									wrapperFactory.resetRendererIgnoredBlocksSet();
-									DhApi.Delayed.renderProxy.clearRenderDataCache();
-								}
-							}));
-					
-					ignoredRenderCaveBlockCsv.addListener(new ConfigChangeListener<String>(Config.Client.Advanced.LodBuilding.ignoredRenderCaveBlockCsv, 
-							(blockCsv) -> 
-							{
-								IWrapperFactory wrapperFactory = SingletonInjector.INSTANCE.get(IWrapperFactory.class);
-								if (wrapperFactory != null)
-								{
-									wrapperFactory.resetRendererIgnoredCaveBlocks();
-									DhApi.Delayed.renderProxy.clearRenderDataCache();
-								}
-							}));
-				}
 			}
 			
 			public static class Multiplayer
@@ -1071,6 +1023,39 @@ 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 class AutoUpdater
 			{
 				public static ConfigEntry<Boolean> enableAutoUpdater = new ConfigEntry.Builder<Boolean>()
@@ -1102,63 +1087,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_AND_INFO_TO_FILE)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
 						.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_AND_INFO_TO_FILE)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
 						.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_AND_INFO_TO_FILE)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
 						.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_AND_INFO_TO_FILE)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
 						.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_AND_INFO_TO_FILE)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
 						.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_AND_INFO_TO_FILE)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
 						.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_AND_INFO_TO_FILE)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
 						.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_AND_INFO_TO_FILE)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
 						.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_AND_INFO_TO_FILE)
+						.set(EDhApiLoggerMode.LOG_ERROR_TO_CHAT)
 						.comment(""
 								+ "If enabled, the mod will log information about network operations. \n"
 								+ "This can be useful for debugging.")
@@ -1172,20 +1157,6 @@ public class Config
 								+ "memory allocated to run DH well.")
 						.build();
 				
-				public static ConfigEntry<Boolean> showReplayWarningOnStartup = new ConfigEntry.Builder<Boolean>()
-						.set(true)
-						.comment(""
-								+ "If enabled, a chat message will be displayed when a replay is started \n"
-								+ "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
@@ -1272,38 +1243,22 @@ public class Config
 				public static ConfigEntry<Boolean> columnBuilderDebugEnable = new ConfigEntry.Builder<Boolean>()
 						.set(false)
 						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
-						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
+						.addListener(DebugColumnConfigEventHandler.INSTANCE)
 						.build();
 				public static ConfigEntry<Integer> columnBuilderDebugDetailLevel = new ConfigEntry.Builder<Integer>()
 						.set((int) DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL)
 						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
-						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
+						.addListener(DebugColumnConfigEventHandler.INSTANCE)
 						.build();
 				public static ConfigEntry<Integer> columnBuilderDebugXPos = new ConfigEntry.Builder<Integer>()
 						.set(0)
 						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
-						.addListener(ReloadLodsConfigEventHandler.INSTANCE)
+						.addListener(DebugColumnConfigEventHandler.INSTANCE)
 						.build();
 				public static ConfigEntry<Integer> columnBuilderDebugZPos = new ConfigEntry.Builder<Integer>()
 						.set(0)
 						.setAppearance(EConfigEntryAppearance.ONLY_IN_GUI)
-						.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)
+						.addListener(DebugColumnConfigEventHandler.INSTANCE)
 						.build();
 				
 				

core/src/main/java/com/seibel/distanthorizons/core/config/eventHandlers/DebugColumnConfigEventHandler.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 ReloadLodsConfigEventHandler implements IConfigListener
+public class DebugColumnConfigEventHandler implements IConfigListener
 {
-	public static ReloadLodsConfigEventHandler INSTANCE = new ReloadLodsConfigEventHandler();
+	public static DebugColumnConfigEventHandler INSTANCE = new DebugColumnConfigEventHandler();
 	
 	@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(newPreset);
+			this.getPresetConfigEntry().set(this.getCustomPresetEnum());
 		}
 	}
 	

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

@@ -256,38 +256,20 @@ public class ConfigEntry<T> extends AbstractConfigType<T, ConfigEntry<T>> implem
 	public byte isValid(T value, T min, T max)
 	{
 		if (this.configBase.disableMinMax)
-		{
 			return 0;
-		}
-		else if (min == null && max == null)
-		{
-			// no validation is needed for this field
-			return 0;
-		}
-		else if (value == null || this.value == null
-				|| value.getClass() != this.value.getClass())
-		{
-			// If the 2 variables aren't the same type then it will be invalid
+		
+		if (value == null || this.value == null || value.getClass() != this.value.getClass()) // If the 2 variables aren't the same type then it will be invalid
 			return 2;
-		}
-		else if (Number.class.isAssignableFrom(value.getClass()))
-		{ 
-			// Only check min max if it is a number
+		if (Number.class.isAssignableFrom(value.getClass()))
+		{ // Only check min max if it is a number
 			if (max != null && NumberUtil.greaterThan((Number) value, (Number) max))
-			{
 				return 1;
-			}
 			if (min != null && NumberUtil.lessThan((Number) value, (Number) min))
-			{
 				return -1;
-			}
 			
 			return 0;
 		}
-		else
-		{
-			return 0;
-		}
+		return 0;
 	}
 	
 	/** This should normally not be called since set() automatically calls this */

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

@@ -62,8 +62,6 @@ public class FullDataSourceV2 implements IDataSource<IDhLevel>
 	
 	/** measured in data columns */
 	public static final int WIDTH = 64;
-	/** how many chunks wide this datasource is. */
-	public static final int NUMB_OF_CHUNKS_WIDE = WIDTH / LodUtil.CHUNK_WIDTH;
 	
 	public static final byte DATA_FORMAT_VERSION = 1;
 	

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.updateOrReplaceRenderDataViewColumnWithFullDataColumn(
+							FullDataToRenderDataTransformer.convertColumnData(
 									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(DhSectionPos.toString(this.pos));
+		stringBuilder.append(this.pos);
 		stringBuilder.append(LINE_DELIMITER);
 		
 		int size = 1;

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

@@ -19,60 +19,29 @@
 
 package com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding;
 
-import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
 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, IDhClientLevel clientLevel,
+			LodQuadBuilder builder,
 			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, boolean[] isAdjDataSameDetailLevel)
+			long topData, long bottomData, ColumnArrayView[][] adjData)
 	{
-		//================//
-		// variable setup //
-		//================//
-		
 		short maxX = (short) (x + xSize);
 		short maxY = (short) (minY + ySize);
 		short maxZ = (short) (z + zSize);
@@ -84,24 +53,33 @@ 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)
 		{
@@ -121,9 +99,7 @@ public class ColumnBox
 		
 		
 		
-		//==========================//
-		// add top and bottom faces //
-		//==========================//
+		// add top and bottom faces if requested //
 		
 		boolean skipTop = RenderDataPointUtil.doesDataPointExist(topData) && (RenderDataPointUtil.getYMin(topData) == maxY) && !isTopTransparent;
 		if (!skipTop)
@@ -138,291 +114,409 @@ public class ColumnBox
 		}
 		
 		
+		// add North, south, east, and west faces if requested //
 		
-		//========================================//
-		// add North, south, east, and west faces //
-		//========================================//
-		
-		// NORTH face
+		// TODO merge duplicate code
+		//NORTH face vertex creation
 		{
-			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)
+			ColumnArrayView[] adjDataNorth = adjData[EDhDirection.NORTH.ordinal() - 2]; // TODO can we use something other than ordinal-2?
+			int adjOverlapNorth = ColorUtil.INVISIBLE;
+			if (adjDataNorth == 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, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.NORTH, x, minY, z, xSize, ySize,
-						color, irisBlockMaterialId, blockLight);
+				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);
 			}
 		}
 		
-		// SOUTH face
+		//SOUTH face vertex creation
 		{
-			ColumnArrayView adjCol = adjData[EDhDirection.SOUTH.ordinal() - 2];
-			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.SOUTH.ordinal() - 2];
-			if (adjCol == null)
+			ColumnArrayView[] adjDataSouth = adjData[EDhDirection.SOUTH.ordinal() - 2];
+			int adjOverlapSouth = ColorUtil.INVISIBLE;
+			if (adjDataSouth == 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, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.SOUTH, x, minY, maxZ, xSize, ySize,
-						color, irisBlockMaterialId, blockLight);
+				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);
 			}
 		}
 		
-		// WEST face
+		//WEST face vertex creation
 		{
-			ColumnArrayView adjCol = adjData[EDhDirection.WEST.ordinal() - 2];
-			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.WEST.ordinal() - 2];
-			if (adjCol == null)
+			ColumnArrayView[] adjDataWest = adjData[EDhDirection.WEST.ordinal() - 2];
+			int adjOverlapWest = ColorUtil.INVISIBLE;
+			if (adjDataWest == 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, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.WEST, x, minY, z, zSize, ySize,
-						color, irisBlockMaterialId, blockLight);
+				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);
 			}
 		}
 		
-		// EAST face
+		//EAST face vertex creation
 		{
-			ColumnArrayView adjCol = adjData[EDhDirection.EAST.ordinal() - 2];
-			boolean adjSameDetailLevel = isAdjDataSameDetailLevel[EDhDirection.EAST.ordinal() - 2];
-			if (adjCol == null)
+			ColumnArrayView[] adjDataEast = adjData[EDhDirection.EAST.ordinal() - 2];
+			int adjOverlapEast = ColorUtil.INVISIBLE;
+			if (adjData[EDhDirection.EAST.ordinal() - 2] == 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, adjCol, adjSameDetailLevel, caveCullingMaxY, EDhDirection.EAST, maxX, minY, z, zSize, ySize,
-						color, irisBlockMaterialId, blockLight);
+				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);
 			}
 		}
 	}
 	
+	// the overlap color can be used to see faces that shouldn't be rendered
 	private static void makeAdjVerticalQuad(
-			LodQuadBuilder builder, @NotNull ColumnArrayView adjColumnView, boolean adjacentIsSameDetailLevel, int caveCullingMaxY, EDhDirection direction, 
+			LodQuadBuilder builder, ColumnArrayView adjColumnView, EDhDirection direction,
 			short x, short yMin, short z, short horizontalWidth, short ySize,
-			int color, byte irisBlockMaterialId, byte blockLight)
+			int color, int debugOverlapColor, byte irisBlockMaterialId, byte skyLightTop, byte blockLight,
+			long topData, long bottomData)
 	{
-		//==================//
-		// create face with //
-		// no adjacent data //
-		//==================//
-		
 		color = ColorUtil.applyShade(color, MC.getShade(direction));
 		
-		// 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)))
+		if (adjColumnView == null || 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;
 		
-		//===========================//
-		// Determine face visibility //
-		// based on it's neighbors   //
-		//===========================//
+		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;
 		
-		short yMax = (short) (yMin + ySize); // min is inclusive, max is exclusive
-		byte[] skyLightAtInputPos = THREAD_LOCAL_SKY_LIGHT_ARRAY.get();
 		
-		try
+		
+		if (!RenderDataPointUtil.doesDataPointExist(bottomData))
 		{
-			// 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);
+			// there isn't anything under this LOD,
+			// to prevent seeing through the world, make it opaque
+			color = ColorUtil.setAlpha(color, 255);
+		}
+		
+		
+		// Add adjacent faces if this LOD is surrounded by transparent LODs
+		// (prevents invisible sides underwater)
+		int adjCount = adjColumnView.size();
+		for (adjIndex = 0; // iterates top down
+				adjIndex < adjCount
+						&& RenderDataPointUtil.doesDataPointExist(adjColumnView.get(adjIndex))
+						&& !RenderDataPointUtil.isVoid(adjColumnView.get(adjIndex));
+				adjIndex++)
+		{
+			long adjPoint = adjColumnView.get(adjIndex);
 			
-			// iterate top down
-			int adjCount = adjColumnView.size();
-			for (int adjIndex = 0; adjIndex < adjCount; 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)
 			{
-				long adjPoint = adjColumnView.get(adjIndex);
-				short adjMinY = RenderDataPointUtil.getYMin(adjPoint);
-				short adjMaxY = RenderDataPointUtil.getYMax(adjPoint);
+				long adjBellowPoint = adjColumnView.get(adjIndex-1);
+				adjOverVoid = !RenderDataPointUtil.doesDataPointExist(adjBellowPoint);	
+			}
+			boolean adjTransparent = !adjOverVoid && RenderDataPointUtil.getAlpha(adjPoint) < 255 && LodRenderer.transparencyEnabled;
+			
+			
+			// continue if this data point is transparent or the adjacent point is not 
+			if (inputTransparent || !adjTransparent) // TODO inputIsTransparent may be unnecessary
+			{
+				short adjYMin = RenderDataPointUtil.getYMin(adjPoint);
+				short adjYMax = RenderDataPointUtil.getYMax(adjPoint);
 				
-				// skip empty adjacent datapoints
-				if (!RenderDataPointUtil.doesDataPointExist(adjPoint)
-						|| RenderDataPointUtil.isVoid(adjPoint))
+				
+				// if fake transparency is enabled, allow for 1 block of transparency,
+				// everything under that should be opaque
+				if (LodRenderer.transparencyEnabled && LodRenderer.fakeOceanFloor)
 				{
-					continue;
-				}
-				
-				// skip this adjacent datapoint if it's above the input datapoint (since it can't affect the input data point)
-				if (yMax <= adjMinY)
-				{
-					continue;
-				}
-				
-				
-				long adjAbovePoint = (adjIndex != 0) ? adjColumnView.get(adjIndex - 1) : RenderDataPointUtil.EMPTY_DATA;
-				long adjBelowPoint = (adjIndex + 1 < adjCount) ? adjColumnView.get(adjIndex + 1) : RenderDataPointUtil.EMPTY_DATA;
-				
-				// if the adjacent data point is over the void
-				// don't consider it as transparent
-				boolean adjOverVoid = !RenderDataPointUtil.doesDataPointExist(adjBelowPoint);
-				boolean adjTransparent = !adjOverVoid && RenderDataPointUtil.getAlpha(adjPoint) < 255 && LodRenderer.transparencyEnabled;
-				
-				
-				
-				//=================================//
-				// set sky light based on adjacent //
-				//=================================//
-				
-				// set light based on overlapping adjacent
-				if (!adjTransparent)
-				{
-					// adj opaque
-					// mark positions adjacent is covering
-					byte adjSkyLight = RenderDataPointUtil.getLightSky(adjPoint);
-					for (int i = adjMinY; i < adjMaxY; i++)
+					if (lastAdjWasTransparent && !adjTransparent)
 					{
-						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);
+						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)
+				{
+					// 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;
+				}
+				
+				
+				if (adjYMin <= yMin)
+				{
+					// the adjacent LOD's base is at or below the input's base
+					
+					if (yMax <= adjYMax)
+					{
+						// The input face is completely inside the adj's face, don't render it
+						if (debugOverlapColor != 0)
+						{
+							builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, ySize, debugOverlapColor, irisBlockMaterialId, LodUtil.MAX_MC_LIGHT, LodUtil.MAX_MC_LIGHT);
+						}
+					}
+					else
+					{
+						// the adj data intersects the lower part of the input data, don't render below the intersection
+						
+						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
 				{
-					// adjacent is transparent,
-					// use datapoint below adjacent for lighting
-					byte belowSkyLight = RenderDataPointUtil.getLightSky(adjBelowPoint);
-					for (int i = adjMinY; i < adjMaxY; i++)
+					// Otherwise: y < _____ height < yMax
+					// _______&&: y < depth ______ < yMax
+					if (debugOverlapColor != 0)
 					{
-						byte skyLightAtPos = skyLightAtInputPos[i];
-						skyLightAtInputPos[i] = (byte) Math.min(belowSkyLight, skyLightAtPos);
+						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;
 					}
 				}
 				
 				
-				// 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++)
+				// set next top as current depth
+				previousAdjDepth = adjYMin;
+				firstFace = false;
+				nextTopSkyLight = skyLightTop;
+				
+				if (adjIndex + 1 < adjColumnView.size() && RenderDataPointUtil.doesDataPointExist(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;
+					nextTopSkyLight = RenderDataPointUtil.getLightSky(adjColumnView.get(adjIndex + 1));
 				}
 				
-				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
-				);
+				lastAdjWasTransparent = adjTransparent;
 			}
 		}
-		finally
+		
+		
+		
+		if (inputAboveAdjLods)
 		{
-			// 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);
+			// 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);
+		}
+		else if (previousAdjDepth != -1)
+		{
+			// We need to finish the last quad.
+			builder.addQuadAdj(direction, x, yMin, z, horizontalWidth, (short) (previousAdjDepth - yMin), color, irisBlockMaterialId, nextTopSkyLight, blockLight);
 		}
 	}
-	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)
-		{
-			// 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,24 +19,19 @@
 
 package com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding;
 
-import com.seibel.distanthorizons.api.DhApi;
 import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
-import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.DhBlockPos;
-import com.seibel.distanthorizons.core.render.glObject.GLProxy;
-import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer;
 import com.seibel.distanthorizons.core.render.renderer.LodRenderer;
 import com.seibel.distanthorizons.core.util.LodUtil;
-import com.seibel.distanthorizons.core.util.objects.StatsMap;
 import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod;
+import com.seibel.distanthorizons.core.util.*;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import org.apache.logging.log4j.Logger;
-import org.lwjgl.system.MemoryUtil;
 
 import java.nio.ByteBuffer;
-import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.concurrent.*;
 
 /**
@@ -54,19 +49,18 @@ public class ColumnRenderBuffer implements AutoCloseable
 	/** number of bytes a single quad takes */
 	public static final int QUADS_BYTE_SIZE = LodUtil.LOD_VERTEX_FORMAT.getByteSize() * 4;
 	/** how big a single VBO can be in bytes */
-	public static final int MAX_VBO_BYTE_SIZE = 10 * 1024 * 1024; // 10 MB
+	public static final int MAX_VBO_BYTE_SIZE = 1024 * 1024; // 1 MB
 	public static final int MAX_QUADS_PER_BUFFER = MAX_VBO_BYTE_SIZE / QUADS_BYTE_SIZE;
 	public static final int FULL_SIZED_BUFFER = MAX_QUADS_PER_BUFFER * QUADS_BYTE_SIZE;
 	
 	
 	
-	
 	public final DhBlockPos pos;
 	
 	public boolean buffersUploaded = false;
 	
-	private GLVertexBuffer[] vbos;
-	private GLVertexBuffer[] vbosTransparent;
+	public SharedVbo.BufferSlice[] opaqueBufferSlices;
+	public SharedVbo.BufferSlice[] transparentBufferSlices;
 	
 	
 	
@@ -77,14 +71,12 @@ public class ColumnRenderBuffer implements AutoCloseable
 	public ColumnRenderBuffer(DhBlockPos pos)
 	{
 		this.pos = pos;
-		this.vbos = new GLVertexBuffer[0];
-		this.vbosTransparent = new GLVertexBuffer[0];
+		this.opaqueBufferSlices = new SharedVbo.BufferSlice[0];
+		this.transparentBufferSlices = new SharedVbo.BufferSlice[0];
 	}
 	
 	
 	
-	
-	
 	//==================//
 	// buffer uploading //
 	//==================//
@@ -92,7 +84,7 @@ public class ColumnRenderBuffer implements AutoCloseable
 	/** Should be run on a DH thread. */
 	public void uploadBuffer(LodQuadBuilder builder, EDhApiGpuUploadMethod gpuUploadMethod) throws InterruptedException
 	{
-		LodUtil.assertTrue(DhApi.isDhThread(), "Buffer uploading needs to be done on a DH thread to prevent locking up any MC threads.");
+		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.");
 		
 		
 		// upload on MC's render thread
@@ -101,7 +93,7 @@ public class ColumnRenderBuffer implements AutoCloseable
 		{
 			try
 			{
-				this.uploadBuffers(builder, gpuUploadMethod);
+				this.uploadBuffersUsingUploadMethod(builder, gpuUploadMethod);
 				uploadFuture.complete(null);
 			}
 			catch (InterruptedException e)
@@ -127,231 +119,163 @@ public class ColumnRenderBuffer implements AutoCloseable
 			//LOGGER.warn("Error uploading builder ["+builder+"] synchronously. Error: "+e.getMessage(), e);
 		}
 	}
-	private void uploadBuffers(LodQuadBuilder builder, EDhApiGpuUploadMethod method) throws InterruptedException
+	private void uploadBuffersUsingUploadMethod(LodQuadBuilder builder, EDhApiGpuUploadMethod gpuUploadMethod) throws InterruptedException
 	{
-		// 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());
+		//if (gpuUploadMethod.useEarlyMapping)
+		//{
+		//	this.uploadBuffersMapped(builder, gpuUploadMethod);
+		//}
+		//else
+		//{
+			this.uploadBuffersDirect(builder);
+		//}
 		
 		this.buffersUploaded = true;
 	}
-	/** 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
+	
+	
+	
+	//private void uploadBuffersMapped(LodQuadBuilder builder, EDhApiGpuUploadMethod method)
+	//{
+	//	// opaque vbos //
+	//	
+	//	this.vbos = ColumnRenderBufferBuilder.resizeBuffer(this.vbos, builder.getCurrentNeededOpaqueVertexBufferCount());
+	//	for (int i = 0; i < this.vbos.length; i++)
+	//	{
+	//		if (this.vbos[i] == null)
+	//		{
+	//			this.vbos[i] = new GLVertexBuffer(method.useBufferStorage);
+	//		}
+	//	}
+	//	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);
+	//	}
+	//}
+	
+	private void uploadBuffersDirect(LodQuadBuilder builder)
 	{
-		try
+		int opaqueSliceCount = builder.getCurrentNeededOpaqueVertexBufferCount();
+		if (this.opaqueBufferSlices.length != opaqueSliceCount)
 		{
-			vbos = resizeBuffer(vbos, buffers.size());
-			uploadBuffersDirect(vbos, buffers, method);
-		}
-		finally
-		{
-			// all the buffers must be manually freed to prevent memory leaks
-			if (buffers != null)
-			{
-				for (ByteBuffer buffer : buffers)
-				{
-					MemoryUtil.memFree(buffer);
-				}
-			}
+			SharedVbo.OPAQUE.deallocate(this.opaqueBufferSlices);
+			this.opaqueBufferSlices = new SharedVbo.BufferSlice[opaqueSliceCount];
 		}
+		uploadBuffersDirect(SharedVbo.OPAQUE, this.opaqueBufferSlices, builder.makeOpaqueVertexBuffers());
 		
-		// return the array in case it was resized
-		return vbos;
-	}
-	private static void uploadBuffersDirect(GLVertexBuffer[] vbos, ArrayList<ByteBuffer> byteBuffers, EDhApiGpuUploadMethod method) throws InterruptedException
-	{
-		int vboIndex = 0;
-		for (int i = 0; i < byteBuffers.size(); i++)
+		
+		int transparentSliceCount = builder.getCurrentNeededTransparentVertexBufferCount();
+		if (this.transparentBufferSlices.length != transparentSliceCount)
 		{
-			if (vboIndex >= vbos.length)
+			SharedVbo.TRANSPARENT.deallocate(this.transparentBufferSlices);
+			this.transparentBufferSlices = new SharedVbo.BufferSlice[transparentSliceCount];
+		}
+		uploadBuffersDirect(SharedVbo.TRANSPARENT, this.transparentBufferSlices, builder.makeTransparentVertexBuffers());
+	}
+	
+	private static void uploadBuffersDirect(SharedVbo handler, SharedVbo.BufferSlice[] bufferSlices, Iterator<ByteBuffer> iter)
+	{
+		int i = 0;
+		while (iter.hasNext())
+		{
+			if (i >= bufferSlices.length)
 			{
 				throw new RuntimeException("Too many vertex buffers!!");
 			}
 			
-			
-			// get or create the VBO
-			if (vbos[vboIndex] == null)
+			// get or create the buffer
+			if (bufferSlices[i] == null)
 			{
-				vbos[vboIndex] = new GLVertexBuffer(method.useBufferStorage);
+				bufferSlices[i] = handler.allocateSlice();
 			}
-			GLVertexBuffer vbo = vbos[vboIndex];
+			SharedVbo.BufferSlice slice = bufferSlices[i];
 			
 			
-			ByteBuffer buffer = byteBuffers.get(i);
-			int size = buffer.limit() - buffer.position();
-			
+			ByteBuffer buffer = iter.next();
 			try
 			{
-				vbo.bind();
-				vbo.uploadBuffer(buffer, size / LodUtil.LOD_VERTEX_FORMAT.getByteSize(), method, FULL_SIZED_BUFFER);
+				handler.updateBuffer(slice, buffer);
 			}
 			catch (Exception e)
 			{
-				vbos[vboIndex] = null;
-				vbo.close();
-				LOGGER.error("Failed to upload buffer: ", e);
+				bufferSlices[i] = null;
+				handler.deallocate(slice);
+				LOGGER.error("Failed to upload buffer. Error: ["+e.getMessage()+"].", e);
 			}
 			
-			vboIndex++;
+			i++;
 		}
 		
-		if (vboIndex < vbos.length)
+		if (i < bufferSlices.length)
 		{
-			throw new RuntimeException("Too few vertex buffers!!");
+			throw new RuntimeException("Too few buffer chunks!");
 		}
 	}
 	
 	
 	
-	
-	
 	//========//
 	// render //
 	//========//
 	
-	/** @return true if something was rendered, false otherwise */
-	public boolean renderOpaque(LodRenderer renderContext, DhApiRenderParam renderEventParam)
-	{
-		boolean hasRendered = false;
-		renderContext.setModelViewMatrixOffset(this.pos, renderEventParam);
-		for (GLVertexBuffer vbo : this.vbos)
-		{
-			if (vbo == null)
-			{
-				continue;
-			}
-			
-			if (vbo.getVertexCount() == 0)
-			{
-				continue;
-			}
-			
-			hasRendered = true;
-			renderContext.drawVbo(vbo);
-			//LodRenderer.tickLogger.info("Vertex buffer: {}", vbo);
-		}
-		return hasRendered;
-	}
-	
-	/** @return true if something was rendered, false otherwise */
-	public boolean renderTransparent(LodRenderer renderContext, DhApiRenderParam renderEventParam)
-	{
-		boolean hasRendered = false;
-		
-		try
-		{
-			// can throw an IllegalStateException if the GL program was freed before it should've been
-			renderContext.setModelViewMatrixOffset(this.pos, renderEventParam);
-			
-			for (GLVertexBuffer vbo : this.vbosTransparent)
-			{
-				if (vbo == null)
-				{
-					continue;
-				}
-				
-				if (vbo.getVertexCount() == 0)
-				{
-					continue;
-				}
-				
-				hasRendered = true;
-				renderContext.drawVbo(vbo);
-				//LodRenderer.tickLogger.info("Vertex buffer: {}", vbo);
-			}
-		}
-		catch (IllegalStateException e)
-		{
-			LOGGER.error("renderContext program doesn't exist for pos: "+this.pos, e);
-		}
-		
-		return hasRendered;
-	}
+	//public void renderOpaque(LodRenderer renderContext, DhApiRenderParam renderEventParam)
+	//{
+	//	renderContext.setModelViewMatrixOffset(this.pos, renderEventParam);
+	//	renderContext.drawSharedVbo(SharedVbo.OPAQUE, this.opaqueBufferSlices);
+	//}
+	//
+	//public void renderTransparent(LodRenderer renderContext, DhApiRenderParam renderEventParam)
+	//{
+	//	renderContext.setModelViewMatrixOffset(this.pos, renderEventParam);
+	//	renderContext.drawSharedVbo(SharedVbo.TRANSPARENT, this.transparentBufferSlices);
+	//}
 	
 	
 	
-	//================//
-	// helper methods //
-	//================//
+	//==============//
+	// misc methods //
+	//==============//
+	
+	// TODO
+	/** can be used when debugging */
+	public boolean hasNonNullVbos() { return false; } //this.vbos != null || this.vbosTransparent != null; }
 	
 	/** can be used when debugging */
-	public boolean hasNonNullVbos() { return this.vbos != null || this.vbosTransparent != null; }
-	
-	/** can be used when debugging */
-	public int vboBufferCount() 
+	public int bufferSliceCount() 
 	{
 		int count = 0;
 		
-		if (this.vbos != null)
+		if (this.opaqueBufferSlices != null)
 		{
-			count += this.vbos.length;
+			count += this.opaqueBufferSlices.length;
 		}
-		
-		if (this.vbosTransparent != null)
+
+		if (this.transparentBufferSlices != null)
 		{
-			count += this.vbosTransparent.length;
+			count += this.transparentBufferSlices.length;
 		}
 		
 		return count;
 	}
 	
-	public void debugDumpStats(StatsMap statsMap)
-	{
-		statsMap.incStat("RenderBuffers");
-		statsMap.incStat("SimpleRenderBuffers");
-		for (GLVertexBuffer vertexBuffer : vbos)
-		{
-			if (vertexBuffer != null)
-			{
-				statsMap.incStat("VBOs");
-				if (vertexBuffer.getSize() == FULL_SIZED_BUFFER)
-				{
-					statsMap.incStat("FullsizedVBOs");
-				}
-				
-				if (vertexBuffer.getSize() == 0)
-				{
-					GLProxy.GL_LOGGER.warn("VBO with size 0");
-				}
-				statsMap.incBytesStat("TotalUsage", vertexBuffer.getSize());
-			}
-		}
-	}
-	
-	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
@@ -363,24 +287,8 @@ public class ColumnRenderBuffer implements AutoCloseable
 	{
 		this.buffersUploaded = false;
 		
-		GLProxy.getInstance().queueRunningOnRenderThread(() ->
-		{
-			for (GLVertexBuffer buffer : this.vbos)
-			{
-				if (buffer != null)
-				{
-					buffer.destroyAsync();
-				}
-			}
-			
-			for (GLVertexBuffer buffer : this.vbosTransparent)
-			{
-				if (buffer != null)
-				{
-					buffer.destroyAsync();
-				}
-			}
-		});
+		SharedVbo.OPAQUE.deallocate(this.opaqueBufferSlices);
+		SharedVbo.TRANSPARENT.deallocate(this.transparentBufferSlices);
 	}
 	
 }

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

@@ -19,7 +19,6 @@
 
 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;
@@ -30,13 +29,12 @@ 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.util.ColorUtil;
+import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer;
 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;
 
@@ -61,21 +59,21 @@ public class ColumnRenderBufferBuilder
 	// vbo building //
 	//==============//
 	
-	public static CompletableFuture<LodQuadBuilder> buildBuffersAsync(
+	public static CompletableFuture<ColumnRenderBuffer> buildAndUploadBuffersAsync(
 			IDhClientLevel clientLevel,
-			ColumnRenderSource renderSource, ColumnRenderSource[] adjData, boolean[] isSameDetailLevel
-		)
+			ColumnRenderSource renderSource, ColumnRenderSource[] adjData)
 	{
 		ThreadPoolExecutor bufferBuilderExecutor = ThreadPoolUtil.getBufferBuilderExecutor();
-		if (bufferBuilderExecutor == null || bufferBuilderExecutor.isTerminated())
+		ThreadPoolExecutor bufferUploaderExecutor = ThreadPoolUtil.getBufferUploaderExecutor();
+		if ((bufferBuilderExecutor == null || bufferBuilderExecutor.isTerminated()) ||
+			(bufferUploaderExecutor == null || bufferUploaderExecutor.isTerminated()))
 		{
 			// one or more of the thread pools has been shut down
-			CompletableFuture<LodQuadBuilder> future = new CompletableFuture<>();
+			CompletableFuture<ColumnRenderBuffer> future = new CompletableFuture<>();
 			future.cancel(true);
 			return future;
 		}
 		
-		
 		try
 		{
 			return CompletableFuture.supplyAsync(() ->
@@ -83,8 +81,35 @@ public class ColumnRenderBufferBuilder
 					try
 					{
 						boolean enableTransparency = Config.Client.Advanced.Graphics.Quality.transparency.get().transparencyEnabled;
-						LodQuadBuilder builder = new LodQuadBuilder(enableTransparency, clientLevel.getClientLevelWrapper());
-						makeLodRenderData(builder, renderSource, clientLevel, adjData, isSameDetailLevel);
+						
+						//EVENT_LOGGER.trace("RenderRegion start QuadBuild @ " + renderSource.sectionPos);
+						boolean enableSkyLightCulling =
+								Config.Client.Advanced.Graphics.AdvancedGraphics.enableCaveCulling.get()
+								&& (
+									// dimensions with a ceiling will be all caves so we don't want cave culling
+									!clientLevel.getLevelWrapper().hasCeiling()
+									// the end has a lot of overhangs with 0 lighting above the void, which look broken with
+									// the current cave culling logic (this could probably be improved, but just skipping it works best for now)
+									&& !clientLevel.getLevelWrapper().getDimensionType().isTheEnd()
+									// FIXME temporary fix
+									//  Cave culling is currently broken for any detail level above 0
+									&& DhSectionPos.getDetailLevel(renderSource.pos) == DhSectionPos.SECTION_MINIMUM_DETAIL_LEVEL
+								);
+						
+						int skyLightCullingBelow = Config.Client.Advanced.Graphics.AdvancedGraphics.caveCullingHeight.get();
+						// FIXME: Clamp also to the max world height.
+						skyLightCullingBelow = Math.max(skyLightCullingBelow, clientLevel.getMinY());
+						
+						
+						long builderStartTime = System.currentTimeMillis();
+						
+						LodQuadBuilder builder = new LodQuadBuilder(enableSkyLightCulling, (short) (skyLightCullingBelow - clientLevel.getMinY()), enableTransparency, clientLevel.getClientLevelWrapper());
+						makeLodRenderData(builder, renderSource, adjData);
+						
+						long builderEndTime = System.currentTimeMillis();
+						long buildMs = builderEndTime - builderStartTime;
+						LOGGER.debug("RenderRegion end QuadBuild @ " + renderSource.pos + " took: " + buildMs);
+						
 						return builder;
 					}
 					catch (UncheckedInterruptedException e)
@@ -93,42 +118,11 @@ public class ColumnRenderBufferBuilder
 					}
 					catch (Throwable e3)
 					{
-						LOGGER.error("LodNodeBufferBuilder was unable to build quads for pos ["+DhSectionPos.toString(renderSource.pos)+"], error: ["+ e3.getMessage()+"].", e3);
+						LOGGER.error("\"LodNodeBufferBuilder\" was unable to build quads: ", e3);
 						throw e3;
 					}
-				}, 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(() ->
+				}, bufferBuilderExecutor)
+				.thenApplyAsync((quadBuilder) ->
 				{
 					try
 					{
@@ -136,15 +130,8 @@ public class ColumnRenderBufferBuilder
 						try
 						{
 							buffer.uploadBuffer(quadBuilder, GLProxy.getInstance().getGpuUploadMethod());
-							if (buffer.buffersUploaded)
-							{
-								return buffer;	
-							}
-							else
-							{
-								buffer.close();
-								return null;
-							}
+							LodUtil.assertTrue(buffer.buffersUploaded);
+							return buffer;
 						}
 						catch (Exception e)
 						{
@@ -158,38 +145,35 @@ public class ColumnRenderBufferBuilder
 					}
 					catch (Throwable e3)
 					{
-						LOGGER.error("LodNodeBufferBuilder was unable to upload buffer for pos ["+DhSectionPos.toString(renderSource.pos)+"], error: [" + e3.getMessage() + "].", e3);
+						LOGGER.error("LodNodeBufferBuilder was unable to upload buffer: " + e3.getMessage(), e3);
 						throw e3;
 					}
 				}, bufferUploaderExecutor);
 		}
 		catch (RejectedExecutionException ignore) 
 		{
-			// shouldn't happen, but just in case
+			// the thread pool was probably shut down because it's size is being changed, just wait a sec and it should be back
 			
 			CompletableFuture<ColumnRenderBuffer> future = new CompletableFuture<>();
 			future.cancel(true);
 			return future;
 		}
 	}
-	private static void makeLodRenderData(
-			LodQuadBuilder quadBuilder, ColumnRenderSource renderSource, IDhClientLevel clientLevel,
-			ColumnRenderSource[] adjRegions, boolean[] isSameDetailLevel)
+	private static void makeLodRenderData(LodQuadBuilder quadBuilder, ColumnRenderSource renderSource, ColumnRenderSource[] adjRegions)
 	{
-		//=============//
-		// debug check //
-		//=============//
+		// Variable initialization
+		EDhApiDebugRendering debugMode = Config.Client.Advanced.Debugging.debugRendering.get();
 		
 		// can be used to limit which section positions are build and thus, rendered
 		// useful when debugging a specific section
-		boolean columnBuilderDebugEnabled = Config.Client.Advanced.Debugging.columnBuilderDebugEnable.get();
-		if (columnBuilderDebugEnabled)
+		boolean enableColumnBufferLimit = Config.Client.Advanced.Debugging.columnBuilderDebugEnable.get();
+		if (enableColumnBufferLimit)
 		{
 			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 breakpoint = 0;
+				int test = 0;
 			}
 			else
 			{
@@ -197,22 +181,24 @@ public class ColumnRenderBufferBuilder
 			}
 		}
 		
-		
-		
-		//===================//
-		// build each column //
-		//===================//
-		
-		byte thisDetailLevel = renderSource.getDataDetailLevel();
-		for (int relX = 0; relX < ColumnRenderSource.SECTION_SIZE; relX++)
+		byte detailLevel = renderSource.getDataDetailLevel();
+		for (int x = 0; x < ColumnRenderSource.SECTION_SIZE; x++)
 		{
-			for (int relZ = 0; relZ < ColumnRenderSource.SECTION_SIZE; relZ++)
+			for (int z = 0; z < ColumnRenderSource.SECTION_SIZE; z++)
 			{
-				// stop the builder if requested
+				// 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;
+//				}
+				
+				
 				UncheckedInterruptedException.throwIfInterrupted();
 				
-				// ignore empty/null columns
-				ColumnArrayView columnRenderData = renderSource.getVerticalDataPointView(relX, relZ);
+				ColumnArrayView columnRenderData = renderSource.getVerticalDataPointView(x, z);
 				if (columnRenderData.size() == 0
 						|| !RenderDataPointUtil.doesDataPointExist(columnRenderData.get(0))
 						|| RenderDataPointUtil.isVoid(columnRenderData.get(0)))
@@ -220,66 +206,43 @@ 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);
 				
 				
-				//=============//
-				// debug limit //
-				//=============//
+				// We check every adj block in each direction
 				
-				// 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];
+				// 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
 				for (EDhDirection lodDirection : EDhDirection.ADJ_DIRECTIONS)
 				{
 					try
 					{
-						int xAdj = relX + lodDirection.getNormal().x;
-						int zAdj = relZ + lodDirection.getNormal().z;
-						boolean isCrossRenderSourceBoundary =
+						int xAdj = x + lodDirection.getNormal().x;
+						int zAdj = z + lodDirection.getNormal().z;
+						boolean isCrossRegionBoundary =
 								(xAdj < 0 || xAdj >= ColumnRenderSource.SECTION_SIZE) ||
-								(zAdj < 0 || zAdj >= ColumnRenderSource.SECTION_SIZE);
+										(zAdj < 0 || zAdj >= ColumnRenderSource.SECTION_SIZE);
 						
 						ColumnRenderSource adjRenderSource;
 						byte adjDetailLevel;
 						
-						
-						
-						//=========================//
-						// get the adjacent render //
-						// source if present       //
-						//=========================//
-						
-						if (!isCrossRenderSourceBoundary)
+						//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)
 						{
-							// 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
+							//we compute at which detail that position should be rendered
 							adjRenderSource = adjRegions[lodDirection.ordinal() - 2];
 							if (adjRenderSource == null)
 							{
@@ -287,70 +250,67 @@ public class ColumnRenderBufferBuilder
 							}
 							
 							adjDetailLevel = adjRenderSource.getDataDetailLevel();
-							if (adjDetailLevel == thisDetailLevel)
+							if (adjDetailLevel != detailLevel)
+							{
+								//TODO: Implement this
+							}
+							else
 							{
-								// 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;
+						}
 						
-						
-						//========================//
-						// 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);
+						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));
+						}
 					}
 					catch (RuntimeException e)
 					{
-						EVENT_LOGGER.warn("Failed to get adj data for relative pos: [" + thisDetailLevel + ":" + relX + "," + relZ + "] at [" + lodDirection + "], Error: "+e.getMessage(), e);
+						EVENT_LOGGER.warn("Failed to get adj data for [" + detailLevel + ":" + x + "," + z + "] 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 (Config.Client.Advanced.Debugging.columnBuilderDebugEnable.get())
-					{
-						int wantedColumnIndex = Config.Client.Advanced.Debugging.columnBuilderDebugColumnIndex.get();
-						if (wantedColumnIndex >= 0 && i != wantedColumnIndex)
-						{
-							continue;
-						}
-					}
+//					if (i != 0)
+//					{
+//						continue;
+//					}
 					
 					long data = columnRenderData.get(i);
 					// If the data is not render-able (Void or non-existing) we stop since there is
@@ -363,12 +323,8 @@ 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;
 					
-					addLodToBuffer(
-							clientLevel,
-							data, topDataPoint, bottomDataPoint, 
-							adjColumnViews, isSameDetailLevel,
-							thisDetailLevel, relX, relZ, 
-							quadBuilder, debugSourceFlag);
+					CubicLodTemplate.addLodToBuffer(data, topDataPoint, bottomDataPoint, adjColumnViews, detailLevel,
+							x, z, quadBuilder, debugMode, debugSourceFlag);
 				}
 				
 			}// for z
@@ -376,147 +332,5 @@ public class ColumnRenderBufferBuilder
 		
 		quadBuilder.finalizeData();
 	}
-	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)
-	{
-		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;
-		}
-		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;
-		EDhApiDebugRendering debugging = Config.Client.Advanced.Debugging.debugRendering.get();
-		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);
-				}
-				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, 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

@@ -0,0 +1,186 @@
+/*
+ *    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,7 +38,8 @@ 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;
-import org.lwjgl.system.MemoryUtil;
+
+//TODO: Recheck this class for refactoring
 
 /**
  * Used to create the quads before they are converted to render-able buffers. <br><br>
@@ -50,6 +51,9 @@ public class LodQuadBuilder
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	
+	public final boolean skipQuadsWithZeroSkylight;
+	public final short skyLightCullingBelow;
+	
 	@SuppressWarnings("unchecked")
 	private final ArrayList<BufferQuad>[] opaqueQuads = (ArrayList<BufferQuad>[]) new ArrayList[6];
 	@SuppressWarnings("unchecked")
@@ -119,7 +123,7 @@ public class LodQuadBuilder
 	// constructor //
 	//=============//
 	
-	public LodQuadBuilder(boolean doTransparency, IClientLevelWrapper clientLevelWrapper)
+	public LodQuadBuilder(boolean enableSkylightCulling, short skyLightCullingBelow, boolean doTransparency, IClientLevelWrapper clientLevelWrapper)
 	{
 		this.doTransparency = doTransparency;
 		for (int i = 0; i < 6; i++)
@@ -128,6 +132,8 @@ public class LodQuadBuilder
 			this.transparentQuads[i] = new ArrayList<>();
 		}
 		
+		this.skipQuadsWithZeroSkylight = enableSkylightCulling;
+		this.skyLightCullingBelow = skyLightCullingBelow;
 		this.clientLevelWrapper = clientLevelWrapper;
 		
 		this.debugRenderingMode = Config.Client.Advanced.Debugging.debugRendering.get();
@@ -151,6 +157,11 @@ 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() &&
@@ -169,6 +180,12 @@ 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()];
@@ -190,13 +207,15 @@ public class LodQuadBuilder
 	
 	public void addQuadDown(short x, short y, short z, short width, short wz, int color, byte irisBlockMaterialId, byte skylight, byte blocklight)
 	{
+		if (skipQuadsWithZeroSkylight && skylight == 0 && y < skyLightCullingBelow)
+			return;
 		BufferQuad quad = new BufferQuad(x, y, z, width, wz, color, irisBlockMaterialId, skylight, blocklight, EDhDirection.DOWN);
 		ArrayList<BufferQuad> qs = (doTransparency && ColorUtil.getAlpha(color) < 255)
 				? transparentQuads[EDhDirection.DOWN.ordinal()] : opaqueQuads[EDhDirection.DOWN.ordinal()];
-		if (!qs.isEmpty()
-				&& (qs.get(qs.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.EastWest)
+		if (!qs.isEmpty() &&
+				(qs.get(qs.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.EastWest)
 						|| qs.get(qs.size() - 1).tryMerge(quad, BufferMergeDirectionEnum.NorthSouthOrUpDown))
-			)
+		)
 		{
 			premergeCount++;
 			return;
@@ -206,124 +225,10 @@ 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;
-	}
-	
-	
-	
 	//==============//
-	// buffer setup //
+	// add vertices //
 	//==============//
 	
-	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()];
@@ -381,10 +286,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
@@ -392,7 +297,7 @@ public class LodQuadBuilder
 								color = ColorUtil.applyShade(color, MC.getShade(quad.direction));
 							}
 						}
-					}
+					}   
 				}
 			}
 			
@@ -406,6 +311,7 @@ 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;
@@ -446,6 +352,389 @@ 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/bufferBuilding/SharedVbo.java

@@ -0,0 +1,188 @@
+package com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding;
+
+import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
+import com.seibel.distanthorizons.core.logging.f3.F3Screen;
+import com.seibel.distanthorizons.core.render.glObject.GLProxy;
+import com.seibel.distanthorizons.core.util.LodUtil;
+import com.seibel.distanthorizons.coreapi.util.StringUtil;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.opengl.GL32;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentHashMap;
+
+/** Used to allow multiple {@link ColumnRenderBuffer}'s to be put in a single VBO. */
+public class SharedVbo 
+{
+	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
+	
+	public static final SharedVbo OPAQUE = new SharedVbo(2_000_000_000L/*1GB*/, 1024 * 1024/*1MB*/);
+	public static final SharedVbo TRANSPARENT = new SharedVbo(2_000_000_000L/*1GB*/, 1024 * 1024/*1MB*/);
+	
+	
+	public final int vboId;
+	
+	
+	private final long bufferTotalByteSize;
+	/** the length of a single chunk of this VBO in bytes. */
+	private final int chunkByteSize;
+	
+	private final ConcurrentHashMap<Long, BufferSlice> bufferSliceByStartingIndex = new ConcurrentHashMap<>();
+	private long nextMemoryAddress = 0L;
+	private final Queue<BufferSlice> availableSlices = new ArrayDeque<>();
+	
+	
+	
+	//=============//
+	// constructor //
+	//=============//
+	
+	public SharedVbo(long totalSize, int chunkByteSize) 
+	{
+		LodUtil.assertTrue(GLProxy.getInstance().runningOnRenderThread(), "Buffer Handler has to be created on the render thread.");
+		
+		this.bufferTotalByteSize = totalSize;
+		this.chunkByteSize = chunkByteSize;
+		
+		// Generate and bind the VBO
+		this.vboId = GL32.glGenBuffers();
+		GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, this.vboId);
+		GL32.glBufferData(GL32.GL_ARRAY_BUFFER, this.bufferTotalByteSize, GL32.GL_DYNAMIC_DRAW);
+		GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, 0);
+	}
+	
+	
+	
+	//============//
+	// allocation //
+	//============//
+	
+	@Nullable
+	public SharedVbo.BufferSlice allocateSlice()
+	{
+		BufferSlice availableSlice = this.availableSlices.poll();
+		if (availableSlice != null)
+		{
+			return availableSlice;
+		}
+		
+		// Find the first free chunk
+		for (long startingIndex = this.nextMemoryAddress; startingIndex < this.bufferTotalByteSize; startingIndex += this.chunkByteSize)
+		{
+			// check if this section is free
+			BufferSlice newSlice = new BufferSlice(startingIndex, this.chunkByteSize);
+			if (this.bufferSliceByStartingIndex.putIfAbsent(startingIndex, newSlice) == null)
+			{
+				this.nextMemoryAddress = startingIndex;
+				return newSlice;
+			}
+		}
+		
+		return null; // No free chunk found
+	}
+	public void deallocate(BufferSlice[] slices)
+	{
+		if (slices != null)
+		{
+			for (BufferSlice slice : slices)
+			{
+				if (slice != null)
+				{
+					this.bufferSliceByStartingIndex.remove(slice.startIndex);
+					this.availableSlices.add(slice);
+				}
+			}
+		}
+	}
+	public void deallocate(BufferSlice slice) 
+	{
+		if (slice != null)
+		{
+			this.bufferSliceByStartingIndex.remove(slice.startIndex);
+			this.availableSlices.add(slice);
+		}
+	}
+	public void clear() 
+	{
+		this.bufferSliceByStartingIndex.clear(); 
+	}
+	
+	
+	
+	//=================//
+	// buffer handling //
+	//=================//
+	
+	public void updateBuffer(BufferSlice chunk, ByteBuffer buffer) 
+	{
+		int size = buffer.limit() - buffer.position();
+		if (size > chunk.length)
+		{
+			// if this was fired that means we didn't split up the buffer into the right size
+			// if this isn't stopped the buffer will overwrite an adjacent section and cause incorrect rendering
+			throw new RuntimeException("Programmer error: Uploaded buffer bigger than the allocated area. Allocated: ["+chunk.length+"], buffer: ["+size+"]");
+		}
+		
+		GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, this.vboId);
+		GL32.glBufferSubData(GL32.GL_ARRAY_BUFFER, chunk.startIndex, buffer);
+		GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, 0);
+		chunk.vertexCount = size / LodUtil.LOD_VERTEX_FORMAT.getByteSize();
+	}
+	
+	public void bind() { GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, this.vboId); }
+	public void unbind() { GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, 0); }
+	
+	
+	
+	//=======//
+	// debug //
+	//=======//
+	
+	public String getDebugMenuString()
+	{
+		long maxChunkCount = (this.bufferTotalByteSize / this.chunkByteSize);
+		long chunkCount = 0;
+		long allocatedBytes = 0;
+		
+		for (BufferSlice slice : this.bufferSliceByStartingIndex.values())
+		{
+			allocatedBytes += slice.length;
+			chunkCount++;
+		}
+		
+		return "Slices: ["+F3Screen.NUMBER_FORMAT.format(chunkCount)+"/"+F3Screen.NUMBER_FORMAT.format(maxChunkCount)+"], " +
+				"Mem: ["+StringUtil.convertByteCountToHumanReadableSI(allocatedBytes)+"/"+StringUtil.convertByteCountToHumanReadableSI(this.bufferTotalByteSize)+"]";
+	}
+	
+	
+	
+	//================//
+	// helper classes //
+	//================//
+	
+	/** represents a single allocated slice of the parent VBO */
+	public static class BufferSlice 
+	{
+		public final long startIndex;
+		public final int length;
+		
+		public int vertexCount;
+		
+		
+		
+		//=============//
+		// constructor //
+		//=============//
+		
+		public BufferSlice(long startIndex, int length) 
+		{
+			this.startIndex = startIndex;
+			this.length = length;
+		}
+		
+	}
+	
+}

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

@@ -20,7 +20,6 @@
 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;
 
@@ -29,60 +28,41 @@ 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;
-	/** 
-	 * 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 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
 	
 	
 	
-	//=============//
-	// constructor //
-	//=============//
-	
-	public ColumnArrayView(LongArrayList data, int size, int offset, int verticalSize)
+	public ColumnArrayView(LongArrayList data, int size, int offset, int vertSize)
 	{
 		this.data = data;
 		this.size = size;
 		this.offset = offset;
-		this.verticalSize = verticalSize;
+		this.vertSize = vertSize;
 	}
 	
 	
 	
-	//=====================//
-	// 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 dataCount() { return (this.verticalSize != 0) ? (this.size / this.verticalSize) : 0; } // TODO what does the divide by mean?
+	public int verticalSize() { return vertSize; }
+	
+	@Override
+	public int dataCount() { return (this.vertSize != 0) ? (this.size / this.vertSize) : 0; }
 	
 	@Override
 	public ColumnArrayView subView(int dataIndexStart, int dataCount)
 	{
-		return new ColumnArrayView(data, dataCount * verticalSize, offset + dataIndexStart * verticalSize, verticalSize);
+		return new ColumnArrayView(data, dataCount * vertSize, offset + dataIndexStart * vertSize, vertSize);
 	}
 	
 	public void fill(long value) { Arrays.fill(data.elements(), offset, offset + size, value); }
@@ -90,7 +70,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() > verticalSize)
+		if (source.verticalSize() > vertSize)
 		{
 			throw new IllegalArgumentException("source verticalSize must be <= self's verticalSize to copy");
 		}
@@ -98,19 +78,19 @@ public final class ColumnArrayView implements IColumnDataView
 		{
 			throw new IllegalArgumentException("dataIndexStart + source.dataCount() must be <= self.dataCount() to copy");
 		}
-		else if (source.verticalSize() != verticalSize)
+		else if (source.verticalSize() != vertSize)
 		{
 			for (int i = 0; i < source.dataCount(); i++)
 			{
-				int outputOffset = offset + outputDataIndexOffset * verticalSize + i * verticalSize;
+				int outputOffset = offset + outputDataIndexOffset * vertSize + i * vertSize;
 				source.subView(i, 1).copyTo(data.elements(), outputOffset, source.verticalSize());
 				Arrays.fill(data.elements(), outputOffset + source.verticalSize(),
-						outputOffset + verticalSize, 0);
+						outputOffset + vertSize, 0);
 			}
 		}
 		else
 		{
-			source.copyTo(data.elements(), offset + outputDataIndexOffset * verticalSize, source.size());
+			source.copyTo(data.elements(), offset + outputDataIndexOffset * vertSize, source.size());
 		}
 	}
 	
@@ -123,19 +103,19 @@ public final class ColumnArrayView implements IColumnDataView
 		{
 			throw new IllegalArgumentException("Cannot merge views of different sizes");
 		}
-		if (verticalSize != source.verticalSize)
+		if (vertSize != source.vertSize)
 		{
 			throw new IllegalArgumentException("Cannot merge views of different vertical sizes");
 		}
 		boolean anyChange = false;
-		for (int o = 0; o < (source.size() * verticalSize); o += verticalSize)
+		for (int o = 0; o < (source.size() * vertSize); o += vertSize)
 		{
 			if (override)
 			{
 				if (RenderDataPointUtil.compareDatapointPriority(source.get(o), get(o)) >= 0)
 				{
 					anyChange = true;
-					System.arraycopy(source.data, source.offset + o, data, offset + o, verticalSize);
+					System.arraycopy(source.data, source.offset + o, data, offset + o, vertSize);
 				}
 			}
 			else
@@ -143,7 +123,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, verticalSize);
+					System.arraycopy(source.data, source.offset + o, data, offset + o, vertSize);
 				}
 			}
 		}
@@ -157,7 +137,7 @@ public final class ColumnArrayView implements IColumnDataView
 			throw new IllegalArgumentException("Cannot copy and resize to views with different dataCounts");
 		}
 		
-		if (this.verticalSize >= source.verticalSize())
+		if (this.vertSize >= source.verticalSize())
 		{
 			this.copyFrom(source);
 		}
@@ -180,18 +160,12 @@ 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(verticalSize);
+		sb.append(" V:").append(vertSize);
 		sb.append(" O:").append(offset);
 		
 		sb.append(" [");
@@ -208,7 +182,6 @@ 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

@@ -0,0 +1,253 @@
+/*
+ *    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

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

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

@@ -19,7 +19,6 @@
 
 package com.seibel.distanthorizons.core.dataObjects.transformers;
 
-import java.util.Collections;
 import java.util.List;
 
 import com.seibel.distanthorizons.api.enums.config.EDhApiWorldCompressionMode;
@@ -32,10 +31,10 @@ import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.pos.DhBlockPos;
+import com.seibel.distanthorizons.core.pos.DhChunkPos;
 import com.seibel.distanthorizons.core.pos.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;
@@ -48,6 +47,8 @@ public class LodDataBuilder
 {
 	private static final Logger LOGGER = DhLoggerBuilder.getLogger();
 	private static final IBlockStateWrapper AIR = SingletonInjector.INSTANCE.get(IWrapperFactory.class).getAirBlockStateWrapper();
+	/** how many chunks wide the {@link FullDataSourceV2} is. */
+	private static final int NUMB_OF_CHUNKS_WIDE = FullDataSourceV2.WIDTH / LodUtil.CHUNK_WIDTH;
 	
 	private static boolean getTopErrorLogged = false;
 	
@@ -66,8 +67,12 @@ public class LodDataBuilder
 		
 		
 		
-		int sectionPosX = getXOrZSectionPosFromChunkPos(chunkWrapper.getChunkPos().x);
-		int sectionPosZ = getXOrZSectionPosFromChunkPos(chunkWrapper.getChunkPos().z);
+		// get the section position
+		int sectionPosX = chunkWrapper.getChunkPos().x;
+		// negative positions start at -1 so the logic there is slightly different
+		sectionPosX = (sectionPosX < 0) ? ((sectionPosX + 1) / NUMB_OF_CHUNKS_WIDE) - 1 : (sectionPosX / NUMB_OF_CHUNKS_WIDE);
+		int sectionPosZ = chunkWrapper.getChunkPos().z;
+		sectionPosZ = (sectionPosZ < 0) ? ((sectionPosZ + 1) / NUMB_OF_CHUNKS_WIDE) - 1 : (sectionPosZ / NUMB_OF_CHUNKS_WIDE);
 		long pos = DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, sectionPosX, sectionPosZ);
 		
 		FullDataSourceV2 dataSource = FullDataSourceV2.createEmpty(pos);
@@ -93,30 +98,30 @@ public class LodDataBuilder
 			// -3 -> 1
 			// -4 -> 0 ---
 			// -5 -> 3
-			chunkOffsetX = ((chunkOffsetX) % FullDataSourceV2.NUMB_OF_CHUNKS_WIDE);
+			chunkOffsetX = ((chunkOffsetX) % NUMB_OF_CHUNKS_WIDE);
 			if (chunkOffsetX != 0)
 			{
-				chunkOffsetX += FullDataSourceV2.NUMB_OF_CHUNKS_WIDE;
+				chunkOffsetX += NUMB_OF_CHUNKS_WIDE;
 			}
 		}
 		else
 		{
-			chunkOffsetX %= FullDataSourceV2.NUMB_OF_CHUNKS_WIDE;
+			chunkOffsetX %= NUMB_OF_CHUNKS_WIDE;
 		}
 		chunkOffsetX *= LodUtil.CHUNK_WIDTH;
 		
 		int chunkOffsetZ = chunkWrapper.getChunkPos().z;
 		if (chunkWrapper.getChunkPos().z < 0)
 		{
-			chunkOffsetZ = ((chunkOffsetZ) % FullDataSourceV2.NUMB_OF_CHUNKS_WIDE);
+			chunkOffsetZ = ((chunkOffsetZ) % NUMB_OF_CHUNKS_WIDE);
 			if (chunkOffsetZ != 0)
 			{
-				chunkOffsetZ += FullDataSourceV2.NUMB_OF_CHUNKS_WIDE;
+				chunkOffsetZ += NUMB_OF_CHUNKS_WIDE;
 			}
 		}
 		else
 		{
-			chunkOffsetZ %= FullDataSourceV2.NUMB_OF_CHUNKS_WIDE;
+			chunkOffsetZ %= NUMB_OF_CHUNKS_WIDE;
 		}
 		chunkOffsetZ *= LodUtil.CHUNK_WIDTH;
 		
@@ -154,8 +159,8 @@ public class LodDataBuilder
 					else
 					{
 						//we are at the height limit. There are no torches here, and sky is not obscured.
-						blockLight = LodUtil.MIN_MC_LIGHT;
-						skyLight = LodUtil.MAX_MC_LIGHT;
+						blockLight = 0;
+						skyLight = 15;
 					}
 					
 					
@@ -297,27 +302,14 @@ public class LodDataBuilder
 	
 	
 	/** @throws ClassCastException if an API user returns the wrong object type(s) */
-	public static FullDataSourceV2 createFromApiChunkData(DhApiChunk apiChunk, boolean runAdditionalValidation) throws ClassCastException, DataCorruptedException, IllegalArgumentException
+	public static FullDataSourceV2 createFromApiChunkData(DhApiChunk dataPoints) throws ClassCastException, DataCorruptedException
 	{
-		// get the section position
-		int sectionPosX = getXOrZSectionPosFromChunkPos(apiChunk.chunkPosX);
-		int sectionPosZ = getXOrZSectionPosFromChunkPos(apiChunk.chunkPosZ);
-		long pos = DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, sectionPosX, sectionPosZ);
-		
-		// chunk relative block position in the data source
-		int relSourceBlockX = Math.floorMod(apiChunk.chunkPosX, 4) * LodUtil.CHUNK_WIDTH;
-		int relSourceBlockZ = Math.floorMod(apiChunk.chunkPosZ, 4) * LodUtil.CHUNK_WIDTH;
-		
-		FullDataSourceV2 dataSource = FullDataSourceV2.createEmpty(pos);
-		for (int relBlockZ = 0; relBlockZ < LodUtil.CHUNK_WIDTH; relBlockZ++)
+		FullDataSourceV2 accessor = FullDataSourceV2.createEmpty(DhSectionPos.encode(new DhChunkPos(dataPoints.chunkPosX, dataPoints.chunkPosZ)));
+		for (int relZ = 0; relZ < LodUtil.CHUNK_WIDTH; relZ++)
 		{
-			for (int relBlockX = 0; relBlockX < LodUtil.CHUNK_WIDTH; relBlockX++)
+			for (int relX = 0; relX < LodUtil.CHUNK_WIDTH; relX++)
 			{
-				List<DhApiTerrainDataPoint> columnDataPoints = apiChunk.getDataPoints(relBlockX, relBlockZ);
-				if (runAdditionalValidation)
-				{
-					validateOrThrowDataColumn(columnDataPoints);
-				}
+				List<DhApiTerrainDataPoint> columnDataPoints = dataPoints.getDataPoints(relX, relZ);
 				
 				
 				// this null check does 2 nice things at the same time:
@@ -326,14 +318,12 @@ public class LodDataBuilder
 				// AND the below loop won't run.
 				int size = (columnDataPoints != null) ? columnDataPoints.size() : 0;
 				
-				// TODO make missing air LODs
-				// TODO merge duplicate datapoints
 				LongArrayList packedDataPoints = new LongArrayList(new long[size]);
 				for (int index = 0; index < size; index++)
 				{
 					DhApiTerrainDataPoint dataPoint = columnDataPoints.get(index);
 					
-					int id = dataSource.mapping.addIfNotPresentAndGetId(
+					int id = accessor.mapping.addIfNotPresentAndGetId(
 							(IBiomeWrapper) (dataPoint.biomeWrapper),
 							(IBlockStateWrapper) (dataPoint.blockStateWrapper)
 					);
@@ -341,7 +331,7 @@ public class LodDataBuilder
 					packedDataPoints.set(index, FullDataPointUtil.encode(
 							id,
 							dataPoint.topYBlockPos - dataPoint.bottomYBlockPos,
-							dataPoint.bottomYBlockPos - apiChunk.bottomYBlockPos,
+							dataPoint.bottomYBlockPos - dataPoints.topYBlockPos,
 							(byte) (dataPoint.blockLightLevel),
 							(byte) (dataPoint.skyLightLevel)
 					));
@@ -349,84 +339,12 @@ public class LodDataBuilder
 				
 				// TODO add the ability for API users to define a different compression mode
 				//  or add a "unkown" compression mode
-				dataSource.setSingleColumn(
-						packedDataPoints, 
-						relBlockX + relSourceBlockX, relBlockZ + relSourceBlockZ, 
-						EDhApiWorldGenerationStep.LIGHT, EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS);
-				dataSource.isEmpty = false;
+				accessor.setSingleColumn(packedDataPoints, relX, relZ, EDhApiWorldGenerationStep.LIGHT, EDhApiWorldCompressionMode.MERGE_SAME_BLOCKS);
 			}
 		}
-		return dataSource;
+		
+		return accessor;
 	}
-	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; 
-		}
-		
-	}
-	
 	
 	
 	
@@ -436,13 +354,4 @@ public class LodDataBuilder
 	
 	public static boolean canGenerateLodFromChunk(IChunkWrapper chunk) { return chunk != null && chunk.isLightCorrect(); }
 	
-	public static int getXOrZSectionPosFromChunkPos(int chunkXOrZPos)
-	{
-		// get the section position
-		int sectionPos = chunkXOrZPos;
-		// negative positions start at -1 so the logic there is slightly different
-		sectionPos = (sectionPos < 0) ? ((sectionPos + 1) / FullDataSourceV2.NUMB_OF_CHUNKS_WIDE) - 1 : (sectionPos / FullDataSourceV2.NUMB_OF_CHUNKS_WIDE);
-		return sectionPos;
-	}
-	
 }

core/src/main/java/com/seibel/distanthorizons/core/file/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.*;
@@ -41,17 +41,13 @@ import java.util.*;
  */
 public class ClientOnlySaveStructure extends AbstractSaveStructure
 {
-	public static final String SERVER_DATA_FOLDER_NAME = "Distant_Horizons_server_data";
-	public static final String REPLAY_SERVER_FOLDER_NAME = "REPLAY";
-	public static final String INVALID_FILE_CHARACTERS_REGEX = "[\\\\/:*?\"<>|]";
-	
+	final File folder;
 	private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
 	private static final IMinecraftSharedWrapper MC_SHARED = SingletonInjector.INSTANCE.get(IMinecraftSharedWrapper.class);
+	public static final String INVALID_FILE_CHARACTERS_REGEX = "[\\\\/:*?\"<>|]";
 	
-	
-	private SubDimensionLevelMatcher subDimMatcher = null;
-	private final File folder;
-	private final HashMap<ILevelWrapper, File> levelWrapperToFileMap = new HashMap<>();
+	SubDimensionLevelMatcher subDimMatcher = null;
+	final HashMap<ILevelWrapper, File> levelWrapperToFileMap = new HashMap<>();
 	
 	
 	
@@ -138,7 +134,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: [" + StringUtil.shortenString(folderName, 8) + "...]");
+			LOGGER.info("Default Sub Dimension set to: [" + LodUtil.shortenString(folderName, 8) + "...]");
 			return folders.get(0);
 		}
 		else
@@ -241,7 +237,7 @@ public class ClientOnlySaveStructure extends AbstractSaveStructure
 	private static String getSaveStructureFolderPath()
 	{
 		String path = MC_SHARED.getInstallationDirectory().getPath() + File.separatorChar
-				+ SERVER_DATA_FOLDER_NAME + File.separatorChar
+				+ "Distant_Horizons_server_data" + File.separatorChar
 				+ getServerFolderName();
 		return path;
 	}
@@ -249,14 +245,6 @@ public class ClientOnlySaveStructure extends AbstractSaveStructure
 	/** Generated from the server the client is currently connected to. */
 	private static String getServerFolderName()
 	{
-		// if connected to a replay we won't have any server info
-		// use the dedicated replay server folder
-		if (MC_CLIENT.connectedToReplay())
-		{
-			return REPLAY_SERVER_FOLDER_NAME;
-		}
-		
-		
 		// parse the current server's IP
 		ParsedIp parsedIp = new ParsedIp(MC_CLIENT.getCurrentServerIp());
 		String serverIpCleaned = parsedIp.ip.replaceAll(INVALID_FILE_CHARACTERS_REGEX, "");

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

@@ -40,7 +40,6 @@ 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;
 
@@ -93,7 +92,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 ["+ StringUtil.shortenString(newId, 8)+"]...");
+			LOGGER.info("No potential level files found. Creating a new sub dimension with the ID ["+LodUtil.shortenString(newId, 8)+"]...");
 			this.foundLevelFile = this.CreateSubDimFolder(newId);
 		}
 	}
@@ -191,7 +190,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		}
 		FullDataSourceV2 newChunkSizedFullDataView = FullDataSourceV2.createFromChunk(newlyLoadedChunk);
 		// convert to a data source for easier comparing
-		FullDataSourceV2 newDataSource = FullDataSourceV2.createEmpty(DhSectionPos.encodeContaining(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, this.playerData.playerBlockPos));
+		FullDataSourceV2 newDataSource = FullDataSourceV2.createEmpty(DhSectionPos.encode(this.playerData.playerBlockPos));
 		newDataSource.update(newChunkSizedFullDataView);
 		
 		
@@ -208,7 +207,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		SubDimCompare mostSimilarSubDim = null;
 		for (File testLevelFolder : this.potentialLevelFolders)
 		{
-			LOGGER.info("Testing level folder: [" + StringUtil.shortenString(testLevelFolder.getName(), 8) + "]");
+			LOGGER.info("Testing level folder: [" + LodUtil.shortenString(testLevelFolder.getName(), 8) + "]");
 			
 			FullDataSourceV2 testFullDataSource = null;
 			try
@@ -216,7 +215,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 				// get the data source to compare against
 				try (IDhLevel tempLevel = new DhClientLevel(new ClientOnlySaveStructure(), this.currentClientLevel, testLevelFolder, false))
 				{
-					testFullDataSource = tempLevel.getFullDataProvider().getAsync(DhSectionPos.encodeContaining(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, this.playerData.playerBlockPos)).join();
+					testFullDataSource = tempLevel.getFullDataProvider().getAsync(DhSectionPos.encode(this.playerData.playerBlockPos)).join();
 					if (testFullDataSource == null)
 					{
 						continue;
@@ -329,8 +328,8 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 				}
 				
 				
-				String subDimShortName = StringUtil.shortenString(testLevelFolder.getName(), 8); // variables are separated out for easier debugging
-				String equalPercent = StringUtil.shortenString(mostSimilarSubDim.getPercentEqual()+"", 5);
+				String subDimShortName = LodUtil.shortenString(testLevelFolder.getName(), 8); // variables are separated out for easier debugging
+				String equalPercent = LodUtil.shortenString(mostSimilarSubDim.getPercentEqual()+"", 5);
 				LOGGER.info("Sub dimension ["+subDimShortName+"...] is current dimension probability: "+equalPercent+" ("+equalDataPoints+"/"+totalDataPointCount+")");
 			}
 			catch (Exception e)
@@ -360,7 +359,7 @@ public class SubDimensionLevelMatcher implements AutoCloseable
 		{
 			// we found a sub dim folder that is similar, use it
 			
-			LOGGER.info("Sub Dimension set to: [" + StringUtil.shortenString(mostSimilarSubDim.folder.getName(), 8) + "...] with an equality of [" + mostSimilarSubDim.getPercentEqual() + "]");
+			LOGGER.info("Sub Dimension set to: [" + LodUtil.shortenString(mostSimilarSubDim.folder.getName(), 8) + "...] with an equality of [" + mostSimilarSubDim.getPercentEqual() + "]");
 			return mostSimilarSubDim.folder;
 		}
 		else
@@ -370,7 +369,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 [" + StringUtil.shortenString(highestEqualityPercent + "", 5) + "]. Creating a new sub dimension with ID: " + StringUtil.shortenString(newId, 8) + "...";
+			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) + "...";
 			LOGGER.info(message);
 			
 			File folder = this.CreateSubDimFolder(newId);

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

@@ -47,6 +47,15 @@ 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;
 	
@@ -138,6 +147,14 @@ 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 an opaque block is hit
+								// set each pos' sky light all the way down until a 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,16 +55,6 @@ 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 */
@@ -88,7 +78,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 	// TODO this logic isn't great and can cause a limit to how many threads could be used for world generation, 
 	//  however it won't cause duplicate requests or concurrency issues, so it will be good enough for now.
 	//  A good long term fix may be to either:
-	//  1. allow the generator to deal with larger sections (let the generator threads split up larger tasks into smaller ones
+	//  1. allow the generator to deal with larger sections (let the generator threads split up larger tasks into smaller one
 	//  2. batch requests better. instead of sending 4 individual tasks of detail level N, send 1 task of detail level n+1
 	private final ExecutorService queueingThread = ThreadUtil.makeSingleThreadPool("World Gen Queue");
 	private boolean generationQueueRunning = false;
@@ -216,7 +206,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.isGeneratorBusy() && taskStarted)
+					while (!this.generator.isBusy() && taskStarted)
 					{
 						taskStarted = this.startNextWorldGenTask(this.generationTargetPos);
 						if (!taskStarted)
@@ -236,26 +226,10 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 			catch (Exception e)
 			{
 				LOGGER.error("queueing exception: " + e.getMessage(), e);
-			}
-			finally
-			{
 				this.generationQueueRunning = false;
 			}
 		});
 	}
-	public boolean isGeneratorBusy()
-	{
-		ThreadPoolExecutor executor = ThreadPoolUtil.getWorldGenExecutor();
-		if (executor == null)
-		{
-			// shouldn't happen, but just in case, don't queue more tasks
-			return true;
-		}
-		
-		int worldGenThreadCount = Math.max(Config.Client.Advanced.MultiThreading.numberOfWorldGenerationThreads.get(), 1);
-		int maxWorldGenTaskCount = worldGenThreadCount * MAX_QUEUED_TASKS_PER_THREAD;
-		return executor.getQueue().size() > maxWorldGenTaskCount;
-	}
 	
 	/**
 	 * @param targetPos the position to center the generation around
@@ -399,7 +373,7 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 					// don't log the shutdown exceptions
 					if (!LodUtil.isInterruptOrReject(exception))
 					{
-						LOGGER.error("Error generating data for pos: " + DhSectionPos.toString(taskPos), exception);
+						LOGGER.error("Error generating data for section " + taskPos, exception);
 					}
 					
 					newTaskGroup.group.worldGenTasks.forEach(worldGenTask -> worldGenTask.future.complete(WorldGenResult.CreateFail()));
@@ -409,11 +383,11 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 					newTaskGroup.group.worldGenTasks.forEach(worldGenTask -> worldGenTask.future.complete(WorldGenResult.CreateSuccess(DhSectionPos.encode(granularity, DhSectionPos.getX(taskPos), DhSectionPos.getZ(taskPos)))));
 				}
 				boolean worked = this.inProgressGenTasksByLodPos.remove(taskPos, newTaskGroup);
-				LodUtil.assertTrue(worked, "Unable to find in progress generator task with position ["+DhSectionPos.toString(taskPos)+"]");
+				LodUtil.assertTrue(worked);
 			}
 			catch (Exception e)
 			{
-				LOGGER.error("Unexpected error completing world gen task at pos: ["+DhSectionPos.toString(taskPos)+"].", e);
+				LOGGER.error("Unexpected error completing world gen task: "+taskPos, e);
 			}
 		});
 		
@@ -492,10 +466,10 @@ public class WorldGenerationQueue implements IFullDataSourceRetrievalQueue, IDeb
 					{
 						try
 						{
-							FullDataSourceV2 dataSource = LodDataBuilder.createFromApiChunkData(dataPoints, this.generator.runApiChunkValidation());
+							FullDataSourceV2 dataSource = LodDataBuilder.createFromApiChunkData(dataPoints);
 							chunkDataConsumer.accept(dataSource);
 						}
-						catch (DataCorruptedException | IllegalArgumentException e)
+						catch (DataCorruptedException 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,19 +19,28 @@
 
 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;
@@ -50,6 +59,8 @@ 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;
@@ -60,7 +71,6 @@ 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
@@ -73,7 +83,10 @@ public abstract class AbstractDhLevel implements IDhLevel
 	// constructor //
 	//=============//
 	
-	protected AbstractDhLevel() {  }
+	protected AbstractDhLevel() 
+	{ 
+		this.chunkToLodBuilder = new ChunkToLodBuilder();
+	}
 	
 	/** 
 	 * Creating the repos requires access to the level file, which isn't
@@ -139,7 +152,7 @@ public abstract class AbstractDhLevel implements IDhLevel
 	public int getUnsavedDataSourceCount() { return this.delayedFullDataSourceSaveCache.getUnsavedCount(); }
 	
 	@Override
-	public void updateChunkAsync(IChunkWrapper chunkWrapper, int chunkHash)
+	public void updateChunkAsync(IChunkWrapper chunkWrapper)
 	{
 		FullDataSourceV2 dataSource = FullDataSourceV2.createFromChunk(chunkWrapper);
 		if (dataSource == null)
@@ -158,7 +171,6 @@ 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);
@@ -173,13 +185,6 @@ 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));
@@ -207,6 +212,14 @@ 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));
+		}
+	}
 	
 	
 	
@@ -249,6 +262,8 @@ 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,8 +258,6 @@ 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,6 +86,7 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	{
 		try
 		{
+			this.chunkToLodBuilder.tick();
 			this.clientside.clientTick();
 		}
 		catch (Exception e)
@@ -109,7 +110,7 @@ public class DhClientLevel extends AbstractDhLevel implements IDhClientLevel
 	//================//
 	
 	@Override
-	public int computeBaseColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper block) { return this.levelWrapper.getBlockColor(pos, biome, block); }
+	public int computeBaseColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper block) { return this.levelWrapper.computeBaseColor(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() {  }
+	public void serverTick() { this.chunkToLodBuilder.tick(); }
 	
 	@Override
 	public void doWorldGen()
@@ -146,7 +146,7 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 		}
 		else
 		{
-			return clientLevel.getBlockColor(pos, biome, block);
+			return clientLevel.computeBaseColor(pos, biome, block);
 		}
 	}
 	
@@ -154,7 +154,10 @@ public class DhClientServerLevel extends AbstractDhLevel implements IDhClientLev
 	public IClientLevelWrapper getClientLevelWrapper() { return MC_CLIENT.getWrappedClientLevel(); }
 	
 	@Override
-	public void clearRenderCache() { this.clientside.clearRenderCache(); }
+	public void clearRenderCache()
+	{
+		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() {  }
+	public void serverTick() { this.chunkToLodBuilder.tick(); }
 	
 	@Override
 	public CompletableFuture<Void> updateDataSourcesAsync(FullDataSourceV2 data) { return this.getFullDataProvider().updateDataSourceAsync(data); }

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

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

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

@@ -20,6 +20,7 @@
 package com.seibel.distanthorizons.core.logging.f3;
 
 import com.seibel.distanthorizons.core.api.internal.SharedApi;
+import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.SharedVbo;
 import com.seibel.distanthorizons.core.level.IDhLevel;
 import com.seibel.distanthorizons.core.render.RenderBufferHandler;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
@@ -72,8 +73,6 @@ 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();
@@ -86,8 +85,6 @@ 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());
@@ -115,6 +112,11 @@ public class F3Screen
 				messageList.add(genericRenderer.getVboRenderDebugMenuString());
 			}
 		}
+		messageList.add("");
+		// GPU memory
+		messageList.add("GPU Opaque " + SharedVbo.OPAQUE.getDebugMenuString());
+		messageList.add("GPU Transp " + SharedVbo.TRANSPARENT.getDebugMenuString());
+		messageList.add("");
 	}
 	
 	

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

@@ -19,7 +19,6 @@
 
 package com.seibel.distanthorizons.core.pos;
 
-import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
@@ -34,11 +33,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 4x4 MC chunks (section detail level 6)? </strong> <br>
+ * <strong>Why does the smallest render section represent 2x2 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 64 data points square (IE 4x4 chunks).
+ * With those thoughts in mind we decided on a smallest section size of 32 data points square (IE 2x2 chunks).
  *
  * @author Leetom
  */
@@ -102,32 +101,21 @@ public class DhSectionPos
 		return data;
 	}
 	
-	/** Returns the section pos at the requested detail level containing the given BlockPos */
-	public static long encodeContaining(byte outputSectionDetailLevel, DhBlockPos pos)
+	public static long encode(DhBlockPos pos) { return encodeBlockPos(pos.x, pos.z); }
+	public static long encode(DhBlockPos2D pos) { return encodeBlockPos(pos.x, pos.z); }
+	public static long encodeBlockPos(int blockX, int blockZ)
 	{
-		int sectionPosX = getXOrZSectionPosFromChunkOrBlockPos(pos.x, false);
-		int sectionPosZ = getXOrZSectionPosFromChunkOrBlockPos(pos.z, false);
-		long blockPos = DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, sectionPosX, sectionPosZ);
-		return convertToDetailLevel(blockPos, outputSectionDetailLevel);
+		long pos = encode(LodUtil.BLOCK_DETAIL_LEVEL, blockX, blockZ);
+		pos = convertToDetailLevel(pos, DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL);
+		return pos;
 	}
-	/** Returns the section pos at the requested detail level containing the given ChunkPos */
-	public static long encodeContaining(byte outputSectionDetailLevel, DhChunkPos pos)
+	
+	public static long encode(DhChunkPos pos) { return encodeChunkPos(pos.x, pos.z); }
+	public static long encodeChunkPos(int chunkX, int chunkZ)
 	{
-		int sectionPosX = getXOrZSectionPosFromChunkOrBlockPos(pos.x, true);
-		int sectionPosZ = getXOrZSectionPosFromChunkOrBlockPos(pos.z, true);
-		long blockPos = DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, sectionPosX, sectionPosZ);
-		return convertToDetailLevel(blockPos, outputSectionDetailLevel);
-	}
-	private static int getXOrZSectionPosFromChunkOrBlockPos(int chunkXOrZPos, boolean isChunkPos)
-	{
-		int sectionPos = chunkXOrZPos;
-		int fullDataSourceWidth = isChunkPos ? FullDataSourceV2.NUMB_OF_CHUNKS_WIDE : (FullDataSourceV2.NUMB_OF_CHUNKS_WIDE * LodUtil.CHUNK_WIDTH);
-		
-		// negative positions start at -1 so the logic there is slightly different
-		sectionPos = (sectionPos < 0) 
-				? ((sectionPos + 1) / fullDataSourceWidth) - 1 
-				: (sectionPos / fullDataSourceWidth);
-		return sectionPos;
+		long pos = encode(LodUtil.CHUNK_DETAIL_LEVEL, chunkX, chunkZ);
+		pos = convertToDetailLevel(pos, DhSectionPos.SECTION_CHUNK_DETAIL_LEVEL);
+		return pos;
 	}
 	
 	

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

@@ -54,6 +54,10 @@ 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

@@ -31,7 +31,6 @@ import com.seibel.distanthorizons.core.pos.DhBlockPos2D;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.render.renderer.DebugRenderer;
 import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable;
-import com.seibel.distanthorizons.core.sql.repo.BeaconBeamRepo;
 import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.util.ThreadUtil;
 import com.seibel.distanthorizons.core.util.objects.quadTree.QuadNode;
@@ -74,6 +73,7 @@ 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);
 	
@@ -109,6 +109,8 @@ 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());
 	}
 	
 	
@@ -148,7 +150,7 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 			}
 			catch (Exception e)
 			{
-				LOGGER.error("Quad Tree tick exception for dimension: " + this.level.getLevelWrapper().getDimensionType().getDimensionName() + ", exception: " + e.getMessage(), e);
+				LOGGER.error("Quad Tree tick exception for dimension: " + this.level.getClientLevelWrapper().getDimensionType().getDimensionName() + ", exception: " + e.getMessage(), e);
 			}
 			finally
 			{
@@ -189,7 +191,7 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 				try
 				{
 					LodRenderSection renderSection = this.getValue(pos);
-					if (renderSection != null && renderSection.getRenderingEnabled())
+					if (renderSection != null && renderSection.renderingEnabled)
 					{
 						renderSection.uploadRenderDataToGpuAsync();
 					}
@@ -290,13 +292,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_MINIMUM_DETAIL_LEVEL;
+		expectedDetailLevel += DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL;
 		
 		
 		if (DhSectionPos.getDetailLevel(sectionPos) > expectedDetailLevel)
 		{
 			// section detail level too high //
-			boolean thisPosIsRendering = renderSection.getRenderingEnabled();
+			boolean thisPosIsRendering = renderSection.renderingEnabled;
 			boolean allChildrenSectionsAreLoaded = true;
 			
 			// recursively update all child render sections
@@ -314,8 +316,24 @@ 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.
-				renderSection.setRenderingEnabled(false);
+				if (renderSection.renderingEnabled)
+				{
+					this.level.unloadBeaconBeamsInPos(renderSection.pos);
+				}
+				renderSection.renderingEnabled = 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++)
@@ -366,14 +384,17 @@ 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.getRenderingEnabled())
+					if (!renderSection.renderingEnabled)
 					{
+						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.getRenderingEnabled())
+								if (childRenderSection.renderingEnabled)
 								{
 									// show that this position's rendering has been disabled due to a parent rendering
 									DebugRenderer.makeParticle(
@@ -384,12 +405,10 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 									);
 								}
 								
-								childRenderSection.setRenderingEnabled(false);
+								childRenderSection.renderingEnabled = false;
 								childRenderSection.close();
 							}
 						});
-						
-						renderSection.setRenderingEnabled(true);
 					}
 				}
 				
@@ -595,7 +614,7 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 	// config listeners //
 	//==================//
 	
-	private void onHorizontalQualityChange() { /*this.clearRenderDataCache();*/ }
+	private void onHorizontalQualityChange() { this.clearRenderDataCache(); }
 	
 	
 	//===========//
@@ -627,7 +646,7 @@ public class LodQuadTree extends QuadTree<LodRenderSection> implements IDebugRen
 				}
 				else if (renderSection.renderBuffer.hasNonNullVbos())
 				{
-					if (renderSection.renderBuffer.vboBufferCount() != 0)
+					if (renderSection.renderBuffer.bufferSliceCount() != 0)
 					{
 						color = Color.GREEN;
 					}
@@ -658,6 +677,8 @@ 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,21 +23,17 @@ 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;
@@ -58,7 +54,6 @@ 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);
 	
 	
 	
@@ -70,7 +65,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 	private final LodQuadTree quadTree;
 	
 	
-	private boolean renderingEnabled = false;
+	public boolean renderingEnabled = false;
 	private boolean canRender = false;
 	
 	/** this reference is necessary so we can determine what VBO to render */
@@ -81,19 +76,7 @@ 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> 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 CompletableFuture<Void> uploadRenderDataToGpuFuture = 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 */
@@ -127,7 +110,6 @@ 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())
@@ -137,7 +119,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			return;
 		}
 		
-		if (this.buildAndUploadRenderDataToGpuFuture != null)
+		if (this.uploadRenderDataToGpuFuture != null)
 		{
 			// don't accidentally queue multiple uploads at the same time
 			return;
@@ -151,7 +133,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			return;
 		}
 		
-		this.buildAndUploadRenderDataToGpuFuture = CompletableFuture.runAsync(() -> 
+		this.uploadRenderDataToGpuFuture = CompletableFuture.runAsync(() -> 
 		{
 			//==================//
 			// load render data //
@@ -159,15 +141,15 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			
 			this.tryDecrementingLoadFutureArray(this.adjacentLoadRefFutures);
 			
-			ReferencedFutureWrapper thisRenderSourceLoadFuture = this.getRenderSourceAsync();
-			ReferencedFutureWrapper[] adjRenderSourceLoadRefFutures = this.getNeighborRenderSourcesAsync();
+			ReferencedFutureWrapper thisLoadFuture = this.getRenderSourceAsync();
+			ReferencedFutureWrapper[] adjLoadRefFutures = 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(thisRenderSourceLoadFuture.future);
-			for (ReferencedFutureWrapper refFuture : adjRenderSourceLoadRefFutures)
+			futureList.add(thisLoadFuture.future);
+			for (ReferencedFutureWrapper refFuture : adjLoadRefFutures)
 			{
 				futureList.add(refFuture.future);
 			}
@@ -176,107 +158,72 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			{
 				try
 				{
-					ColumnRenderSource renderSource = thisRenderSourceLoadFuture.future.get();
+					ColumnRenderSource renderSource = thisLoadFuture.future.get();
 					if (renderSource == null || renderSource.isEmpty())
 					{
-						thisRenderSourceLoadFuture.decrementRefCount();
-						for (ReferencedFutureWrapper futureWrapper : adjRenderSourceLoadRefFutures)
+						thisLoadFuture.decrementRefCount();
+						for (ReferencedFutureWrapper futureWrapper : adjLoadRefFutures)
 						{
 							futureWrapper.decrementRefCount();
 						}
 						
 						// nothing needs to be rendered
 						this.canRender = false;
-						this.buildAndUploadRenderDataToGpuFuture = null;
-						this.bufferBuildFuture = null;
+						this.uploadRenderDataToGpuFuture = null;
 						return;
 					}
 					
 					
 					
-					//=======================//
-					// build new render data //
-					//=======================//
+					//==============================//
+					// build/upload 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] = 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);
+							adjacentRenderSections[i] = adjLoadRefFutures[i].future.getNow(null);
 						}
-						
-						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) ->
+						ColumnRenderBufferBuilder.buildAndUploadBuffersAsync(this.level, renderSource, adjacentRenderSections).thenAccept((buffer) ->
 						{
+							// upload complete, clean up the old data if 
+							this.renderBuffer = buffer;
+							this.canRender = true;
+							this.uploadRenderDataToGpuFuture = null;
 							
 							
-							
-							//===================================//
-							// upload new render data to the GPU //
-							//===================================//
-							
-							if (this.bufferUploadFuture != null)
+							if (previousBuffer != 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.bufferUploadFuture.cancel(true);
+								previousBuffer.close();
 							}
-							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;
-								
-								
-								if (previousBuffer != null)
-								{
-									previousBuffer.close();
-								}
-								
-								thisRenderSourceLoadFuture.decrementRefCount();
-								this.tryDecrementingLoadFutureArray(adjRenderSourceLoadRefFutures);
-								this.adjacentLoadRefFutures = null;
-							});
+							
+							thisLoadFuture.decrementRefCount();
+							this.tryDecrementingLoadFutureArray(adjLoadRefFutures);
+							this.adjacentLoadRefFutures = null;
 						});
 					}
 					catch (Exception e)
 					{
-						thisRenderSourceLoadFuture.decrementRefCount();
-						this.tryDecrementingLoadFutureArray(adjRenderSourceLoadRefFutures);
+						thisLoadFuture.decrementRefCount();
+						this.tryDecrementingLoadFutureArray(adjLoadRefFutures);
 						this.adjacentLoadRefFutures = null;
 						
 						LOGGER.error("Unexpected error in LodRenderSection loading, Error: "+e.getMessage(), e);
-						this.buildAndUploadRenderDataToGpuFuture = null;
-						this.bufferBuildFuture = null;
+						this.uploadRenderDataToGpuFuture = null;
 					}
 				}
 				catch (Exception e)
 				{
-					thisRenderSourceLoadFuture.decrementRefCount();
-					this.tryDecrementingLoadFutureArray(adjRenderSourceLoadRefFutures);
+					thisLoadFuture.decrementRefCount();
+					this.tryDecrementingLoadFutureArray(adjLoadRefFutures);
 					this.adjacentLoadRefFutures = null;
 					
 					LOGGER.error("Unexpected error in LodRenderSection loading, Error: "+e.getMessage(), e);
-					this.buildAndUploadRenderDataToGpuFuture = null;
-					this.bufferBuildFuture = null;
+					this.uploadRenderDataToGpuFuture = null;
 				}
 			});
 		}, executor);
@@ -345,7 +292,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 				}
 				catch (Exception e)
 				{
-					LOGGER.warn("Unable to get render source " + DhSectionPos.toString(this.pos) + ", error: " + e.getMessage(), e);
+					LOGGER.warn("Unable to get render source " + this.pos + ", error: " + e.getMessage(), e);
 					this.renderSourceLoadingRefFuture = null;
 					return null;
 				}
@@ -357,32 +304,6 @@ 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);
-		}
-	}
 	
 	
 	
@@ -392,39 +313,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 	
 	public boolean canRender() { return this.canRender; }
 	
-	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; }
+	public boolean gpuUploadInProgress() { return this.uploadRenderDataToGpuFuture != null; }
 	
 	
 	
@@ -534,18 +423,9 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 			this.renderBuffer.close();
 		}
 		
-		// cancel all in-progress futures since they aren't needed any more
-		if (this.buildAndUploadRenderDataToGpuFuture != null)
+		if (this.uploadRenderDataToGpuFuture != null)
 		{
-			this.buildAndUploadRenderDataToGpuFuture.cancel(true);
-		}
-		if (this.bufferBuildFuture != null)
-		{
-			this.bufferBuildFuture.cancel(true);
-		}
-		if (this.bufferUploadFuture != null)
-		{
-			this.bufferUploadFuture.cancel(true);
+			this.uploadRenderDataToGpuFuture.cancel(true);
 		}
 		
 		// this render section won't be rendering, we don't need to load any data for it
@@ -580,7 +460,7 @@ public class LodRenderSection implements IDebugRenderable, AutoCloseable
 		{
 			color = Color.green;
 		}
-		else if (this.buildAndUploadRenderDataToGpuFuture != null)
+		else if (this.uploadRenderDataToGpuFuture != null)
 		{
 			color = Color.yellow;
 		}

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

@@ -25,11 +25,13 @@ import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShadow
 import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
 import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.ColumnRenderBuffer;
+import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.SharedVbo;
 import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.enums.EDhDirection;
 import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
 import com.seibel.distanthorizons.core.logging.f3.F3Screen;
+import com.seibel.distanthorizons.core.pos.DhBlockPos;
 import com.seibel.distanthorizons.core.pos.DhLodPos;
 import com.seibel.distanthorizons.core.pos.DhSectionPos;
 import com.seibel.distanthorizons.core.pos.Pos2D;
@@ -48,9 +50,7 @@ import org.apache.logging.log4j.Logger;
 import org.joml.Matrix4f;
 import org.joml.Matrix4fc;
 
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.ListIterator;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
@@ -311,7 +311,7 @@ public class RenderBufferHandler implements AutoCloseable
 				}
 				
 				ColumnRenderBuffer buffer = renderSection.renderBuffer;
-				if (buffer == null || !renderSection.getRenderingEnabled())
+				if (buffer == null || !renderSection.renderingEnabled)
 				{
 					continue;
 				}
@@ -348,7 +348,11 @@ public class RenderBufferHandler implements AutoCloseable
 		// TODO why can these sometimes be null when teleporting between multiverses
 		if (this.loadedNearToFarBuffers != null)
 		{
-			this.loadedNearToFarBuffers.forEach(loadedBuffer -> loadedBuffer.buffer.renderOpaque(renderContext, renderEventParam));
+			renderContext.setModelViewMatrixOffset(DhBlockPos.ZERO, renderEventParam);
+			
+			ArrayList<SharedVbo.BufferSlice> sliceList = new ArrayList<>();
+			this.loadedNearToFarBuffers.forEach(loadedBuffer -> sliceList.addAll(Arrays.asList(loadedBuffer.buffer.opaqueBufferSlices)));
+			renderContext.drawSharedVbo(SharedVbo.OPAQUE, sliceList.toArray(new SharedVbo.BufferSlice[0]));
 		}
 	}
 	public void renderTransparent(LodRenderer renderContext, DhApiRenderParam renderEventParam)
@@ -356,12 +360,11 @@ public class RenderBufferHandler implements AutoCloseable
 		// TODO why can these sometimes be null when teleporting between multiverses
 		if (this.loadedNearToFarBuffers != null)
 		{
-			ListIterator<LoadedRenderBuffer> iter = this.loadedNearToFarBuffers.listIterator(this.loadedNearToFarBuffers.size());
-			while (iter.hasPrevious())
-			{
-				LoadedRenderBuffer loadedBuffer = iter.previous();
-				loadedBuffer.buffer.renderTransparent(renderContext, renderEventParam);
-			}
+			renderContext.setModelViewMatrixOffset(DhBlockPos.ZERO, renderEventParam);
+			
+			ArrayList<SharedVbo.BufferSlice> sliceList = new ArrayList<>();
+			this.loadedNearToFarBuffers.forEach(loadedBuffer -> sliceList.addAll(Arrays.asList(loadedBuffer.buffer.transparentBufferSlices)));
+			renderContext.drawSharedVbo(SharedVbo.TRANSPARENT, sliceList.toArray(new SharedVbo.BufferSlice[0]));
 		}
 	}
 	

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

@@ -193,7 +193,17 @@ public class GLProxy
 		return instance;
 	}
 	
-	public EDhApiGpuUploadMethod getGpuUploadMethod() { return this.preferredUploadMethod; }
+	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 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 maxExpansionSize, int bufferHint, int mapFlags)
+	public ByteBuffer mapBuffer(int targetSize, EDhApiGpuUploadMethod uploadMethod, int maxExpensionSize, 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 > maxExpansionSize) newSize = maxExpansionSize;
+			if (newSize > maxExpensionSize) newSize = maxExpensionSize;
 			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 maxExpansionSize)
+	public ByteBuffer mapBuffer(int targetSize, EDhApiGpuUploadMethod uploadMethod, int maxExpensionSize)
 	{
-		return super.mapBuffer(targetSize, uploadMethod, maxExpansionSize,
+		return super.mapBuffer(targetSize, uploadMethod, maxExpensionSize,
 				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,7 +25,6 @@ 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;
@@ -155,7 +154,7 @@ public class QuadElementBuffer extends GLElementBuffer
 		LOGGER.info("Quad IBO Resizing from [" + getCapacity() + "] to [" + quadCount + "]" + " with type: " +
 				GLEnums.getString(type));
 		
-		ByteBuffer buffer = MemoryUtil.memAlloc(indicesCount * GLEnums.getTypeSize(type));
+		ByteBuffer buffer = ByteBuffer.allocateDirect(indicesCount * GLEnums.getTypeSize(type)).order(ByteOrder.nativeOrder());
 		buildBuffer(quadCount, buffer, type);
 		if (!gl.bufferStorageSupported)
 		{
@@ -170,8 +169,6 @@ 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/LodRenderer.java

@@ -25,6 +25,7 @@ import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShader
 import com.seibel.distanthorizons.api.methods.events.abstractEvents.*;
 import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam;
 import com.seibel.distanthorizons.core.config.Config;
+import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.SharedVbo;
 import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.ColumnRenderBuffer;
 import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
@@ -35,11 +36,11 @@ import com.seibel.distanthorizons.core.render.DhApiRenderProxy;
 import com.seibel.distanthorizons.core.render.RenderBufferHandler;
 import com.seibel.distanthorizons.core.render.glObject.GLProxy;
 import com.seibel.distanthorizons.core.render.glObject.GLState;
-import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer;
 import com.seibel.distanthorizons.core.render.glObject.buffer.QuadElementBuffer;
 import com.seibel.distanthorizons.core.render.glObject.texture.*;
 import com.seibel.distanthorizons.core.render.renderer.generic.GenericObjectRenderer;
 import com.seibel.distanthorizons.core.render.renderer.shaders.*;
+import com.seibel.distanthorizons.core.util.LodUtil;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper;
@@ -54,10 +55,13 @@ import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector;
 import com.seibel.distanthorizons.core.util.math.Mat4f;
 import com.seibel.distanthorizons.core.util.math.Vec3d;
 import com.seibel.distanthorizons.core.util.math.Vec3f;
+import it.unimi.dsi.fastutil.ints.IntArrayList;
 import org.apache.logging.log4j.LogManager;
+import org.lwjgl.PointerBuffer;
 import org.lwjgl.opengl.GL32;
 
 import java.awt.*;
+import java.nio.IntBuffer;
 import java.time.Duration;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
@@ -301,8 +305,11 @@ public class LodRenderer
 				// terrain
 				profiler.popPush("LOD Opaque");
 				ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderPassEvent.class, renderEventParam);
+				
 				this.bufferHandler.renderOpaque(this, renderEventParam);
 				
+				
+				
 				// custom objects with SSAO
 				if (Config.Client.Advanced.Graphics.GenericRendering.enableRendering.get())
 				{
@@ -466,6 +473,7 @@ public class LodRenderer
 		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);
 		ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderPassEvent.class, renderEventParam);
+		
 		this.bufferHandler.renderTransparent(this, renderEventParam);
 		GL32.glDepthMask(true); // Apparently the depth mask state is stored in the FBO, so glState fails to restore it...
 		
@@ -485,37 +493,58 @@ public class LodRenderer
 			shaderProgram = shaderProgramOverride;
 		}
 		
+		if (!GL32.glIsProgram(shaderProgram.getId()))
+		{
+			throw new IllegalStateException("No GL program exists with the ID: [" + shaderProgram.getId() + "]. This either means a shader program was freed while it was still in use or was never created.");
+		}
+		
 		shaderProgram.bind();
 		shaderProgram.setModelOffsetPos(modelPos);
 		
 		ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos));
 	}
 	
-	public void drawVbo(GLVertexBuffer vbo)
+	public void drawSharedVbo(SharedVbo sharedVbo, SharedVbo.BufferSlice[] slices)
 	{
-		//// can be uncommented to add additional debug validation to prevent crashes if invalid buffers are being created
-		//// shouldn't be used in production due to the performance hit
-		//if (GL32.glIsBuffer(vbo.getId()))
+		IDhApiShaderProgram shaderProgram = this.lodRenderProgram;
+		IDhApiShaderProgram shaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class);
+		if (shaderProgramOverride != null && shaderProgram.overrideThisFrame())
 		{
-			IDhApiShaderProgram shaderProgram = this.lodRenderProgram;
-			IDhApiShaderProgram shaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class);
-			if (shaderProgramOverride != null && shaderProgram.overrideThisFrame())
-			{
-				shaderProgram = shaderProgramOverride;
-			}
-			
-			
-			vbo.bind();
-			shaderProgram.bindVertexBuffer(vbo.getId());
-			GL32.glDrawElements(GL32.GL_TRIANGLES, (vbo.getVertexCount() / 4) * 6, // TODO what does the 4 and 6 here represent?
-					this.quadIBO.getType(), 0);
-			vbo.unbind();
+			shaderProgram = shaderProgramOverride;
 		}
-		//else
-		//{
-		//	// will spam the log if uncommented, but helpful for validation
-		//	//LOGGER.warn("Unable to draw VBO: "+vbo.getId());
-		//}
+		
+		
+		sharedVbo.bind();
+		shaderProgram.bindVertexBuffer(sharedVbo.vboId);
+		
+		IntArrayList countList = new IntArrayList();
+		IntArrayList baseVertexList = new IntArrayList();
+		for (int i = 0; i < slices.length; i++)
+		{
+			SharedVbo.BufferSlice slice = slices[i];
+			if (slice != null && slice.vertexCount != 0)
+			{
+				countList.add((slice.vertexCount / 4) * 6); // 4 vertices per quad, 6 indices per quad
+				baseVertexList.add((int)slice.startIndex / LodUtil.LOD_VERTEX_FORMAT.getByteSize());
+			}
+		}
+		
+		int[] counts = countList.toIntArray();
+		PointerBuffer iboIndicies = PointerBuffer.allocateDirect(counts.length);
+		for (int i = 0; i < counts.length; i++)
+		{
+			iboIndicies.put(0L);
+		}
+		iboIndicies.rewind();
+		int[] baseVertecies = baseVertexList.toIntArray();
+		
+		
+		if (counts.length != 0)
+		{
+			GL32.glMultiDrawElementsBaseVertex(GL32.GL_TRIANGLES, counts, this.quadIBO.getType(), iboIndicies, baseVertecies);
+		}
+		
+		sharedVbo.unbind();
 	}
 	
 	

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

@@ -24,7 +24,6 @@ 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;
@@ -87,14 +86,14 @@ public class ScreenQuad
 	
 	private void createBuffer()
 	{
-		ByteBuffer buffer = MemoryUtil.memAlloc(box_vertices.length * Float.BYTES);
+		ByteBuffer buffer = ByteBuffer.allocateDirect(box_vertices.length * Float.BYTES);
+		buffer.order(ByteOrder.nativeOrder());
 		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,6 +22,7 @@ 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;
@@ -41,6 +42,7 @@ 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
 {
@@ -54,7 +56,7 @@ public class BeaconRenderHandler
 	private final BeaconBeamRepo beaconBeamRepo;
 	
 	private final IDhApiRenderableBoxGroup beaconBoxGroup;
-	private final HashSet<DhBlockPos> beaconBlockPosSet = new HashSet<>();
+	private final HashMap<DhBlockPos, AtomicInteger> beaconRefCountByBlockPos = new HashMap<>();
 	
 	
 	
@@ -94,8 +96,8 @@ public class BeaconRenderHandler
 			for (int i = 0; i < newBeamList.size(); i++)
 			{
 				BeaconBeamDTO beam = newBeamList.get(i);
-				newBeamByPos.put(beam.blockPos, beam);
-				allPosSet.add(beam.blockPos);
+				newBeamByPos.put(beam.pos, beam);
+				allPosSet.add(beam.pos);
 			}
 			
 			// get existing beams
@@ -104,8 +106,8 @@ public class BeaconRenderHandler
 			for (int i = 0; i < existingBeamList.size(); i++)
 			{
 				BeaconBeamDTO beam = existingBeamList.get(i);
-				existingBeamByPos.put(beam.blockPos, beam);
-				allPosSet.add(beam.blockPos);
+				existingBeamByPos.put(beam.pos, beam);
+				allPosSet.add(beam.pos);
 			}
 			
 			
@@ -166,7 +168,7 @@ public class BeaconRenderHandler
 		for (int i = 0; i < existingBeamList.size(); i++)
 		{
 			BeaconBeamDTO beam = existingBeamList.get(i);
-			this.stopRenderingBeaconAtPos(beam.blockPos);
+			this.stopRenderingBeaconAtPos(beam.pos);
 		}
 	}
 	
@@ -178,37 +180,50 @@ public class BeaconRenderHandler
 	
 	private void startRenderingBeacon(BeaconBeamDTO beacon)
 	{
-		if (this.beaconBlockPosSet.add(beacon.blockPos))
+		this.beaconRefCountByBlockPos.compute(beacon.pos, (beamPos, beaconRefCount) ->
 		{
-			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();
-		}
+			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
+				);
+				
+				this.beaconBoxGroup.add(beaconBox);
+				this.beaconBoxGroup.triggerBoxChange();
+			}
+			return beaconRefCount;
+		});
 	}
 	
 	private void stopRenderingBeaconAtPos(DhBlockPos beaconPos)
 	{
-		if (this.beaconBlockPosSet.remove(beaconPos))
+		this.beaconRefCountByBlockPos.compute(beaconPos, (pos, beaconRefCount) ->
 		{
-			this.beaconBoxGroup.removeIf((box) ->
+			if (beaconRefCount != null
+					&& beaconRefCount.decrementAndGet() <= 0)
 			{
-				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();
-		}
+				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;
+			}
+		});
 	}
 	
 	private void updateBeaconColor(BeaconBeamDTO newBeam)
 	{
-		DhBlockPos pos = newBeam.blockPos;
+		DhBlockPos pos = newBeam.pos;
 		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,7 +50,6 @@ 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;
@@ -193,22 +192,24 @@ public class GenericObjectRenderer implements IDhApiCustomRenderRegister
 	private void createBuffers()
 	{
 		// box vertices 
-		ByteBuffer boxVerticesBuffer = MemoryUtil.memAlloc(BOX_VERTICES.length * Float.BYTES);
+		ByteBuffer boxVerticesBuffer = ByteBuffer.allocateDirect(BOX_VERTICES.length * Float.BYTES);
+		boxVerticesBuffer.order(ByteOrder.nativeOrder());
 		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 = MemoryUtil.memAlloc(BOX_INDICES.length * Integer.BYTES);
+		ByteBuffer solidIndexBuffer = ByteBuffer.allocateDirect(BOX_INDICES.length * Integer.BYTES);
+		solidIndexBuffer.order(ByteOrder.nativeOrder());
 		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,12 +94,6 @@ 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,11 +167,6 @@ 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,12 +125,6 @@ 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,19 +103,17 @@ public class SSAOShader extends AbstractShaderRenderer
 		this.shader.setUniform(this.gSampleCountUniform,
 				Config.Client.Advanced.Graphics.Ssao.sampleCount.get());
 		
-		// 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.gRadiusUniform,
+				Config.Client.Advanced.Graphics.Ssao.radius.get().floatValue());
 		
+		this.shader.setUniform(this.gStrengthUniform,
+				Config.Client.Advanced.Graphics.Ssao.strength.get().floatValue());
 		
-		Number strength = Config.Client.Advanced.Graphics.Ssao.strength.get();
-		this.shader.setUniform(this.gStrengthUniform, strength.floatValue());
+		this.shader.setUniform(this.gMinLightUniform,
+				Config.Client.Advanced.Graphics.Ssao.minLight.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());
+		this.shader.setUniform(this.gBiasUniform,
+				Config.Client.Advanced.Graphics.Ssao.bias.get().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,13 +21,14 @@ 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 blockPos;
+	public DhBlockPos pos;
 	public Color color;
 	
 	
@@ -36,9 +37,9 @@ public class BeaconBeamDTO implements IBaseDTO<DhBlockPos>
 	// constructor //
 	//=============//
 	
-	public BeaconBeamDTO(DhBlockPos blockPos, Color color)
+	public BeaconBeamDTO(DhBlockPos pos, Color color)
 	{
-		this.blockPos = blockPos;
+		this.pos = pos;
 		this.color = color;
 	}
 	
@@ -49,6 +50,6 @@ public class BeaconBeamDTO implements IBaseDTO<DhBlockPos>
 	//===========//
 	
 	@Override 
-	public DhBlockPos getKey() { return this.blockPos; }
+	public DhBlockPos getKey() { return this.pos; }
 	
 }

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.blockPos.x);
-		statement.setObject(i++, dto.blockPos.y);
-		statement.setObject(i++, dto.blockPos.z);
+		statement.setObject(i++, dto.pos.x);
+		statement.setObject(i++, dto.pos.y);
+		statement.setObject(i++, dto.pos.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.blockPos.x);
-		statement.setObject(i++, dto.blockPos.y);
-		statement.setObject(i++, dto.blockPos.z);
+		statement.setObject(i++, dto.pos.x);
+		statement.setObject(i++, dto.pos.y);
+		statement.setObject(i++, dto.pos.z);
 		
 		return statement;
 	}

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

@@ -20,6 +20,7 @@
 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;
@@ -28,8 +29,11 @@ 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;
@@ -40,6 +44,9 @@ 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
 {
@@ -47,7 +54,31 @@ 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
@@ -135,9 +166,92 @@ public class LodUtil
 	
 	
 	
-	//=========//
-	// methods //
-	//=========//
+	
+	/**
+	 * 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);
+	}
 	
 	/** Returns the chunk int position for the given double position */
 	public static int getChunkPosFromDouble(double value) { return (int) Math.floor(value / CHUNK_WIDTH); }
@@ -161,6 +275,11 @@ 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
 	 *
@@ -171,7 +290,26 @@ 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(); }
+	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 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.EMPTY_DATA;
+			return RenderDataPointUtil.createVoidDataPoint();
 		}
 		
 		long highestDataPoint;
@@ -849,7 +849,7 @@ public class RenderDataPointReducingList
 				}
 			}
 			//no visible segments, return void.
-			return RenderDataPointUtil.EMPTY_DATA;
+			return RenderDataPointUtil.createVoidDataPoint();
 		}
 		
 		//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.EMPTY_DATA);
+			view.set(writeIndex++, RenderDataPointUtil.createVoidDataPoint());
 		}
 		
 		for (int size = view.size(); writeIndex < size; writeIndex++)

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

@@ -19,7 +19,6 @@
 
 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;
@@ -111,6 +110,8 @@ 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(
@@ -244,11 +245,11 @@ public class RenderDataPointUtil
 					" Y-:" + getYMin(dataPoint) +
 					" argb:" + getAlpha(dataPoint) + " " +
 					getRed(dataPoint) + " " +
-					getGreen(dataPoint) + " " +
-					getBlue(dataPoint) +
+					getBlue(dataPoint) + " " +
+					getGreen(dataPoint) +
 					" BL:" + getLightBlock(dataPoint) +
 					" SL:" + getLightSky(dataPoint) +
-					" MAT:" + getBlockMaterialId(dataPoint) + "["+ EDhApiBlockMaterial.getFromIndex(getBlockMaterialId(dataPoint))+"]";
+					" BID:" + getBlockMaterialId(dataPoint);
 		}
 	}
 	
@@ -302,6 +303,352 @@ 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,6 +48,93 @@ 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 //
 	//=====================//
@@ -79,6 +166,19 @@ 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

@@ -0,0 +1,100 @@
+/*
+ *    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/world/DhClientWorld.java

@@ -19,18 +19,26 @@
 
 package com.seibel.distanthorizons.core.world;
 
+import com.seibel.distanthorizons.core.config.Config;
 import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
 import com.seibel.distanthorizons.core.file.structure.ClientOnlySaveStructure;
 import com.seibel.distanthorizons.core.level.IDhLevel;
 import com.seibel.distanthorizons.core.level.DhClientLevel;
+import com.seibel.distanthorizons.core.network.NetworkClient;
+import com.seibel.distanthorizons.core.network.messages.*;
+import com.seibel.distanthorizons.core.network.messages.PlayerUUIDMessage;
+import com.seibel.distanthorizons.core.network.messages.RemotePlayerConfigMessage;
+import com.seibel.distanthorizons.core.network.objects.RemotePlayer;
 import com.seibel.distanthorizons.core.util.ThreadUtil;
 import com.seibel.distanthorizons.core.util.objects.EventLoop;
 import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
 import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
+import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 

core/src/main/java/com/seibel/distanthorizons/core/wrapperInterfaces/IWrapperFactory.java

@@ -82,17 +82,6 @@ public interface IWrapperFactory extends IDhApiWrapperFactory, IBindable
 	 * Generally this contains blocks like: air, barriers, light blocks, etc. 
 	 */
 	HashSet<IBlockStateWrapper> getRendererIgnoredBlocks(ILevelWrapper levelWrapper);
-	/**
-	 * Returns the set of {@link IBlockStateWrapper}'s that shouldn't be rendered in caves. <br>
-	 * Generally this contains blocks like: air, rails, glow lichen, etc. 
-	 */
-	HashSet<IBlockStateWrapper> getRendererIgnoredCaveBlocks(ILevelWrapper levelWrapper);
-	
-	/** clears the cached values */
-	void resetRendererIgnoredCaveBlocks();
-	/** clears the cached values */
-	void resetRendererIgnoredBlocksSet();
-	
 	
 	/**
 	 * Specifically designed to be used with the API.

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

@@ -141,25 +141,6 @@ 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,7 +25,6 @@ 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;
@@ -80,11 +79,9 @@ 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);
@@ -153,77 +150,29 @@ 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
 	 */
-	@Deprecated
-	default boolean bakeDhLightingUsingMcLightingEngine(ILevelWrapper levelWrapper) throws IllegalStateException
+	default void bakeDhLightingUsingMcLightingEngine() throws IllegalStateException
 	{
 		if (!this.isLightCorrect())
 		{
-			return false;
+			throw new IllegalStateException("Unable to bake lighting for for chunk [" + this.getChunkPos() + "], Minecraft lighting not valid.");
 		}
 		
-		//=======================//
-		// 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();
-		
+		// get the lighting for every relative block pos
 		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++)
 				{
-					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;
-					}
+					this.setDhSkyLight(relX, y, relZ, this.getSkyLight(relX, y, relZ));
+					this.setDhBlockLight(relX, y, relZ, this.getBlockLight(relX, y, relZ));
 				}
 			}
 		}
 		
-		
-		
-		//=================//
-		// 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;
 	}
 	
 	
@@ -280,42 +229,18 @@ public interface IChunkWrapper extends IBindable
 		int hash = 31;
 		int primeBlockMultiplier = 227;
 		int primeBiomeMultiplier = 701;
-		int primeHeightMultiplier = 137;
 		
-		int minBuildHeight = this.getMaxNonEmptyHeight();
-		int maxBuildHeight = this.getMinNonEmptyHeight();
+		int minBuildHeight = this.getMinBuildHeight();
+		int maxBuildHeight = this.getMaxBuildHeight();
 		
-		
-		// 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++)
 			{
-				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)
+				for (int y = minBuildHeight; y < maxBuildHeight; y++)
 				{
-					hash = (hash * primeBlockMultiplier) + this.getBlockState(x, solidY, z).hashCode();
-					hash = (hash * primeBiomeMultiplier) + this.getBiome(x, solidY, z).hashCode();
-					hash = (hash * primeHeightMultiplier) + solidY;
+					hash = (hash * primeBlockMultiplier) + this.getBlockState(x, y, z).hashCode();
+					hash = (hash * primeBiomeMultiplier) + this.getBiome(x, y, z).hashCode();
 				}
 			}
 		}

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

@@ -62,8 +62,6 @@ public interface IMinecraftClientWrapper extends IBindable
 	
 	boolean hasSinglePlayerServer();
 	boolean clientConnectedToDedicatedServer();
-	/** for use with the Replay mod */
-	boolean connectedToReplay();
 	
 	String getCurrentServerName();
 	String getCurrentServerIp();
@@ -87,6 +85,10 @@ public interface IMinecraftClientWrapper extends IBindable
 	 */
 	IClientLevelWrapper getWrappedClientLevel();
 	
+	/** Please move over to getInstallationDirectory() within the IMinecraftSharedWrapper */
+	@Deprecated
+	File getGameDirectory();
+	
 	IProfilerWrapper getProfiler();
 	
 	/** Returns all worlds available to the server */

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

@@ -48,10 +48,18 @@ 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); }
@@ -82,6 +90,63 @@ 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,6 +25,8 @@ 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,6 +19,8 @@
 
 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;
@@ -32,10 +34,10 @@ public interface IClientLevelWrapper extends ILevelWrapper
 	@Nullable
 	IServerLevelWrapper tryGetServerSideWrapper();
 	
-	int getBlockColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper blockState);
+	int computeBaseColor(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

@@ -379,14 +379,7 @@
     "How should block data be compressed when creating LOD data? \nThis setting will only affect new or updated LOD data, \nany data already generated when this setting is changed will be \nunaffected until it is modified or re-loaded. \n\nMost Accurate: Merge Same Blocks \nHighest Compression: Visually Equal",
   "distanthorizons.config.client.advanced.lodBuilding.showMigrationChatWarning":
     "Log Migration In Chat",
-  "distanthorizons.config.client.advanced.lodBuilding.ignoredRenderBlockCsv":
-    "Ignored Block CSV",
-  "distanthorizons.config.client.advanced.lodBuilding.ignoredRenderBlockCsv.@tooltip":
-    "A comma separated list of block resource locations that won't be rendered by DH. \nNote: air is always included in this list.",
-  "distanthorizons.config.client.advanced.lodBuilding.ignoredRenderCaveBlockCsv":
-    "Ignored Cave Block CSV",
-  "distanthorizons.config.client.advanced.lodBuilding.ignoredRenderCaveBlockCsv.@tooltip":
-    "A comma separated list of block resource locations that shouldn't be rendered \nif they are in a 0 sky light underground area. \nNote: air is always included in this list.",
+    
     
   "distanthorizons.config.client.advanced.multiplayer":
     "Multiplayer",
@@ -491,20 +484,14 @@
   "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":
@@ -564,10 +551,6 @@
     "Network Events",
   "distanthorizons.config.client.advanced.logging.showLowMemoryWarningOnStartup":
     "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,8 +350,6 @@ public class LightingTestChunkWrapper implements IChunkWrapper
 		}
 		return this.blockLightStorage;
 	}
-	@Override
-	public void clearDhBlockLighting() { throw new UnsupportedOperationException("Not implemented"); }
 	
 	
 	@Override
@@ -366,8 +364,6 @@ 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()
 	{

core/src/test/java/tests/CompressionTest.java

@@ -23,12 +23,11 @@ import com.seibel.distanthorizons.api.enums.config.EDhApiDataCompressionMode;
 import com.seibel.distanthorizons.core.dataObjects.fullData.sources.FullDataSourceV2;
 import com.seibel.distanthorizons.core.sql.dto.FullDataSourceV2DTO;
 import com.seibel.distanthorizons.core.sql.repo.FullDataSourceV2Repo;
+import com.seibel.distanthorizons.coreapi.util.StringUtil;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import org.junit.Assert;
 
 import java.io.*;
-import java.text.CharacterIterator;
-import java.text.StringCharacterIterator;
 
 /**
  * <strong>Note:</strong>
@@ -356,10 +355,10 @@ public class CompressionTest
 			System.out.println("\n");
 			System.out.println("Results: " + compressorName);
 			System.out.println();
-			System.out.println("Total uncompressed data: [" + humanReadableByteCountSI(totalUncompressedFileSizeInBytes) + "] Total compressed data: [" + humanReadableByteCountSI(totalCompressedFileSizeInBytes) + "]. Compression ratio: [" + compressionRatioString + "].");
-			System.out.println("Min uncompressed data: [" + humanReadableByteCountSI(minUncompressedDtoSizeInBytes) + "] Min compressed data: [" + humanReadableByteCountSI(minCompressedDtoSizeInBytes) + "].");
-			System.out.println("Max uncompressed data: [" + humanReadableByteCountSI(maxUncompressedDtoSizeInBytes) + "] Max compressed data: [" + humanReadableByteCountSI(maxCompressedDtoSizeInBytes) + "].");
-			System.out.println("Avg uncompressed data: [" + humanReadableByteCountSI(avgUncompressedDtoSizeInBytes) + "] Avg compressed data: [" + humanReadableByteCountSI(avgCompressedDtoSizeInBytes) + "].");
+			System.out.println("Total uncompressed data: [" + StringUtil.convertByteCountToHumanReadableSI(totalUncompressedFileSizeInBytes) + "] Total compressed data: [" + StringUtil.convertByteCountToHumanReadableSI(totalCompressedFileSizeInBytes) + "]. Compression ratio: [" + compressionRatioString + "].");
+			System.out.println("Min uncompressed data: [" + StringUtil.convertByteCountToHumanReadableSI(minUncompressedDtoSizeInBytes) + "] Min compressed data: [" + StringUtil.convertByteCountToHumanReadableSI(minCompressedDtoSizeInBytes) + "].");
+			System.out.println("Max uncompressed data: [" + StringUtil.convertByteCountToHumanReadableSI(maxUncompressedDtoSizeInBytes) + "] Max compressed data: [" + StringUtil.convertByteCountToHumanReadableSI(maxCompressedDtoSizeInBytes) + "].");
+			System.out.println("Avg uncompressed data: [" + StringUtil.convertByteCountToHumanReadableSI(avgUncompressedDtoSizeInBytes) + "] Avg compressed data: [" + StringUtil.convertByteCountToHumanReadableSI(avgCompressedDtoSizeInBytes) + "].");
 			System.out.println();
 			System.out.println("Total read time in MS: [" + totalReadTimeInNano / 1_000_000.0 + "] Average read time per dto: [" + (totalReadTimeInNano / processedDtoCount) / 1_000_000.0 + "]");
 			System.out.println("Total write time in MS: [" + totalWriteTimeInNano / 1_000_000.0 + "] Average write time per dto: [" + (totalWriteTimeInNano / processedDtoCount) / 1_000_000.0 + "]");
@@ -373,23 +372,4 @@ public class CompressionTest
 	}
 	
 	
-	/**
-	 * Source:
-	 * https://stackoverflow.com/questions/3758606/how-can-i-convert-byte-size-into-a-human-readable-format-in-java#3758880
-	 */
-	public static String humanReadableByteCountSI(long bytes)
-	{
-		if (-1000 < bytes && bytes < 1000)
-		{
-			return bytes + " B";
-		}
-		CharacterIterator ci = new StringCharacterIterator("kMGTPE");
-		while (bytes <= -999_950 || bytes >= 999_950)
-		{
-			bytes /= 1000;
-			ci.next();
-		}
-		return String.format("%.1f %cB", bytes / 1000.0, ci.current());
-	}
-	
 }

core/src/test/java/tests/DhSectionPosTest.java

@@ -191,19 +191,41 @@ public class DhSectionPosTest
 		// origin pos //
 		
 		DhBlockPos originBlockPos = new DhBlockPos(0, 0, 0);
-		long originSectionPos = DhSectionPos.encodeContaining(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, originBlockPos);
-		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, 0, 0), originSectionPos);
+		long originsectionPos = DhSectionPos.encode(originBlockPos);
+		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, 0, 0), originsectionPos);
 		
 		
 		// offset pos //
 		long offsetSectionPos;
 		
 		DhBlockPos offsetBlockPos = new DhBlockPos(1000, 0, 42000);
-		offsetSectionPos = DhSectionPos.encodeContaining(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, offsetBlockPos);
+		offsetSectionPos = DhSectionPos.encode(offsetBlockPos);
 		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, 15, 656), offsetSectionPos);
 		
 		offsetBlockPos = new DhBlockPos(-987654, 0, 46);
-		offsetSectionPos = DhSectionPos.encodeContaining(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, offsetBlockPos);
+		offsetSectionPos = DhSectionPos.encode(offsetBlockPos);
+		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, -15433, 0), offsetSectionPos);
+		
+	}
+	
+	@Test
+	public void createFromBlockPos2D()
+	{
+		// origin pos //
+		
+		DhBlockPos2D originBlockPos = new DhBlockPos2D(0, 0);
+		long originSectionPos = DhSectionPos.encode(originBlockPos);
+		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, 0, 0), originSectionPos);
+		
+		
+		// offset pos //
+		
+		DhBlockPos2D offsetBlockPos = new DhBlockPos2D(1000, 42000);
+		long offsetSectionPos = DhSectionPos.encode(offsetBlockPos);
+		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, 15, 656), offsetSectionPos);
+		
+		offsetBlockPos = new DhBlockPos2D(-987654, 46);
+		offsetSectionPos = DhSectionPos.encode(offsetBlockPos);
 		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_BLOCK_DETAIL_LEVEL, -15433, 0), offsetSectionPos);
 		
 	}
@@ -214,18 +236,18 @@ public class DhSectionPosTest
 		// origin pos //
 		
 		DhChunkPos originChunkPos = new DhChunkPos(0,0);
-		long originSectionPos = DhSectionPos.encodeContaining(DhSectionPos.SECTION_CHUNK_DETAIL_LEVEL, originChunkPos);
+		long originSectionPos = DhSectionPos.encode(originChunkPos);
 		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_CHUNK_DETAIL_LEVEL, 0, 0), originSectionPos);
 		
 		
 		// offset pos //
 		
 		DhChunkPos offsetChunkPos = new DhChunkPos(1000, 42000);
-		long offsetSectionPos = DhSectionPos.encodeContaining(DhSectionPos.SECTION_CHUNK_DETAIL_LEVEL, offsetChunkPos);
+		long offsetSectionPos = DhSectionPos.encode(offsetChunkPos);
 		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_CHUNK_DETAIL_LEVEL, 15, 656), offsetSectionPos);
 		
 		offsetChunkPos = new DhChunkPos(-987654, 46);
-		offsetSectionPos = DhSectionPos.encodeContaining(DhSectionPos.SECTION_CHUNK_DETAIL_LEVEL, offsetChunkPos);
+		offsetSectionPos = DhSectionPos.encode(offsetChunkPos);
 		assertSectionPosEqual(DhSectionPos.encode(DhSectionPos.SECTION_CHUNK_DETAIL_LEVEL, -15433, 0), offsetSectionPos);
 		
 	}