Update Readme.md

It wasn't used and there was a comment saying not to use it

Readme.md

@@ -1,4 +1,11 @@
-# Distant Horizons
+# THIS VERSION IS NO LONGER MAINTAINED! ALL DEVELOPMENT HAVE BEEN MOVED OVER TO THE MAIN BRANCH
+
+# <img src="https://gitlab.com/jeseibel/distant-horizons-core/-/raw/main/_logo%20files/LOD%20logo%20flat%20-%20with%20boarder.png" width="32"> Distant Horizons
+
+> A mod that adds a Level of Detail System to Minecraft
+
+
+# What is Distant Horizons?
 
 This mod adds a Level Of Detail (LOD) system to Minecraft.\
 This implementation renders simplified chunks outside the normal render distance\
@@ -10,12 +17,11 @@ If you want to see a quick demo, check out a video covering the mod here:
 <a href="https://www.youtube.com/watch?v=H2tnvEVbO1c" target="_blank">![Minecraft Level Of Detail (LOD) mod - Alpha 1.5](https://i.ytimg.com/vi_webp/H2tnvEVbO1c/mqdefault.webp)</a>
 
 Architectury version: 3.4-SNAPSHOT\
-Forge version: 36.1.0\
-Fabric version: 0.12.3\
-Fabric API version: 0.34.2+1.16
+Forge version: 36.2.28\
+Fabric version: 0.13.2\
+Fabric API version: 0.42.0+1.16
 
-Modmenu version: 1.16.22\
-Sodium version: mc1.16.5-0.2.0
+Modmenu version: 1.16.22
 
 Notes:\
 This version has been confirmed to work in Eclipse and Retail Minecraft.\
@@ -48,13 +54,15 @@ Side note: invalidate caches and restart if required
 **Using GUI**
 1. Open a command line in the project folder
 2. Run the command: `./gradlew build`
-3. The compiled jar file will be in the folder `fabric/build/libs/` and `forge/build/libs/`
+5. Then run command: `./gradlew mergeJars`
+6. The compiled jar file will be in the folder `Merged`
 
 **If in terminal:**
 1. `git clone -b 1.16.5_architectury --recurse-submodules https://gitlab.com/jeseibel/minecraft-lod-mod.git`
 2. `cd minecraft-lod-mod`
-3. `./gradlew assemble` or `./gradlew build`
-4. The build should be in `fabric/build/libs/` and `forge/build/libs/`
+3. `./gradlew assemble`
+5. `./gradlew mergeJars`
+6. The compiled jar file will be in the folder `Merged`
 
 
 ## Other commands

build.gradle

@@ -50,6 +50,14 @@ subprojects { p ->
             shadowMe(project(":core")) { transitive false }
         }
     }
+
+    jar {
+        manifest {
+            attributes 'Implementation-Title': rootProject.archives_base_name,
+                    'Implementation-Version': rootProject.mod_version,
+                    'Main-Class': 'com.seibel.lod.core.JarMain'
+        }
+    }
 }
 
 allprojects {
@@ -98,6 +106,39 @@ allprojects {
         }
     }
 
+    // Put stuff from gradle.properties into the mod info
+    processResources {
+        def resourceTargets = ["fabric.mod.json", "META-INF/mods.toml"] // Location of where to put
+        def intoTargets = ["$buildDir/resources/main/"] // Location of the built resources folder
+        def replaceProperties = [
+                version: mod_version,
+                mod_name: mod_name,
+                authors: mod_authors,
+                description: mod_description,
+                homepage: mod_homepage,
+                source: mod_source,
+                issues: mod_issues
+        ]   // The left side is what gets replaced in the mod info and the right side is where to get it from in the gradle.properties
+
+        inputs.properties replaceProperties
+        replaceProperties.put 'project', project
+        filesMatching(resourceTargets) {
+            expand replaceProperties
+        }
+
+        intoTargets.each { target ->
+            if (file(target).exists()) {
+                copy {
+                    from(sourceSets.main.resources) {
+                        include resourceTargets
+                        expand replaceProperties
+                    }
+                    into target
+                }
+            }
+        }
+    }
+
     tasks.withType(JavaCompile) {
         options.encoding = "UTF-8"
 

common/src/main/java/com/seibel/lod/common/Config.java

@@ -27,6 +27,7 @@ import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton.IClient.IAdvanced.*;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton.IClient.IGraphics.*;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton.IClient.IWorldGenerator;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton.IClient.IMultiplayer;
 import net.minecraft.client.renderer.DimensionSpecialEffects;
 
 /**
@@ -73,6 +74,9 @@ public class Config extends ConfigGui
 		@ConfigAnnotations.ScreenEntry
 		public static WorldGenerator worldGenerator;
 
+		@ConfigAnnotations.ScreenEntry
+		public static Multiplayer multiplayer;
+
 		@ConfigAnnotations.ScreenEntry
 		public static Advanced advanced;
 
@@ -209,6 +213,13 @@ public class Config extends ConfigGui
 			public static BlocksToAvoid blocksToAvoid = IWorldGenerator.BLOCKS_TO_AVOID_DEFAULT;
 		}
 
+		public static class Multiplayer {
+			@ConfigAnnotations.FileComment
+			public static String _serverFolderNameMode = IMultiplayer.SERVER_FOLDER_NAME_MODE_DESC;
+			@ConfigAnnotations.Entry
+			public static ServerFolderNameMode serverFolderNameMode = IMultiplayer.SERVER_FOLDER_NAME_MODE_DEFAULT;
+		}
+
 		public static class Advanced
 		{
 			@ConfigAnnotations.ScreenEntry

common/src/main/java/com/seibel/lod/common/forge/LodForgeMethodCaller.java

@@ -1,6 +1,6 @@
 package com.seibel.lod.common.forge;
 
-import com.seibel.lod.common.wrappers.minecraft.MinecraftWrapper;
+import com.seibel.lod.common.wrappers.minecraft.MinecraftClientWrapper;
 import net.minecraft.client.renderer.block.model.BakedQuad;
 import net.minecraft.core.Direction;
 import net.minecraft.world.level.block.Block;
@@ -15,5 +15,5 @@ import java.util.Random;
  * @author Ran
  */
 public interface LodForgeMethodCaller {
-    List<BakedQuad> getQuads(MinecraftWrapper mc, Block block, BlockState blockState, Direction direction, Random random);
+    List<BakedQuad> getQuads(MinecraftClientWrapper mc, Block block, BlockState blockState, Direction direction, Random random);
 }

common/src/main/java/com/seibel/lod/common/wrappers/DependencySetup.java

@@ -1,15 +1,13 @@
 package com.seibel.lod.common.wrappers;
 
 import com.seibel.lod.common.LodCommonMain;
-import com.seibel.lod.common.wrappers.block.BlockColorSingletonWrapper;
 import com.seibel.lod.common.wrappers.minecraft.MinecraftRenderWrapper;
-import com.seibel.lod.common.wrappers.minecraft.MinecraftWrapper;
+import com.seibel.lod.common.wrappers.minecraft.MinecraftClientWrapper;
 import com.seibel.lod.core.handlers.IReflectionHandler;
 import com.seibel.lod.core.handlers.ReflectionHandler;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.IVersionConstants;
 import com.seibel.lod.core.wrapperInterfaces.IWrapperFactory;
-import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorSingletonWrapper;
 import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
 import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftWrapper;
 
@@ -25,13 +23,14 @@ import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftWrapper;
  */
 public class DependencySetup {
     public static void createInitialBindings() {
-        SingletonHandler.bind(IBlockColorSingletonWrapper.class, BlockColorSingletonWrapper.INSTANCE);
+        SingletonHandler.bind(IVersionConstants.class, VersionConstants.INSTANCE);
         if (!LodCommonMain.serverSided) {
-            SingletonHandler.bind(IMinecraftWrapper.class, MinecraftWrapper.INSTANCE);
+            SingletonHandler.bind(IMinecraftWrapper.class, MinecraftClientWrapper.INSTANCE);
             SingletonHandler.bind(IMinecraftRenderWrapper.class, MinecraftRenderWrapper.INSTANCE);
-            SingletonHandler.bind(IReflectionHandler.class, ReflectionHandler.createSingleton(MinecraftWrapper.INSTANCE.getOptions().getClass().getDeclaredFields(), MinecraftWrapper.INSTANCE.getOptions()));
+            SingletonHandler.bind(IReflectionHandler.class, ReflectionHandler.createSingleton(MinecraftClientWrapper.INSTANCE.getOptions().getClass().getDeclaredFields(), MinecraftClientWrapper.INSTANCE.getOptions()));
             SingletonHandler.bind(IVersionConstants.class, VersionConstants.INSTANCE);
         }
         SingletonHandler.bind(IWrapperFactory.class, WrapperFactory.INSTANCE);
+        DependencySetupDoneCheck.isDone = true;
     }
 }

common/src/main/java/com/seibel/lod/common/wrappers/DependencySetupDoneCheck.java

@@ -0,0 +1,7 @@
+package com.seibel.lod.common.wrappers;
+
+public class DependencySetupDoneCheck
+{
+	public static boolean isDone = false;
+	
+}

common/src/main/java/com/seibel/lod/common/wrappers/McObjectConverter.java

@@ -46,9 +46,17 @@ public class McObjectConverter
         return matrix;
     }
 
+    static final Direction[] directions;
+    static {
+        LodDirection[] lodDirs = LodDirection.values();
+        directions = new Direction[lodDirs.length];
+        for (LodDirection lodDir : lodDirs) {
+            directions[lodDir.ordinal()] = Direction.byName(lodDir.name());
+        }
+    }
 
     public static Direction Convert(LodDirection lodDirection)
     {
-        return Direction.byName(lodDirection.name());
+        return directions[lodDirection.ordinal()];
     }
 }

common/src/main/java/com/seibel/lod/common/wrappers/VersionConstants.java

@@ -52,4 +52,9 @@ public class VersionConstants implements IVersionConstants {
 	public boolean hasBatchGenerationImplementation() {
 		return true;
 	}
+
+    @Override
+    public boolean isVanillaRenderedChunkSquare() {
+        return true;
+    }
 }

common/src/main/java/com/seibel/lod/common/wrappers/block/BlockColorSingletonWrapper.java

@@ -1,46 +0,0 @@
-/*
- *    This file is part of the Distant Horizon mod (formerly the LOD Mod),
- *    licensed under the GNU GPL v3 License.
- *
- *    Copyright (C) 2020  James Seibel
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU 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 General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.seibel.lod.common.wrappers.block;
-
-import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorSingletonWrapper;
-import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorWrapper;
-
-import net.minecraft.world.level.block.Blocks;
-
-
-/**
- * Contains methods that would have been static in BlockColorWrapper.
- * Since interfaces can't create/implement static methods we have
- * to split the object up in two.
- *
- * @author James Seibel
- * @version 11-17-2021
- */
-public class BlockColorSingletonWrapper implements IBlockColorSingletonWrapper
-{
-    public static final BlockColorSingletonWrapper INSTANCE = new BlockColorSingletonWrapper();
-
-    @Override
-    public IBlockColorWrapper getWaterColor()
-    {
-        return BlockColorWrapper.getBlockColorWrapper(Blocks.WATER);
-    }
-}
-

common/src/main/java/com/seibel/lod/common/wrappers/block/BlockColorWrapper.java

@@ -1,329 +0,0 @@
-package com.seibel.lod.common.wrappers.block;
-
-import java.util.List;
-import java.util.Objects;
-import java.util.Random;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import com.seibel.lod.common.LodCommonMain;
-import com.seibel.lod.common.wrappers.minecraft.MinecraftWrapper;
-import com.seibel.lod.core.util.ColorUtil;
-import com.seibel.lod.core.wrapperInterfaces.block.AbstractBlockPosWrapper;
-import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorWrapper;
-
-import net.minecraft.client.renderer.block.model.BakedQuad;
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.core.Direction;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.Blocks;
-import net.minecraft.world.level.block.BushBlock;
-import net.minecraft.world.level.block.FlowerBlock;
-import net.minecraft.world.level.block.GrassBlock;
-import net.minecraft.world.level.block.LeavesBlock;
-import net.minecraft.world.level.block.TallGrassBlock;
-import net.minecraft.world.level.block.state.BlockState;
-
-
-/**
- * @author James Seibel
- * @version 11-21-2021
- */
-public class BlockColorWrapper implements IBlockColorWrapper
-{
-    //set of block which require tint
-    public static final ConcurrentMap<Block, BlockColorWrapper> blockColorWrapperMap = new ConcurrentHashMap<>();
-    //    public static final ModelDataMap dataMap = new ModelDataMap.Builder().build();
-    public static final AbstractBlockPosWrapper blockPos = new BlockPosWrapper(0, 0, 0);
-    public static final Random random = new Random(0);
-    //public static BlockColourWrapper WATER_COLOR = getBlockColorWrapper(Blocks.WATER);
-    public static final Direction[] directions = new Direction[] { Direction.UP, Direction.EAST, Direction.SOUTH, Direction.WEST, Direction.NORTH, Direction.DOWN };
-
-    private final Block block;
-    private int color;
-    private boolean isColored;
-    private boolean toTint;
-    private boolean foliageTint;
-    private boolean grassTint;
-    private boolean waterTint;
-
-
-    /**Constructor only require for the block instance we are wrapping**/
-    public BlockColorWrapper(Block block)
-    {
-        this.block = block;
-        this.color = 0;
-        this.isColored = true;
-        this.toTint = false;
-        this.foliageTint = false;
-        this.grassTint = false;
-        this.waterTint = false;
-        setupColorAndTint();
-		/*StringBuilder s = new StringBuilder();
-		s.append(block + "\n"
-								   + Integer.toHexString(
-				Minecraft.getInstance().getBlockColors().createDefault().getColor(
-						block.defaultBlockState(),
-						(World) MinecraftWrapper.INSTANCE.getWrappedServerLevel().getLevel(),
-						blockPosWrapper.getBlockPos())) + "\n"
-		);
-		for(Property x : Minecraft.getInstance().getBlockColors().getColoringProperties(block))
-			s.append(x.getName() + " " + x.getPossibleValues() + '\n');
-		System.out.println(s);*/
-        //System.out.println(block + " color " + Integer.toHexString(color) + " to tint " + toTint + " folliageTint " + folliageTint + " grassTint " + grassTint + " waterTint " + waterTint);
-    }
-
-
-    /**
-     * this return a wrapper of the block in input
-     * @param block object of the block to wrap
-     */
-    public static IBlockColorWrapper getBlockColorWrapper(Block block)
-    {
-        //first we check if the block has already been wrapped
-        if (blockColorWrapperMap.containsKey(block) && blockColorWrapperMap.get(block) != null)
-            return blockColorWrapperMap.get(block);
-
-
-        //if it hasn't been created yet, we create it and save it in the map
-        BlockColorWrapper blockWrapper = new BlockColorWrapper(block);
-        blockColorWrapperMap.put(block, blockWrapper);
-
-        //we return the newly created wrapper
-        return blockWrapper;
-    }
-
-    /**
-     * Generate the color of the given block from its texture
-     * and store it for later use.
-     */
-    private void setupColorAndTint()
-    {
-        BlockState blockState = block.defaultBlockState();
-        //BlockPosWrapper blockPosWrapper = new BlockPosWrapper();
-        MinecraftWrapper mc = MinecraftWrapper.INSTANCE;
-        TextureAtlasSprite texture;
-        List<BakedQuad> quads = null;
-
-        //boolean isTinted = false;
-        //int listSize = 0;
-
-        // first step is to check if this block has a tinted face
-        //for (Direction direction : directions)
-        //{
-        //    quads = mc.getModelManager().getBlockModelShaper().getBlockModel(block.defaultBlockState()).getQuads(blockState, direction, random);
-        //    listSize = Math.max(listSize, quads.size());
-        //    for (BakedQuad bakedQuad : quads)
-        //    {
-        //        isTinted |= bakedQuad.isTinted();
-        //    }
-        //}
-
-        //if it contains a tinted face then we store this block in the toTint set
-        //if (isTinted)
-        //    this.toTint = true;
-
-        //now we get the first non-empty face
-        for (Direction direction : directions)
-        {
-            quads = mc.getModelManager().getBlockModelShaper().getBlockModel(block.defaultBlockState()).getQuads(blockState, direction, random);
-            if (!quads.isEmpty())
-                break;
-        }
-
-        //the quads list is not empty we extract the first one
-        if (!quads.isEmpty())
-        {
-            isColored = true;
-            texture = quads.get(0).sprite;
-        }
-        else
-        {
-            isColored = true;
-            texture = mc.getModelManager().getBlockModelShaper().getParticleIcon(block.defaultBlockState());
-            texture = mc.getModelManager().getBlockModelShaper().getParticleIcon(block.defaultBlockState());
-        }
-
-        int count = 0;
-        int alpha = 0;
-        int red = 0;
-        int green = 0;
-        int blue = 0;
-        int numberOfGreyPixel = 0;
-        int tempColor;
-        int colorMultiplier;
-
-        // generate the block's color
-//        for (int frameIndex = 0; frameIndex < texture.getFrameCount(); frameIndex++)
-        boolean lookForTint = false;
-        if (grassInstance() || leavesInstance() || waterIstance())
-            lookForTint = true;
-
-        // generate the block's color
-        for (int frameIndex = 0; frameIndex < texture.getFrameCount(); frameIndex++)
-        {
-            // textures normally use u and v instead of x and y
-            for (int u = 0; u < texture.getWidth(); u++)
-            {
-                for (int v = 0; v < texture.getHeight(); v++)
-                {
-                    tempColor = TextureAtlasSpriteWrapper.getPixelRGBA(texture, frameIndex, u, v);
-
-                    if (texture.isTransparent(frameIndex, u, v))
-                        continue;
-
-                    if (lookForTint)
-                    {
-                        // determine if this pixel is gray
-                        int colorMax = Math.max(Math.max(ColorUtil.getBlue(tempColor), ColorUtil.getGreen(tempColor)), ColorUtil.getRed(tempColor));
-                        int colorMin = 4 + Math.min(Math.min(ColorUtil.getBlue(tempColor), ColorUtil.getGreen(tempColor)), ColorUtil.getRed(tempColor));
-                        boolean isGray = colorMax < colorMin;
-                        if (isGray)
-                            numberOfGreyPixel++;
-                    }
-
-
-                    // for flowers, weight their non-green color higher
-                    if (block instanceof FlowerBlock && (!(ColorUtil.getGreen(tempColor) > (ColorUtil.getBlue(tempColor) + 30)) || !(ColorUtil.getGreen(tempColor) > (ColorUtil.getRed(tempColor) + 30))))
-                        colorMultiplier = 5;
-                    else
-                        colorMultiplier = 1;
-
-
-                    // add to the running averages
-                    count += colorMultiplier;
-                    alpha += ColorUtil.getAlpha(tempColor) * colorMultiplier;
-                    red += ColorUtil.getBlue(tempColor) * colorMultiplier;
-                    green += ColorUtil.getGreen(tempColor) * colorMultiplier;
-                    blue += ColorUtil.getRed(tempColor) * colorMultiplier;
-                }
-            }
-        }
-
-
-        if (count == 0)
-            // this block is entirely transparent
-            tempColor = 0;
-        else
-        {
-            // determine the average color
-            alpha /= count;
-            red /= count;
-            green /= count;
-            blue /= count;
-            tempColor = ColorUtil.rgbToInt(alpha, red, green, blue);
-        }
-
-        // determine if this block should use the biome color tint
-        if (lookForTint && (float) numberOfGreyPixel / count > 0.75f)
-            this.toTint = true;
-
-        // we check which kind of tint we need to apply
-        this.grassTint = grassInstance() && toTint;
-
-        this.foliageTint = leavesInstance() && toTint;
-
-        this.waterTint = waterIstance() && toTint;
-
-        //hardcoded leaves
-        if (block == Blocks.SPRUCE_LEAVES)
-            color = ColorUtil.multiplyRGBcolors(tempColor, 0xFF619961);
-        else if (block == Blocks.BIRCH_LEAVES)
-            color = ColorUtil.multiplyRGBcolors(tempColor, 0xFF80A755);
-        else
-            color = tempColor;
-    }
-
-    /** determine if the given block should use the biome's grass color */
-    private boolean grassInstance()
-    {
-        return block instanceof GrassBlock
-                || block instanceof BushBlock
-//                || block instanceof IGrowable
-//                || block instanceof AbstractPlantBlock
-//                || block instanceof AbstractTopPlantBlock
-                || block instanceof TallGrassBlock;
-    }
-
-    /** determine if the given block should use the biome's foliage color */
-    private boolean leavesInstance()
-    {
-        return (block instanceof LeavesBlock && block != Blocks.SPRUCE_LEAVES && block != Blocks.BIRCH_LEAVES/* && block != Blocks.AZALEA_LEAVES && block != Blocks.FLOWERING_AZALEA_LEAVES*/)
-                || block == Blocks.VINE
-                || block == Blocks.SUGAR_CANE;
-    }
-
-    /** determine if the given block should use the biome's foliage color */
-    private boolean waterIstance()
-    {
-        return block == Blocks.WATER;
-    }
-
-    @Override
-    public String getName(){
-        return block.getName().toString();
-    }
-
-//--------------//
-//Colors getters//
-//--------------//
-
-    @Override
-    public boolean hasColor()
-    {
-        return isColored;
-    }
-
-    @Override
-    public int getColor()
-    {
-        return color;
-    }
-
-//------------//
-//Tint getters//
-//------------//
-
-
-    @Override
-    public boolean hasTint()
-    {
-        return toTint;
-    }
-
-    @Override
-    public boolean hasGrassTint()
-    {
-        return grassTint;
-    }
-
-    @Override
-    public boolean hasFolliageTint()
-    {
-        return foliageTint;
-    }
-
-    @Override
-    public boolean hasWaterTint()
-    {
-        return waterTint;
-    }
-
-
-
-
-    @Override public boolean equals(Object o)
-    {
-        if (this == o)
-            return true;
-        if (!(o instanceof BlockColorWrapper))
-            return false;
-        BlockColorWrapper that = (BlockColorWrapper) o;
-        return Objects.equals(block, that.block);
-    }
-
-    @Override public int hashCode()
-    {
-        return Objects.hash(block);
-    }
-}

common/src/main/java/com/seibel/lod/common/wrappers/block/BlockDetailMap.java

@@ -0,0 +1,286 @@
+package com.seibel.lod.common.wrappers.block;
+
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.seibel.lod.core.api.ApiShared;
+import com.seibel.lod.core.util.ColorUtil;
+import com.seibel.lod.core.wrapperInterfaces.block.BlockDetail;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.color.block.BlockColors;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.FlowerBlock;
+import net.minecraft.world.level.block.LeavesBlock;
+import net.minecraft.world.level.block.LiquidBlock;
+import net.minecraft.world.level.block.RenderShape;
+import net.minecraft.world.level.block.RotatedPillarBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+public class BlockDetailMap
+{
+    public static final int FLOWER_COLOR_SCALE = 5;
+
+    public static final Random random = new Random(0);
+
+    //TODO: Perhaps make this not just use the first frame?
+    //FIXME: Stuff is wrong.
+    private static int calculateColorFromTexture(TextureAtlasSprite texture, boolean useFlowerScaling, boolean useFastLeaf) {
+
+        int count = 0;
+        double alpha = 0;
+        double red = 0;
+        double green = 0;
+        double blue = 0;
+        int tempColor;
+
+        {
+            // textures normally use u and v instead of x and y
+            for (int u = 0; u < texture.getWidth(); u++)
+            {
+                for (int v = 0; v < texture.getHeight(); v++)
+                {
+                    //note: Minecraft color format is: 0xAA BB GG RR
+                    //________ DH mod color format is: 0xAA RR GG BB
+                    //OpenGL RGBA format native order: 0xRR GG BB AA
+                    //_ OpenGL RGBA format Java Order: 0xAA BB GG RR
+                    tempColor = TextureAtlasSpriteWrapper.getPixelRGBA(texture, 0, u, v);
+
+                    double r = ((tempColor & 0x000000FF)      )/255.;
+                    double g = ((tempColor & 0x0000FF00) >>> 8)/255.;
+                    double b = ((tempColor & 0x00FF0000) >>> 16)/255.;
+                    double a = ((tempColor & 0xFF000000) >>> 24)/255.;
+                    int scale = 1;
+
+                    if (useFastLeaf) {
+                        r *= a;
+                        g *= a;
+                        b *= a;
+                        a = 1.;
+                    } else if (a==0.) {
+                        continue;
+                    } else if (useFlowerScaling && (g+0.1<b || g+0.1<r)) {
+                        scale = FLOWER_COLOR_SCALE;
+                    }
+
+                    count += scale;
+                    alpha += a*a*scale;
+                    red += r*r*scale;
+                    green += g*g*scale;
+                    blue += b*b*scale;
+                }
+            }
+        }
+
+        if (count == 0)
+            // this block is entirely transparent
+            tempColor = ColorUtil.rgbToInt(255,255,0,255);
+        else
+        {
+            // determine the average color
+            tempColor = ColorUtil.rgbToInt(
+                    (int) (Math.sqrt(alpha/count)*255.),
+                    (int) (Math.sqrt(red / count)*255.),
+                    (int) (Math.sqrt(green / count)*255.),
+                    (int) (Math.sqrt(blue / count)*255.));
+        }
+        // TODO: Remove this when transparency is added!
+        double colorAlpha = ColorUtil.getAlpha(tempColor)/255.;
+        tempColor = ColorUtil.rgbToInt(
+                ColorUtil.getAlpha(tempColor),
+                (int)(ColorUtil.getRed(tempColor) * colorAlpha),
+                (int)(ColorUtil.getGreen(tempColor) * colorAlpha),
+                (int)(ColorUtil.getBlue(tempColor) * colorAlpha)
+        );
+
+        return tempColor;
+    }
+
+
+    static class BlockDetailCache {
+        static BlockDetailCache NULL_BLOCK_DETAIL = new BlockDetailCache();
+
+        private static final Block[] BLOCK_TO_AVOID = {Blocks.AIR, Blocks.CAVE_AIR, Blocks.BARRIER};
+
+        private static final Direction[] DIRECTION_ORDER = {Direction.UP, Direction.NORTH, Direction.EAST, Direction.WEST, Direction.SOUTH, Direction.DOWN};
+
+        ConcurrentHashMap<Biome, BlockDetail> biomeDetailMap = null;
+        BlockDetail blockDetail;
+        BlockDetail defaultTintedDetail = null;
+        boolean requireResolving;
+        @SuppressWarnings("unused")
+        boolean requireShade; //TODO: Add back using this in renderer
+        @SuppressWarnings("unused")
+        boolean scaleFlowerColor; //FIXME: Do I need to scale the tint color???
+        int tintIndex;
+
+        static boolean isBlockToBeAvoid(Block b) {
+            for (Block bta : BLOCK_TO_AVOID)
+                if (bta==b) return true;
+            return false;
+        }
+
+        static boolean hasNoCollision(BlockState bs, BlockPos pos, LevelReader getter) {
+            if (!bs.getFluidState().isEmpty() || bs.getBlock() instanceof LiquidBlock) // Is blockState a fluid?
+                return false;
+            if (bs.getCollisionShape(getter, pos).isEmpty())
+                return true;
+            return false;
+        }
+        static boolean hasOnlyNonFullFace(BlockState bs, BlockPos pos, LevelReader getter) {
+            if (!bs.getFluidState().isEmpty() || bs.getBlock() instanceof LiquidBlock) // Is blockState a fluid?
+                return false;
+            VoxelShape voxelShape = bs.getShape(getter, pos);
+            if (voxelShape.isEmpty()) return true;
+            AABB bbox = voxelShape.bounds();
+            double xWidth = (bbox.maxX - bbox.minX);
+            double yWidth = (bbox.maxY - bbox.minY);
+            double zWidth = (bbox.maxZ - bbox.minZ);
+            return xWidth < 1 && zWidth < 1 && yWidth < 1;
+        }
+
+        static BlockDetailCache make(BlockState bs, BlockPos pos, LevelReader getter) {
+            boolean noCol, nonFull, canOcclude;
+            if(!bs.getFluidState().isEmpty()) {
+                bs = bs.getFluidState().createLegacyBlock();
+                FluidState fs = bs.getFluidState();
+                fs.getType();
+                noCol = false;
+                nonFull = false;
+                canOcclude = false;
+                BlockDetailCache result = new BlockDetailCache(fs);
+                //ApiShared.LOGGER.info(fs.toString()+" = ["+result+"]");
+                return result;
+            } else {
+                if (bs.getRenderShape() != RenderShape.MODEL) return NULL_BLOCK_DETAIL;
+                if (isBlockToBeAvoid(bs.getBlock())) return NULL_BLOCK_DETAIL;
+                //BlocksToAvoid toAvoid = CONFIG.client().worldGenerator().getBlocksToAvoid();
+                noCol = hasNoCollision(bs, pos, getter);
+                nonFull = hasOnlyNonFullFace(bs, pos, getter);
+                canOcclude = bs.canOcclude();
+                List<BakedQuad> quads = null;
+                for (Direction direction : DIRECTION_ORDER)
+                {
+                    quads = Minecraft.getInstance().getModelManager().getBlockModelShaper().getBlockModel(bs).getQuads(bs, direction, random);
+                    if (!quads.isEmpty() && !(bs.getBlock() instanceof RotatedPillarBlock && direction == Direction.UP))
+                        break;
+                };
+                if (quads == null || quads.isEmpty()) return NULL_BLOCK_DETAIL;
+                BlockDetailCache result = new BlockDetailCache(canOcclude, noCol, nonFull, quads.get(0),
+                        bs.getBlock() instanceof FlowerBlock, bs.getBlock() instanceof LeavesBlock);
+                // ApiShared.LOGGER.info(bs.toString()+" = ["+result+"]");
+                return result;
+            }
+        }
+
+        BlockDetailCache(boolean isFullBlock, boolean noCol, boolean nonFull, BakedQuad quad, boolean useFlowerScaling, boolean useFastLeaf) {
+            requireResolving = quad.isTinted();
+            requireShade = quad.isShade();
+            tintIndex = quad.getTintIndex();
+            scaleFlowerColor = useFlowerScaling;
+            blockDetail = new BlockDetail(calculateColorFromTexture(quad.sprite, useFlowerScaling, useFastLeaf), isFullBlock, noCol, nonFull);
+            if (quad.isTinted()) biomeDetailMap = new ConcurrentHashMap<Biome, BlockDetail>();
+        }
+
+        BlockDetailCache(FluidState fluid) {
+            requireResolving = true; // TODO: Maybe in the future recheck that there really is no way to see if a fluid needs tinting
+            requireShade = false;
+            tintIndex = 0; // Vanilla doesn't use this index currently. (Checked at 1.18.X, See BlockColors.class)
+            scaleFlowerColor = false;
+            TextureAtlasSprite text = Minecraft.getInstance().getModelManager().getBlockModelShaper().getBlockModel(fluid.createLegacyBlock()).getParticleIcon();
+            blockDetail = new BlockDetail(calculateColorFromTexture(text, false, false), true, false, false);
+            biomeDetailMap = new ConcurrentHashMap<Biome, BlockDetail>();
+        }
+
+        private BlockDetailCache()
+        {
+            //DUMMY CREATOR
+        }
+
+        BlockDetail getResolvedBlockDetail(BlockState bs, int x, int y, int z, LevelReader getter) {
+            if (!requireResolving) return blockDetail;
+            BlockPos pos = new BlockPos(x,y,z);
+            Biome biome = getter.getBiome(pos);
+            BlockDetail tintDetail = biomeDetailMap.get(biome);
+            if (tintDetail == null) {
+                if (!bs.getFluidState().isEmpty()) bs = bs.getFluidState().createLegacyBlock();
+                BlockColors bc = Minecraft.getInstance().getBlockColors();
+                int tintColor = bc.getColor(bs, getter, pos, tintIndex);
+                tintColor = ColorUtil.multiplyARGBwithRGB(blockDetail.color, tintColor);
+                tintDetail = new BlockDetail(tintColor, blockDetail.isFullBlock,
+                        blockDetail.hasNoCollision, blockDetail.hasOnlyNonFullFace);
+                BlockDetail tintDetailCAS = biomeDetailMap.putIfAbsent(biome, tintDetail);
+                if (tintDetailCAS != null) tintDetail = tintDetailCAS;
+            }
+            return tintDetail;
+        }
+
+        // Note: this one won't resolve biome based or pos based colors. (Kinda like GUI block icons)
+        BlockDetail getResolvedBlockDetail(BlockState bs) {
+            if (!requireResolving) return blockDetail;
+            if (defaultTintedDetail != null) return defaultTintedDetail;
+
+            BlockColors bc = Minecraft.getInstance().getBlockColors();
+            if (!bs.getFluidState().isEmpty()) bs = bs.getFluidState().createLegacyBlock();
+            int tintColor = bc.getColor(bs, null, null, tintIndex);
+            if (tintColor == -1) {
+                defaultTintedDetail = blockDetail;
+            }
+            else {
+                defaultTintedDetail = new BlockDetail(ColorUtil.multiplyARGBwithRGB(blockDetail.color, tintColor),
+                        blockDetail.isFullBlock, blockDetail.hasNoCollision, blockDetail.hasOnlyNonFullFace);
+            }
+            return defaultTintedDetail;
+        }
+
+        @Override
+        public String toString() {
+            return "[BlockDetail: "+blockDetail+", RequireResolving: "+requireResolving+", requireShade: "+requireShade+", scaleFlowerColor: "+scaleFlowerColor+"]";
+        }
+
+    }
+
+
+
+    private static ConcurrentHashMap<BlockState, BlockDetailCache> map = new ConcurrentHashMap<BlockState, BlockDetailCache>();
+
+    private BlockDetailMap() {}
+
+    private static BlockDetailCache getOrMakeBlockDetailCache(BlockState bs, BlockPos pos, LevelReader getter) {
+        BlockDetailCache cache = map.get(bs);
+        if (cache != null) return cache;
+        if (bs.getFluidState().isEmpty()) {
+            cache = BlockDetailCache.make(bs, pos, getter);
+        } else {
+            cache = BlockDetailCache.make(bs.getFluidState().createLegacyBlock(), pos, getter);
+        }
+        BlockDetailCache cacheCAS = map.putIfAbsent(bs, cache);
+        return cacheCAS==null ? cache : cacheCAS;
+    }
+
+
+    // Return null means skip the block
+    public static BlockDetail getBlockDetail(BlockState bs) {
+        BlockDetailCache cache = getOrMakeBlockDetailCache(bs, new BlockPos(0, 0, 0), null);
+        if (cache == BlockDetailCache.NULL_BLOCK_DETAIL) return null;
+        return cache.getResolvedBlockDetail(bs);
+    }
+
+    // Return null means skip the block
+    public static BlockDetail getBlockDetailWithCompleteTint(BlockState bs, int x, int y, int z, LevelReader tintGetter) {
+        BlockDetailCache cache = getOrMakeBlockDetailCache(bs, new BlockPos(x,y,z), tintGetter);
+        if (cache == BlockDetailCache.NULL_BLOCK_DETAIL) return null;
+        return cache.getResolvedBlockDetail(bs, x, y, z, tintGetter);
+    }
+}

common/src/main/java/com/seibel/lod/common/wrappers/block/BlockShapeWrapper.java

@@ -1,159 +0,0 @@
-
-package com.seibel.lod.common.wrappers.block;
-
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import com.seibel.lod.core.wrapperInterfaces.block.AbstractBlockPosWrapper;
-import com.seibel.lod.core.wrapperInterfaces.block.IBlockShapeWrapper;
-import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper;
-import com.seibel.lod.common.wrappers.chunk.ChunkWrapper;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.Blocks;
-import net.minecraft.world.level.chunk.ChunkAccess;
-import net.minecraft.world.phys.AABB;
-import net.minecraft.world.phys.shapes.VoxelShape;
-
-
-/**
- * @author James Seibel
- * @version 11-21-2021
- */
-public class BlockShapeWrapper implements IBlockShapeWrapper
-{
-    //set of block which require tint
-    public static final ConcurrentMap<Block, BlockShapeWrapper> blockShapeWrapperMap = new ConcurrentHashMap<>();
-    public static BlockShapeWrapper WATER_SHAPE = new BlockShapeWrapper();
-
-    private final Block block;
-    private final boolean toAvoid;
-    private boolean nonFull;
-    private boolean noCollision;
-
-    /**Constructor only require for the block instance we are wrapping**/
-    public BlockShapeWrapper(Block block, IChunkWrapper chunkWrapper, int x, int y, int z)
-    {
-        this.block = block;
-        this.nonFull = false;
-        this.noCollision = false;
-        this.toAvoid = ofBlockToAvoid();
-        setupShapes(chunkWrapper, x, y, z);
-        //System.out.println(block + " non full " + nonFull + " no collision " + noCollision + " to avoid " + toAvoid);
-    }
-
-    private BlockShapeWrapper()
-    {
-        this.block = Blocks.WATER;
-        this.nonFull = false;
-        this.noCollision = false;
-        this.toAvoid = false;
-    }
-
-    /**
-     * this return a wrapper of the block in input
-     * @param block Block object to wrap
-     */
-    static public BlockShapeWrapper getBlockShapeWrapper(Block block, ChunkWrapper chunkWrapper, int x, int y, int z)
-    {
-        //first we check if the block has already been wrapped
-        if (blockShapeWrapperMap.containsKey(block) && blockShapeWrapperMap.get(block) != null)
-            return blockShapeWrapperMap.get(block);
-
-
-        //if it hasn't been created yet, we create it and save it in the map
-        BlockShapeWrapper blockWrapper = new BlockShapeWrapper(block, chunkWrapper, x, y, z);
-        blockShapeWrapperMap.put(block, blockWrapper);
-
-        //we return the newly created wrapper
-        return blockWrapper;
-    }
-
-    private void setupShapes(IChunkWrapper chunkWrapper, int x, int y, int z)
-    {
-        ChunkAccess chunk = ((ChunkWrapper) chunkWrapper).getChunk();
-        BlockPos blockPos = new BlockPos(x, y, z);
-        boolean noCollisionSetted = false;
-        boolean nonFullSetted = false;
-        if (!block.defaultBlockState().getFluidState().isEmpty())// || block instanceof SixWayBlock)
-        {
-            noCollisionSetted = true;
-            nonFullSetted = true;
-            noCollision = false;
-            nonFull = false;
-        }
-        if (!nonFullSetted)
-        {
-            VoxelShape voxelShape = block.defaultBlockState().getShape(chunk, blockPos);
-
-            if (!voxelShape.isEmpty())
-            {
-                AABB bbox = voxelShape.bounds();
-                double xWidth = (bbox.maxX - bbox.minX);
-                double yWidth = (bbox.maxY - bbox.minY);
-                double zWidth = (bbox.maxZ - bbox.minZ);
-                nonFull = xWidth < 1 && zWidth < 1 && yWidth < 1;
-            }
-            else
-            {
-                nonFull = false;
-            }
-        }
-
-        if (!noCollisionSetted)
-        {
-            VoxelShape collisionShape = block.defaultBlockState().getCollisionShape(chunk, blockPos);
-            noCollision = collisionShape.isEmpty();
-        }
-    }
-
-    @Override
-    public boolean ofBlockToAvoid()
-    {
-        return block.equals(Blocks.AIR)
-                || block.equals(Blocks.CAVE_AIR)
-                || block.equals(Blocks.BARRIER);
-    }
-//-----------------//
-//Avoidance getters//
-//-----------------//
-
-
-    @Override
-    public boolean isNonFull()
-    {
-        return nonFull;
-    }
-
-    @Override
-    public boolean hasNoCollision()
-    {
-        return noCollision;
-    }
-
-    @Override
-    public boolean isToAvoid()
-    {
-        return toAvoid;
-    }
-
-
-
-
-    @Override public boolean equals(Object o)
-    {
-        if (this == o)
-            return true;
-        if (!(o instanceof BlockShapeWrapper))
-            return false;
-        BlockShapeWrapper that = (BlockShapeWrapper) o;
-        return Objects.equals(block, that.block);
-    }
-
-    @Override public int hashCode()
-    {
-        return Objects.hash(block);
-    }
-}

common/src/main/java/com/seibel/lod/common/wrappers/chunk/ChunkWrapper.java

@@ -1,18 +1,18 @@
 package com.seibel.lod.common.wrappers.chunk;
 
+import com.seibel.lod.common.wrappers.worldGeneration.mimicObject.LightedWorldGenRegion;
 import com.seibel.lod.core.util.LevelPosUtil;
 import com.seibel.lod.core.util.LodUtil;
-import com.seibel.lod.core.wrapperInterfaces.block.IBlockColorWrapper;
-import com.seibel.lod.core.wrapperInterfaces.block.IBlockShapeWrapper;
+import com.seibel.lod.core.wrapperInterfaces.block.BlockDetail;
 import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.lod.core.wrapperInterfaces.world.IBiomeWrapper;
 import com.seibel.lod.common.wrappers.WrapperUtil;
-import com.seibel.lod.common.wrappers.block.BlockColorWrapper;
-import com.seibel.lod.common.wrappers.block.BlockShapeWrapper;
+import com.seibel.lod.common.wrappers.block.BlockDetailMap;
 import com.seibel.lod.common.wrappers.world.BiomeWrapper;
 
 import net.minecraft.core.BlockPos;
 import net.minecraft.world.level.BlockAndTintGetter;
+import net.minecraft.world.level.LevelReader;
 import net.minecraft.world.level.LightLayer;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.LiquidBlockContainer;
@@ -20,6 +20,7 @@ import net.minecraft.world.level.block.SimpleWaterloggedBlock;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.block.state.properties.BlockStateProperties;
 import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
 import net.minecraft.world.level.levelgen.Heightmap;
 
 /**
@@ -30,7 +31,7 @@ import net.minecraft.world.level.levelgen.Heightmap;
 public class ChunkWrapper implements IChunkWrapper
 {
     private ChunkAccess chunk;
-    private BlockAndTintGetter lightSource;
+    private LevelReader lightSource;
 
     @Override
     public int getHeight(){
@@ -62,19 +63,9 @@ public class ChunkWrapper implements IChunkWrapper
     }
 
     @Override
-    public IBlockColorWrapper getBlockColorWrapper(int x, int y, int z)
-    {
-        BlockState blockState = chunk.getBlockState(new BlockPos(x,y,z));
-        Block block = blockState.getBlock();
-        return BlockColorWrapper.getBlockColorWrapper(block);
-    }
-
-    @Override
-    public IBlockShapeWrapper getBlockShapeWrapper(int x, int y, int z)
-    {
-        BlockState blockState = chunk.getBlockState(new BlockPos(x,y,z));
-        Block block = blockState.getBlock();
-        return BlockShapeWrapper.getBlockShapeWrapper(block, this, x, y, z);
+    public BlockDetail getBlockDetail(int x, int y, int z) {
+        BlockState blockState = chunk.getBlockState(new BlockPos(x, y, z));
+        return BlockDetailMap.getBlockDetailWithCompleteTint(blockState, x, y, z, lightSource);
     }
 
     @Deprecated
@@ -83,7 +74,7 @@ public class ChunkWrapper implements IChunkWrapper
         this.chunk = chunk;
         this.lightSource = null;
     }
-    public ChunkWrapper(ChunkAccess chunk, BlockAndTintGetter lightSource) {
+    public ChunkWrapper(ChunkAccess chunk, LevelReader lightSource) {
         this.chunk = chunk;
         this.lightSource = lightSource;
     }
@@ -170,4 +161,17 @@ public class ChunkWrapper implements IChunkWrapper
 	public long getLongChunkPos() {
 		return chunk.getPos().toLong();
 	}
+
+    @Override
+    public boolean doesNearbyChunksExist() {
+        if (lightSource instanceof LightedWorldGenRegion) return true;
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                if (dx == 0 && dz == 0) continue;
+                if (lightSource.getChunk(dx + getChunkPosX(), dz + getChunkPosZ(), ChunkStatus.BIOMES, false) == null)
+                    return false;
+            }
+        }
+        return true;
+    }
 }

common/src/main/java/com/seibel/lod/common/wrappers/config/ConfigGui.java

@@ -44,6 +44,7 @@ import net.minecraft.client.gui.components.Button;
 import net.minecraft.client.gui.components.ContainerObjectSelectionList;
 import net.minecraft.client.gui.components.EditBox;
 import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarratableEntry;
 import net.minecraft.client.gui.screens.Screen;
 import net.minecraft.network.chat.CommonComponents;
 import net.minecraft.network.chat.Component;
@@ -752,10 +753,10 @@ public abstract class ConfigGui
 
         // Only for 1.17 and over
         // Remove in 1.16 and below
-//        @Override
-//        public List<? extends NarratableEntry> narratables()
-//        {
-//            return children;
-//        }
+        @Override
+        public List<? extends NarratableEntry> narratables()
+        {
+            return children;
+        }
     }
 }

common/src/main/java/com/seibel/lod/common/wrappers/config/LodConfigWrapperSingleton.java

@@ -3,6 +3,7 @@ package com.seibel.lod.common.wrappers.config;
 import com.seibel.lod.core.enums.config.*;
 import com.seibel.lod.core.enums.rendering.*;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton.IClient.IMultiplayer;
 import com.seibel.lod.common.Config;
 
 /**
@@ -28,6 +29,7 @@ public class LodConfigWrapperSingleton implements ILodConfigWrapperSingleton
 	{
 		public final IGraphics graphics;
 		public final IWorldGenerator worldGenerator;
+		public final IMultiplayer multiplayer;
 		public final IAdvanced advanced;
 
 
@@ -43,6 +45,11 @@ public class LodConfigWrapperSingleton implements ILodConfigWrapperSingleton
 			return worldGenerator;
 		}
 
+		@Override
+		public IMultiplayer multiplayer() {
+			return multiplayer;
+		}
+
 		@Override
 		public IAdvanced advanced()
 		{
@@ -70,6 +77,7 @@ public class LodConfigWrapperSingleton implements ILodConfigWrapperSingleton
 		{
 			graphics = new Graphics();
 			worldGenerator = new WorldGenerator();
+			multiplayer = new Multiplayer();
 			advanced = new Advanced();
 		}
 
@@ -333,20 +341,6 @@ public class LodConfigWrapperSingleton implements ILodConfigWrapperSingleton
 				ConfigGui.editSingleOption.saveOption("client.worldGenerator.distanceGenerationMode");
 			}
 
-			/*
-			@Override
-			public boolean getAllowUnstableFeatureGeneration()
-			{
-				return Config.Client.WorldGenerator.allowUnstableFeatureGeneration;
-			}
-			@Override
-			public void setAllowUnstableFeatureGeneration(boolean newAllowUnstableFeatureGeneration)
-			{
-				ConfigGui.editSingleOption.getEntry("client.worldGenerator.allowUnstableFeatureGeneration").value = newAllowUnstableFeatureGeneration;
-				ConfigGui.editSingleOption.saveOption("client.worldGenerator.allowUnstableFeatureGeneration");
-			}*/
-
-
 			@Override
 			public BlocksToAvoid getBlocksToAvoid()
 			{
@@ -361,7 +355,7 @@ public class LodConfigWrapperSingleton implements ILodConfigWrapperSingleton
 			@Override
 			public boolean getEnableDistantGeneration()
 			{
-				return Config.Client.WorldGenerator.enableDistantGeneration;
+				return (boolean) ConfigGui.editSingleOption.getEntry("client.worldGenerator.enableDistantGeneration").value;
 			}
 			@Override
 			public void setEnableDistantGeneration(boolean newEnableDistantGeneration)
@@ -384,6 +378,27 @@ public class LodConfigWrapperSingleton implements ILodConfigWrapperSingleton
 
 
 
+		//=====================//
+		// Multiplayer Configs //
+		//=====================//
+		public static class Multiplayer implements IMultiplayer
+		{
+			@Override
+			public ServerFolderNameMode getServerFolderNameMode()
+			{
+				return Config.Client.Multiplayer.serverFolderNameMode;
+			}
+			@Override
+			public void setServerFolderNameMode(ServerFolderNameMode newServerFolderNameMode)
+			{
+				ConfigGui.editSingleOption.getEntry("client.multiplayer.serverFolderNameMode").value = newServerFolderNameMode;
+				ConfigGui.editSingleOption.saveOption("client.multiplayer.serverFolderNameMode");
+			}
+
+
+		}
+
+
 
 		//============================//
 		// AdvancedModOptions Configs //

common/src/main/java/com/seibel/lod/common/wrappers/config/TexturedButtonWidget.java

@@ -31,7 +31,7 @@ public class TexturedButtonWidget extends ImageButton {
 	public void renderButton(PoseStack matrices, int mouseX, int mouseY, float delta) {
 
 		Minecraft.getInstance().getTextureManager().bind(WIDGETS_LOCATION);
-		RenderSystem.color4f(1.0F, 1.0F, 1.0F, this.alpha);
+		RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, this.alpha);
 		int i = getYImage(isHovered());
 
 		RenderSystem.enableBlend();

common/src/main/java/com/seibel/lod/common/wrappers/minecraft/MinecraftClientWrapper.java

@@ -26,10 +26,11 @@ import java.util.ArrayList;
 import com.mojang.blaze3d.platform.NativeImage;
 import com.mojang.blaze3d.platform.Window;
 import com.seibel.lod.core.ModInfo;
+import com.seibel.lod.core.api.ApiShared;
 import com.seibel.lod.core.api.ClientApi;
 import com.seibel.lod.core.enums.LodDirection;
 import com.seibel.lod.core.util.LodUtil;
-import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftWrapper;
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
 import com.seibel.lod.core.wrapperInterfaces.minecraft.IProfilerWrapper;
 import com.seibel.lod.core.wrapperInterfaces.misc.ILightMapWrapper;
 import com.seibel.lod.core.wrapperInterfaces.world.IDimensionTypeWrapper;
@@ -69,9 +70,9 @@ import org.jetbrains.annotations.Nullable;
  * @author James Seibel
  * @version 9-16-2021
  */
-public class MinecraftWrapper implements IMinecraftWrapper
+public class MinecraftClientWrapper implements IMinecraftClientWrapper
 {
-    public static final MinecraftWrapper INSTANCE = new MinecraftWrapper();
+    public static final MinecraftClientWrapper INSTANCE = new MinecraftClientWrapper();
 
     public final Minecraft mc = Minecraft.getInstance();
 
@@ -84,7 +85,7 @@ public class MinecraftWrapper implements IMinecraftWrapper
     private ProfilerWrapper profilerWrapper;
 
 
-    private MinecraftWrapper()
+    private MinecraftClientWrapper()
     {
 
     }
@@ -240,7 +241,7 @@ public class MinecraftWrapper implements IMinecraftWrapper
     @Override
     public ChunkPosWrapper getPlayerChunkPos()
     {
-        return new ChunkPosWrapper(getPlayer().xChunk, getPlayer().zChunk);
+        return new ChunkPosWrapper(getPlayer().chunkPosition().x, getPlayer().chunkPosition().z);
     }
 
     public Options getOptions()
@@ -417,7 +418,7 @@ public class MinecraftWrapper implements IMinecraftWrapper
     @Override
     public void crashMinecraft(String errorMessage, Throwable exception)
     {
-        ClientApi.LOGGER.error(ModInfo.READABLE_NAME + " had the following error: [" + errorMessage + "]. Crashing Minecraft...");
+        ApiShared.LOGGER.error(ModInfo.READABLE_NAME + " had the following error: [" + errorMessage + "]. Crashing Minecraft...");
         CrashReport report = new CrashReport(errorMessage, exception);
         Minecraft.crash(report);
     }

common/src/main/java/com/seibel/lod/common/wrappers/minecraft/MinecraftRenderWrapper.java

@@ -2,20 +2,16 @@ package com.seibel.lod.common.wrappers.minecraft;
 
 import java.awt.*;
 import java.util.HashSet;
-import java.util.LinkedHashSet;
 import java.util.stream.Collectors;
 
 import com.mojang.blaze3d.platform.NativeImage;
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.math.Vector3d;
 import com.seibel.lod.common.wrappers.WrapperFactory;
 import com.seibel.lod.common.wrappers.misc.LightMapWrapper;
+import com.seibel.lod.core.api.ApiShared;
 import com.seibel.lod.core.api.ClientApi;
-import com.seibel.lod.core.api.ModAccessorApi;
-import com.seibel.lod.core.handlers.IReflectionHandler;
-import com.seibel.lod.core.handlers.ReflectionHandler;
 import com.seibel.lod.core.util.LodUtil;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.ModAccessorHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.IWrapperFactory;
 import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftWrapper;
 import com.seibel.lod.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
@@ -24,7 +20,6 @@ import it.unimi.dsi.fastutil.objects.ObjectList;
 import net.minecraft.client.renderer.LightTexture;
 import net.minecraft.world.phys.AABB;
 import org.lwjgl.opengl.GL15;
-import org.lwjgl.opengl.GL20;
 
 import com.mojang.math.Vector3f;
 import com.seibel.lod.core.objects.math.Mat4f;
@@ -35,19 +30,18 @@ import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
 import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
 import com.seibel.lod.common.wrappers.McObjectConverter;
 import com.seibel.lod.common.wrappers.block.BlockPosWrapper;
-import com.seibel.lod.common.wrappers.chunk.ChunkPosWrapper;
 
 import net.minecraft.client.Camera;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.GameRenderer;
 import net.minecraft.client.renderer.LevelRenderer;
-import net.minecraft.client.renderer.chunk.ChunkRenderDispatcher.CompiledChunk;
 import net.minecraft.core.BlockPos;
 import net.minecraft.tags.FluidTags;
 import net.minecraft.world.effect.MobEffects;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.level.material.FogType;
 import net.minecraft.world.phys.Vec3;
 
 
@@ -122,7 +116,7 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
     @Override
     public Color getSkyColor() {
         if (MC.level.dimensionType().hasSkyLight()) {
-            Vec3 colorValues = MC.level.getSkyColor(MC.gameRenderer.getMainCamera().getBlockPosition(), MC.getFrameTime());
+            Vec3 colorValues = MC.level.getSkyColor(MC.gameRenderer.getMainCamera().getPosition(), MC.getFrameTime());
             return new Color((float) colorValues.x, (float) colorValues.y, (float) colorValues.z);
         } else
             return new Color(0, 0, 0);
@@ -157,57 +151,46 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
      * is going to render this frame. <br><br>
      * <p>
      */
+    public boolean usingBackupGetVanillaRenderedChunks = false;
     @Override
     public HashSet<AbstractChunkPosWrapper> getVanillaRenderedChunks()
     {
-        ISodiumAccessor sodium = ModAccessorApi.get(ISodiumAccessor.class);
+        ISodiumAccessor sodium = ModAccessorHandler.get(ISodiumAccessor.class);
         if (sodium != null)
         {
             return sodium.getNormalRenderedChunks();
         }
-        IOptifineAccessor optifine = ModAccessorApi.get(IOptifineAccessor.class);
+        IOptifineAccessor optifine = ModAccessorHandler.get(IOptifineAccessor.class);
         if (optifine != null)
         {
             HashSet<AbstractChunkPosWrapper> pos = optifine.getNormalRenderedChunks();
             if (pos==null) pos = getMaximumRenderedChunks();
             return pos;
         }
-        LevelRenderer levelRenderer = MC.levelRenderer;
-        ObjectList<LevelRenderer.RenderChunkInfo> chunks = levelRenderer.renderChunks;
-        return (chunks.stream().map((chunk) -> {
-            AABB chunkBoundingBox = chunk.chunk.bb;
-            return FACTORY.createChunkPos(Math.floorDiv((int) chunkBoundingBox.minX, 16),
-                    Math.floorDiv((int) chunkBoundingBox.minZ, 16));
-        }).collect(Collectors.toCollection(HashSet::new)));
+        if (!usingBackupGetVanillaRenderedChunks) {
+			try {
+		        LevelRenderer levelRenderer = MC.levelRenderer;
+		        ObjectList<LevelRenderer.RenderChunkInfo> chunks = levelRenderer.renderChunks;
+		        return (chunks.stream().map((chunk) -> {
+		            AABB chunkBoundingBox = chunk.chunk.bb;
+		            return FACTORY.createChunkPos(Math.floorDiv((int) chunkBoundingBox.minX, 16),
+		                    Math.floorDiv((int) chunkBoundingBox.minZ, 16));
+		        }).collect(Collectors.toCollection(HashSet::new)));
+			} catch (LinkageError e) {
+				try {
+					MinecraftClientWrapper.INSTANCE.sendChatMessage(
+							"\u00A7e\u00A7l\u00A7uWARNING: Distant Horizons: getVanillaRenderedChunks method failed."
+							+ " Using Backup Method.");
+					MinecraftClientWrapper.INSTANCE.sendChatMessage(
+							"\u00A7eOverdraw prevention will be worse than normal.");
+				} catch (Exception e2) {}
+				ApiShared.LOGGER.error("getVanillaRenderedChunks Error: {}", e);
+				usingBackupGetVanillaRenderedChunks = true;
+			}
+		}
+		return getMaximumRenderedChunks();
     }
 
-    @Override
-    public HashSet<AbstractChunkPosWrapper> getMaximumRenderedChunks()
-    {
-        IMinecraftWrapper mcWrapper = SingletonHandler.get(IMinecraftWrapper.class);
-        IWrapperFactory factory = SingletonHandler.get(IWrapperFactory.class);
-
-        int chunkRenderDist = this.getRenderDistance();
-
-        AbstractChunkPosWrapper centerChunkPos = mcWrapper.getPlayerChunkPos();
-        int startChunkX = centerChunkPos.getX() - chunkRenderDist;
-        int startChunkZ = centerChunkPos.getZ() - chunkRenderDist;
-
-        // add every position within render distance
-        HashSet<AbstractChunkPosWrapper> renderedPos = new HashSet<AbstractChunkPosWrapper>();
-        for (int chunkX = 0; chunkX < (chunkRenderDist * 2+1); chunkX++)
-        {
-            for(int chunkZ = 0; chunkZ < (chunkRenderDist * 2+1); chunkZ++)
-            {
-                renderedPos.add(factory.createChunkPos(startChunkX + chunkX, startChunkZ + chunkZ));
-            }
-        }
-
-        return renderedPos;
-    }
-
-
-
     @Override
     public int[] getLightmapPixels()
     {
@@ -311,12 +294,13 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
     @Override
     public boolean isFogStateSpecial() {
     	Camera camera = GAME_RENDERER.getMainCamera();
-		FluidState fluidState = camera.getFluidInCamera();
+		FogType fogType = camera.getFluidInCamera();
 	    Entity entity = camera.getEntity();
-	    boolean isUnderWater = (entity instanceof LivingEntity) && ((LivingEntity)entity).hasEffect(MobEffects.BLINDNESS);
-	    isUnderWater |= fluidState.is(FluidTags.WATER);
-	    isUnderWater |= fluidState.is(FluidTags.LAVA);
-        return isUnderWater;
+	    boolean enableFog = (entity instanceof LivingEntity) && ((LivingEntity)entity).hasEffect(MobEffects.BLINDNESS);
+	    enableFog |= fogType.equals(FogType.WATER);
+	    enableFog |= fogType.equals(FogType.LAVA);
+	    enableFog |= fogType.equals(FogType.POWDER_SNOW);
+        return enableFog;
     }
 
     @Override

common/src/main/java/com/seibel/lod/common/wrappers/world/WorldWrapper.java

@@ -129,12 +129,6 @@ public class WorldWrapper implements IWorldWrapper
         return world.dimensionType().hasSkyLight();
     }
 
-    @Override
-    public boolean isEmpty()
-    {
-        return world == null;
-    }
-
     @Override
     public int getHeight()
     {

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/BatchGenerationEnvironment.java

@@ -19,6 +19,7 @@
 
 package com.seibel.lod.common.wrappers.worldGeneration;
 
+import com.seibel.lod.core.api.ApiShared;
 import com.seibel.lod.core.api.ClientApi;
 import com.seibel.lod.core.builders.lodBuilding.LodBuilder;
 import com.seibel.lod.core.builders.lodBuilding.LodBuilderConfig;
@@ -26,15 +27,16 @@ import com.seibel.lod.core.enums.config.DistanceGenerationMode;
 import com.seibel.lod.core.objects.lod.LodDimension;
 import com.seibel.lod.core.util.GridList;
 import com.seibel.lod.core.util.LodThreadFactory;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftWrapper;
 import com.seibel.lod.core.wrapperInterfaces.world.IWorldWrapper;
 import com.seibel.lod.core.wrapperInterfaces.worldGeneration.AbstractBatchGenerationEnvionmentWrapper;
 
-import java.io.IOException;
 import java.time.Duration;
 import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -56,10 +58,14 @@ import com.seibel.lod.common.wrappers.worldGeneration.step.StepSurface;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.level.ChunkPos;
 import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkGenerator;
 import net.minecraft.world.level.chunk.ChunkStatus;
 import net.minecraft.world.level.chunk.LevelChunk;
 import net.minecraft.world.level.chunk.ProtoChunk;
 import net.minecraft.world.level.chunk.UpgradeData;
+import net.minecraft.world.level.levelgen.DebugLevelSource;
+import net.minecraft.world.level.levelgen.FlatLevelSource;
+import net.minecraft.world.level.levelgen.NoiseBasedChunkGenerator;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.world.level.lighting.LevelLightEngine;
 
@@ -185,7 +191,7 @@ public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnv
 		}
 	}
 
-	public static final int TIMEOUT_SECONDS = 30;
+	public static final int TIMEOUT_SECONDS = 60;
 
 	// =================Generation Step===================
 
@@ -198,13 +204,29 @@ public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnv
 	public final StepSurface stepSurface = new StepSurface(this);
 	public final StepFeatures stepFeatures = new StepFeatures(this);
 	public final StepLight stepLight = new StepLight(this);
+	public boolean unsafeThreadingRecorded = false;
 	static private final ILodConfigWrapperSingleton CONFIG = SingletonHandler.get(ILodConfigWrapperSingleton.class);
+	private static final IMinecraftWrapper MC = SingletonHandler.get(IMinecraftWrapper.class);
+	public static final long EXCEPTION_TIMER_RESET_TIME = TimeUnit.NANOSECONDS.convert(1, TimeUnit.SECONDS);
+	public static final int EXCEPTION_COUNTER_TRIGGER = 20;
+	public int unknownExceptionCount = 0;
+	public long lastExceptionTriggerTime = 0;
 
 	public static final LodThreadFactory threadFactory = new LodThreadFactory("Gen-Worker-Thread", Thread.MIN_PRIORITY);
 
 	public ExecutorService executors = Executors.newFixedThreadPool(
 			CONFIG.client().advanced().threading().getNumberOfWorldGenerationThreads(), threadFactory);
 
+	public <T> T joinSync(CompletableFuture<T> f) {
+		if (!unsafeThreadingRecorded && !f.isDone()) {
+			MC.sendChatMessage("\u00A74\u00A7l\u00A7uERROR: Distant Horizons: Unsafe Threading in Chunk Generator Detected!");
+			MC.sendChatMessage("\u00A7eTo increase stability, it is recommended to set world generation threads count to 1.");
+			ApiShared.LOGGER.error("Unsafe Threading in Chunk Generator: ", new RuntimeException("Concurrent future"));
+			unsafeThreadingRecorded = true;
+		}
+		return f.join();
+	}
+
 	@Override
 	public void resizeThreadPool(int newThreadCount) {
 		executors = Executors.newFixedThreadPool(newThreadCount,
@@ -228,6 +250,11 @@ public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnv
 
 	@Override
 	public void updateAllFutures() {
+		if (unknownExceptionCount > 0) {
+			if (System.nanoTime() - lastExceptionTriggerTime >= EXCEPTION_TIMER_RESET_TIME) {
+				unknownExceptionCount = 0;
+			}
+		}
 		// Update all current out standing jobs
 		Iterator<GenerationEvent> iter = events.iterator();
 		while (iter.hasNext()) {
@@ -236,30 +263,45 @@ public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnv
 				try {
 					event.join();
 				} catch (Throwable e) {
-					e.printStackTrace();
-					while (e.getCause() != null) {
-						e = e.getCause();
-						e.printStackTrace();
-					}
+					ApiShared.LOGGER.error("Batching World Generator: Event {} gotten an exception", event);
+					ApiShared.LOGGER.error("Exception: ", e);
+					unknownExceptionCount++;
+					lastExceptionTriggerTime = System.nanoTime();
 				} finally {
 					iter.remove();
 				}
 			} else if (event.hasTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
-				ClientApi.LOGGER.error("Batching World Generator: " + event + " timed out and terminated!");
-				ClientApi.LOGGER.info("Dump PrefEvent: " + event.pEvent);
+				ApiShared.LOGGER.error("Batching World Generator: " + event + " timed out and terminated!");
+				ApiShared.LOGGER.info("Dump PrefEvent: " + event.pEvent);
 				try {
 					if (!event.terminate())
-						ClientApi.LOGGER.error("Failed to terminate the stuck generation event!");
+						ApiShared.LOGGER.error("Failed to terminate the stuck generation event!");
 				} finally {
 					iter.remove();
 				}
 			}
 		}
+		if (unknownExceptionCount > EXCEPTION_COUNTER_TRIGGER) {
+			try {
+				MC.sendChatMessage("\u00A74\u00A7l\u00A7uERROR: Distant Horizons: Too many exceptions in Batching World Generator! Disabling the generator.");
+			} catch (Exception e) {}
+			ApiShared.LOGGER.error("Too many exceptions in Batching World Generator! Now disabling.");
+			unknownExceptionCount = 0;
+			CONFIG.client().worldGenerator().setEnableDistantGeneration(false);
+		}
 	}
 
 	public BatchGenerationEnvironment(IWorldWrapper serverlevel, LodBuilder lodBuilder, LodDimension lodDim) {
 		super(serverlevel, lodBuilder, lodDim);
-		ClientApi.LOGGER.info("================WORLD_GEN_STEP_INITING=============");
+		ApiShared.LOGGER.info("================WORLD_GEN_STEP_INITING=============");
+		ChunkGenerator generator =  ((WorldWrapper) serverlevel).getServerWorld().getChunkSource().getGenerator();
+		if (!(generator instanceof NoiseBasedChunkGenerator ||
+				generator instanceof DebugLevelSource ||
+				generator instanceof FlatLevelSource)) {
+			MC.sendChatMessage("\u00A74\u00A7l\u00A7uWARNING: Distant Horizons: Unknown Chunk Generator Detected! Distant Generation May Fail!");
+			MC.sendChatMessage("\u00A7eIf it does crash, set Distant Generation to OFF or Generation Mode to None.");
+			ApiShared.LOGGER.warn("Unknown Chunk Generator detected: {}", generator.getClass());
+		}
 		params = new GlobalParameters((ServerLevel) ((WorldWrapper) serverlevel).getWorld(), lodBuilder, lodDim);
 	}
 
@@ -271,20 +313,25 @@ public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnv
 		CompoundTag chunkData = null;
 		try {
 			chunkData = level.getChunkSource().chunkMap.readChunk(chunkPos);
-		} catch (IOException e) {
-			ClientApi.LOGGER.error("DistantHorizons: Couldn't load chunk {}", chunkPos, e);
+		} catch (Exception e) {
+			ApiShared.LOGGER.error("DistantHorizons: Couldn't load chunk {}", chunkPos, e);
 		}
 		if (chunkData == null) {
 			return new ProtoChunk(chunkPos, UpgradeData.EMPTY);
 		} else {
-			return ChunkLoader.read(level, lightEngine, chunkPos, chunkData);
+			try {
+				return ChunkLoader.read(level, lightEngine, chunkPos, chunkData);
+			} catch (Exception e) {
+				ApiShared.LOGGER.error("DistantHorizons: Couldn't load chunk {}", chunkPos, e);
+				return new ProtoChunk(chunkPos, UpgradeData.EMPTY);
+			}
 		}
 
 	}
 
 	void generateLodFromList(GenerationEvent e) {
 		if (ENABLE_EVENT_LOGGING)
-			ClientApi.LOGGER.info("Lod Generate Event: " + e.pos);
+			ApiShared.LOGGER.info("Lod Generate Event: " + e.pos);
 		e.pEvent.beginNano = System.nanoTime();
 		GridList<ChunkAccess> referencedChunks;
 		DistanceGenerationMode generationMode;
@@ -309,7 +356,6 @@ public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnv
 					target = loadOrMakeChunk(chunkPos, params.level, lightEngine);
 				} catch (RuntimeException e2) {
 					// Continue...
-					e2.printStackTrace();
 				}
 				if (target == null)
 					target = new ProtoChunk(chunkPos, UpgradeData.EMPTY);
@@ -370,7 +416,7 @@ public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnv
 				boolean isFull = target.getStatus() == ChunkStatus.FULL || target instanceof LevelChunk;
 				if (isFull) {
 					if (ENABLE_LOAD_EVENT_LOGGING)
-						ClientApi.LOGGER.info("Detected full existing chunk at {}", target.getPos());
+						ApiShared.LOGGER.info("Detected full existing chunk at {}", target.getPos());
 					params.lodBuilder.generateLodNodeFromChunk(params.lodDim, new ChunkWrapper(target, region),
 							new LodBuilderConfig(DistanceGenerationMode.FULL), true, e.genAllDetails);
 				} else if (target.getStatus() == ChunkStatus.EMPTY && generationMode == DistanceGenerationMode.NONE) {
@@ -387,7 +433,7 @@ public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnv
 		e.refreshTimeout();
 		if (ENABLE_PERF_LOGGING) {
 			e.tParam.perf.recordEvent(e.pEvent);
-			ClientApi.LOGGER.info(e.tParam.perf);
+			ApiShared.LOGGER.info(e.tParam.perf);
 		}
 	}
 
@@ -461,15 +507,15 @@ public final class BatchGenerationEnvironment extends AbstractBatchGenerationEnv
 
 	@Override
 	public void stop(boolean blocking) {
-		ClientApi.LOGGER.info("Batch Chunk Generator shutting down...");
+		ApiShared.LOGGER.info("Batch Chunk Generator shutting down...");
 		executors.shutdownNow();
 		if (blocking) {
 			try {
 				if (!executors.awaitTermination(10, TimeUnit.SECONDS)) {
-					ClientApi.LOGGER.error("Batch Chunk Generator shutdown failed! Ignoring child threads...");
+					ApiShared.LOGGER.error("Batch Chunk Generator shutdown failed! Ignoring child threads...");
 				}
 			} catch (InterruptedException e) {
-				ClientApi.LOGGER.error("Batch Chunk Generator shutdown failed! Ignoring child threads...", e);
+				ApiShared.LOGGER.error("Batch Chunk Generator shutdown failed! Ignoring child threads...", e);
 			}
 		}
 	}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/GenerationEvent.java

@@ -5,9 +5,10 @@ import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
 import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment.PrefEvent;
+import com.seibel.lod.core.api.ApiShared;
 import com.seibel.lod.core.api.ClientApi;
 import com.seibel.lod.core.enums.config.LightGenerationMode;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
 import com.seibel.lod.core.wrapperInterfaces.worldGeneration.AbstractBatchGenerationEnvionmentWrapper.Steps;
 
@@ -58,7 +59,7 @@ public final class GenerationEvent {
 
 	public boolean terminate() {
 		future.cancel(true);
-		ClientApi.LOGGER.info("======================DUMPING ALL THREADS FOR WORLD GEN=======================");
+		ApiShared.LOGGER.info("======================DUMPING ALL THREADS FOR WORLD GEN=======================");
 		BatchGenerationEnvironment.threadFactory.dumpAllThreadStacks();
 		return future.isCancelled();
 	}
@@ -67,7 +68,7 @@ public final class GenerationEvent {
 		try {
 			future.get();
 		} catch (InterruptedException | ExecutionException e) {
-			e.printStackTrace();
+			throw new RuntimeException(e.getCause()==null? e : e.getCause());
 		}
 	}
 

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/WorldGeneratorWrapper.java

@@ -6,7 +6,7 @@ import com.seibel.lod.core.builders.lodBuilding.LodBuilder;
 import com.seibel.lod.core.builders.lodBuilding.LodBuilderConfig;
 import com.seibel.lod.core.enums.config.DistanceGenerationMode;
 import com.seibel.lod.core.objects.lod.LodDimension;
-//import com.seibel.lod.core.util.SingletonHandler;
+//import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
 //import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
 import com.seibel.lod.core.wrapperInterfaces.world.IWorldWrapper;

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/mimicObject/ChunkLoader.java

@@ -1,6 +1,7 @@
 
 package com.seibel.lod.common.wrappers.worldGeneration.mimicObject;
 
+import com.seibel.lod.core.api.ApiShared;
 import com.seibel.lod.core.api.ClientApi;
 
 import java.util.Objects;
@@ -31,7 +32,7 @@ import net.minecraft.world.level.material.Fluids;
 import org.apache.logging.log4j.Logger;
 
 public class ChunkLoader {
-	private static final Logger LOGGER = ClientApi.LOGGER;
+	private static final Logger LOGGER = ApiShared.LOGGER;
 
 	private static LevelChunkSection[] readSections(WorldGenLevel level, LevelLightEngine lightEngine,
 			ChunkPos chunkPos, CompoundTag tagLevel) {

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/mimicObject/LightGetterAdaptor.java

@@ -1,6 +1,6 @@
 package com.seibel.lod.common.wrappers.worldGeneration.mimicObject;
 
-import com.seibel.lod.core.api.ModAccessorApi;
+import com.seibel.lod.core.handlers.dependencyInjection.ModAccessorHandler;
 import com.seibel.lod.core.wrapperInterfaces.modAccessor.IStarlightAccessor;
 
 import net.minecraft.world.level.BlockGetter;
@@ -14,7 +14,7 @@ public class LightGetterAdaptor implements LightChunkGetter {
 
 	public LightGetterAdaptor(BlockGetter heightAccessor) {
 		this.heightGetter = heightAccessor;
-		shouldReturnNull = ModAccessorApi.get(IStarlightAccessor.class) != null;
+		shouldReturnNull = ModAccessorHandler.get(IStarlightAccessor.class) != null;
 	}
 
 	public void setRegion(LightedWorldGenRegion region) {

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/mimicObject/LightedWorldGenRegion.java

@@ -3,6 +3,7 @@ package com.seibel.lod.common.wrappers.worldGeneration.mimicObject;
 import java.util.List;
 import java.util.stream.Stream;
 
+import com.seibel.lod.core.api.ApiShared;
 import org.jetbrains.annotations.Nullable;
 
 import com.seibel.lod.common.wrappers.worldGeneration.BatchGenerationEnvironment.EmptyChunkGenerator;
@@ -173,7 +174,7 @@ public class LightedWorldGenRegion extends WorldGenRegion {
 			}
 		}
 		if (chunkStatus != ChunkStatus.EMPTY && chunkStatus != debugTriggeredForStatus) {
-			ClientApi.LOGGER.info("WorldGen requiring " + chunkStatus
+			ApiShared.LOGGER.info("WorldGen requiring " + chunkStatus
 					+ " outside expected range detected. Force passing EMPTY chunk and seeing if it works.");
 			debugTriggeredForStatus = chunkStatus;
 		}

common/src/main/java/com/seibel/lod/common/wrappers/worldGeneration/step/StepFeatures.java

@@ -1,6 +1,7 @@
 package com.seibel.lod.common.wrappers.worldGeneration.step;
 
 import java.util.ArrayList;
+import java.util.EnumSet;
 
 import com.seibel.lod.common.wrappers.worldGeneration.ThreadedParameters;
 import com.seibel.lod.common.wrappers.worldGeneration.mimicObject.LightedWorldGenRegion;
@@ -11,6 +12,7 @@ import net.minecraft.ReportedException;
 import net.minecraft.world.level.chunk.ChunkAccess;
 import net.minecraft.world.level.chunk.ChunkStatus;
 import net.minecraft.world.level.chunk.ProtoChunk;
+import net.minecraft.world.level.levelgen.Heightmap;
 
 public final class StepFeatures {
 	/**
@@ -40,6 +42,7 @@ public final class StepFeatures {
 		for (ChunkAccess chunk : chunksToDo) {
 			try {
 				worldGenRegion.setOverrideCenter(chunk.getPos());
+				Heightmap.primeHeightmaps(chunk, STATUS.heightmapsAfter());
 				envionment.params.generator.applyBiomeDecoration(worldGenRegion, tParams.structFeat);
 			} catch (ReportedException e) {
 				e.printStackTrace();

fabric/build.gradle

@@ -25,6 +25,12 @@ repositories {
     maven { url "https://maven.terraformersmc.com/" }
 }
 
+def addMod(path, enabled) {
+    if (enabled == "2")
+        dependencies { modImplementation(path) }
+    else if (enabled == "1")
+        dependencies { modCompileOnly(path) }
+}
 
 dependencies {
     // Fabric loader
@@ -39,14 +45,14 @@ dependencies {
     }
 
     // Sodium
-    modImplementation "curse.maven:sodium-394468:${rootProject.sodium_version}"
+    addMod("curse.maven:sodium-394468:${rootProject.sodium_version}", rootProject.enable_sodium)
     implementation "org.joml:joml:1.10.2"
 
     // Lithium
-//    modImplementation "maven.modrinth:lithium:${rootProject.lithium_version}"
+    addMod("maven.modrinth:lithium:${rootProject.lithium_version}", rootProject.enable_lithium)
 
     // Iris
-//    modImplementation "maven.modrinth:iris:${rootProject.iris_version}"
+    addMod("maven.modrinth:iris:${rootProject.iris_version}", rootProject.enable_iris)
 
 
 
@@ -90,36 +96,8 @@ runClient {
     finalizedBy(deleteResources)
 }
 
-// Put stuff from gradle.properties into the mod info stuff
-def resourceTargets = ["fabric.mod.json"]
-def intoTargets = ["$buildDir/resources/main/"]
-def replaceProperties = [
-        version: mod_version,
-        mod_name: mod_name,
-        authors: mod_authors,
-        description: mod_description
-]
-
 processResources {
     dependsOn(copyAccessWidener)
-    
-    inputs.properties replaceProperties
-    replaceProperties.put 'project', project
-    filesMatching(resourceTargets) {
-        expand replaceProperties
-    }
-
-    intoTargets.each { target ->
-        if (file(target).exists()) {
-            copy {
-                from(sourceSets.main.resources) {
-                    include resourceTargets
-                    expand replaceProperties
-                }
-                into target
-            }
-        }
-    }
 }
 
 shadowJar {

fabric/src/main/java/com/seibel/lod/fabric/ClientProxy.java

@@ -26,7 +26,7 @@ import com.seibel.lod.common.wrappers.chunk.ChunkWrapper;
 import com.seibel.lod.common.wrappers.world.DimensionTypeWrapper;
 import com.seibel.lod.common.wrappers.world.WorldWrapper;
 
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
 import com.seibel.lod.fabric.mixins.events.MixinClientLevel;

fabric/src/main/java/com/seibel/lod/fabric/FabricMain.java

@@ -21,16 +21,18 @@ package com.seibel.lod.fabric;
 
 import com.seibel.lod.common.LodCommonMain;
 import com.seibel.lod.core.ModInfo;
+import com.seibel.lod.core.api.ApiShared;
 import com.seibel.lod.core.api.ClientApi;
-import com.seibel.lod.core.api.ModAccessorApi;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.DependencyHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.ModAccessorHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.modAccessor.IModChecker;
 import com.seibel.lod.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
 import com.seibel.lod.core.wrapperInterfaces.modAccessor.ISodiumAccessor;
 import com.seibel.lod.fabric.wrappers.modAccessor.ModChecker;
 import com.seibel.lod.fabric.wrappers.modAccessor.OptifineAccessor;
 import com.seibel.lod.fabric.wrappers.modAccessor.SodiumAccessor;
-import com.seibel.lod.fabric.wrappers.DependencySetup;
+import com.seibel.lod.fabric.wrappers.FabricDependencySetup;
 
 import net.fabricmc.api.ClientModInitializer;
 
@@ -43,7 +45,7 @@ import net.fabricmc.api.ClientModInitializer;
  * @author Ran
  * @version 12-1-2021
  */
-public class Main implements ClientModInitializer
+public class FabricMain implements ClientModInitializer
 {
 	// This is a client mod so it should implement ClientModInitializer and in fabric.mod.json it should have "environment": "client"
 	// Once it works on servers change the implement to ModInitializer and in fabric.mod.json it should be "environment": "*"
@@ -62,25 +64,37 @@ public class Main implements ClientModInitializer
 	public static void init() {
 		LodCommonMain.initConfig();
 		LodCommonMain.startup(null, false);
-		DependencySetup.createInitialBindings();
-		SingletonHandler.bind(IModChecker.class, ModChecker.INSTANCE);
-		ClientApi.LOGGER.info(ModInfo.READABLE_NAME + ", Version: " + ModInfo.VERSION);
-
+		
+		ApiShared.LOGGER.info(ModInfo.READABLE_NAME + ", Version: " + ModInfo.VERSION);
+		
+		
+		// make sure the dependencies are set up before the mod needs them
+		FabricDependencySetup.createInitialBindings();
+		FabricDependencySetup.finishBinding();
+		
+		// mod dependencies
+		if (SingletonHandler.get(IModChecker.class).isModLoaded("sodium")) {
+			ModAccessorHandler.bind(ISodiumAccessor.class, new SodiumAccessor());
+		}
+		if (SingletonHandler.get(IModChecker.class).isModLoaded("optifine")) {
+			ModAccessorHandler.bind(IOptifineAccessor.class, new OptifineAccessor());
+		}
+		
+		ModAccessorHandler.finishBinding();
+		
+		
 		// Check if this works
 		client_proxy = new ClientProxy();
 		client_proxy.registerEvents();
-		if (SingletonHandler.get(IModChecker.class).isModLoaded("sodium")) {
-			ModAccessorApi.bind(ISodiumAccessor.class, new SodiumAccessor());
-		}
-		if (SingletonHandler.get(IModChecker.class).isModLoaded("optifine")) {
-			ModAccessorApi.bind(IOptifineAccessor.class, new OptifineAccessor());
-		}
 	}
 
 	public static void initServer() {
 		LodCommonMain.initConfig();
 		LodCommonMain.startup(null, true);
-		DependencySetup.createInitialBindings();
-		ClientApi.LOGGER.info(ModInfo.READABLE_NAME + ", Version: " + ModInfo.VERSION);
+		
+		ApiShared.LOGGER.info(ModInfo.READABLE_NAME + ", Version: " + ModInfo.VERSION);
+		
+		FabricDependencySetup.createInitialBindings();
+		FabricDependencySetup.finishBinding();
 	}
 }

fabric/src/main/java/com/seibel/lod/fabric/mixins/MixinFogRenderer.java

@@ -7,7 +7,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 import com.mojang.blaze3d.systems.RenderSystem;
 import com.seibel.lod.core.api.ClientApi;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
 
 import net.minecraft.client.Camera;
@@ -18,6 +18,7 @@ import net.minecraft.world.effect.MobEffects;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.level.material.FogType;
 
 @Mixin(FogRenderer.class)
 public class MixinFogRenderer {
@@ -29,16 +30,17 @@ public class MixinFogRenderer {
 	
 	@Inject(at = @At("RETURN"), method = "setupFog(Lnet/minecraft/client/Camera;Lnet/minecraft/client/renderer/FogRenderer$FogMode;FZ)V")
 	private static final void disableSetupFog(Camera camera, FogMode fogMode, float f, boolean bl, CallbackInfo callback) {
-		FluidState fluidState = camera.getFluidInCamera();
+		FogType fogType = camera.getFluidInCamera();
 	    Entity entity = camera.getEntity();
-	    boolean isUnderWater = (entity instanceof LivingEntity) && ((LivingEntity)entity).hasEffect(MobEffects.BLINDNESS);
-	    isUnderWater |= fluidState.is(FluidTags.WATER);
-	    isUnderWater |= fluidState.is(FluidTags.LAVA);
+	    boolean enableFog = (entity instanceof LivingEntity) && ((LivingEntity)entity).hasEffect(MobEffects.BLINDNESS);
+	    enableFog |= fogType.equals(FogType.WATER);
+	    enableFog |= fogType.equals(FogType.LAVA);
+	    enableFog |= fogType.equals(FogType.POWDER_SNOW);
 	    
-	    if (!isUnderWater) {
+	    if (!enableFog) {
 			if (fogMode == FogMode.FOG_TERRAIN && CONFIG.client().graphics().fogQuality().getDisableVanillaFog()) {
-			    RenderSystem.fogStart(A_REALLY_REALLY_BIG_VALUE);
-			    RenderSystem.fogEnd(A_EVEN_LARGER_VALUE);
+			    RenderSystem.setShaderFogStart(A_REALLY_REALLY_BIG_VALUE);
+			    RenderSystem.setShaderFogEnd(A_EVEN_LARGER_VALUE);
 			}
 	    }
 	}

fabric/src/main/java/com/seibel/lod/fabric/mixins/MixinMinecraft.java

@@ -1,6 +1,6 @@
 package com.seibel.lod.fabric.mixins;
 
-import com.seibel.lod.fabric.Main;
+import com.seibel.lod.fabric.FabricMain;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.main.GameConfig;
 import org.spongepowered.asm.mixin.Mixin;
@@ -16,6 +16,6 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 public class MixinMinecraft {
     @Inject(method = "<init>", at = @At("TAIL"))
     private void startMod(GameConfig gameConfig, CallbackInfo ci) {
-        Main.init();
+        FabricMain.init();
     }
 }

fabric/src/main/java/com/seibel/lod/fabric/mixins/MixinOptionsScreen.java

@@ -3,7 +3,7 @@ package com.seibel.lod.fabric.mixins;
 import com.seibel.lod.common.wrappers.config.ConfigGui;
 import com.seibel.lod.common.wrappers.config.TexturedButtonWidget;
 import com.seibel.lod.core.ModInfo;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
 import net.minecraft.client.gui.screens.OptionsScreen;
 import net.minecraft.client.gui.screens.Screen;

fabric/src/main/java/com/seibel/lod/fabric/mixins/events/MixinBlockUpdate.java

@@ -1,6 +1,6 @@
 package com.seibel.lod.fabric.mixins.events;
 
-import com.seibel.lod.fabric.Main;
+import com.seibel.lod.fabric.FabricMain;
 import net.minecraft.client.Minecraft;
 import net.minecraft.core.BlockPos;
 import net.minecraft.network.protocol.game.ClientGamePacketListener;
@@ -23,6 +23,6 @@ public abstract class MixinBlockUpdate {
 
     @Inject(method = "handle(Lnet/minecraft/network/protocol/game/ClientGamePacketListener;)V", at = @At("TAIL"))
     private void onBlockUpdate(ClientGamePacketListener clientGamePacketListener, CallbackInfo ci) {
-        Main.client_proxy.blockChangeEvent(Minecraft.getInstance().player.clientLevel, this.getPos());
+        FabricMain.client_proxy.blockChangeEvent(Minecraft.getInstance().player.clientLevel, this.getPos());
     }
 }

fabric/src/main/java/com/seibel/lod/fabric/mixins/events/MixinClientLevel.java

@@ -1,6 +1,6 @@
 package com.seibel.lod.fabric.mixins.events;
 
-import com.seibel.lod.fabric.Main;
+import com.seibel.lod.fabric.FabricMain;
 import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.multiplayer.ClientPacketListener;
 import net.minecraft.client.renderer.LevelRenderer;
@@ -23,6 +23,6 @@ import java.util.function.Supplier;
 public class MixinClientLevel {
     @Inject(method = "<init>", at = @At("TAIL"))
     private void loadWorldEvent(ClientPacketListener clientPacketListener, ClientLevel.ClientLevelData clientLevelData, ResourceKey<Level> resourceKey, DimensionType dimensionType, int i, Supplier<ProfilerFiller> supplier, LevelRenderer levelRenderer, boolean bl, long l, CallbackInfo ci) {
-        Main.client_proxy.worldLoadEvent((ClientLevel) (Object) this);
+        FabricMain.client_proxy.worldLoadEvent((ClientLevel) (Object) this);
     }
 }

fabric/src/main/java/com/seibel/lod/fabric/mixins/events/MixinMinecraft.java

@@ -1,6 +1,6 @@
 package com.seibel.lod.fabric.mixins.events;
 
-import com.seibel.lod.fabric.Main;
+import com.seibel.lod.fabric.FabricMain;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.screens.Screen;
 import net.minecraft.client.multiplayer.ClientLevel;
@@ -23,11 +23,11 @@ public class MixinMinecraft {
 
     @Inject(method = "setLevel", at = @At("HEAD"))
     private void unloadWorldEvent_sL(ClientLevel clientLevel, CallbackInfo ci) {
-        if (level != null) Main.client_proxy.worldUnloadEvent(level);
+        if (level != null) FabricMain.client_proxy.worldUnloadEvent(level);
     }
 
     @Inject(method = "clearLevel(Lnet/minecraft/client/gui/screens/Screen;)V", at = @At("HEAD"))
     private void unloadWorldEvent_cL(Screen screen, CallbackInfo ci) {
-        if (this.level != null) Main.client_proxy.worldUnloadEvent(this.level);
+        if (this.level != null) FabricMain.client_proxy.worldUnloadEvent(this.level);
     }
 }

fabric/src/main/java/com/seibel/lod/fabric/mixins/events/MixinServerLevel.java

@@ -1,6 +1,6 @@
 package com.seibel.lod.fabric.mixins.events;
 
-import com.seibel.lod.fabric.Main;
+import com.seibel.lod.fabric.FabricMain;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.util.ProgressListener;
 import org.spongepowered.asm.mixin.Mixin;
@@ -16,6 +16,6 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 public class MixinServerLevel {
     @Inject(method = "save", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerChunkCache;save(Z)V", shift = At.Shift.AFTER))
     private void saveWorldEvent(ProgressListener progressListener, boolean bl, boolean bl2, CallbackInfo ci) {
-        Main.client_proxy.worldSaveEvent();
+        FabricMain.client_proxy.worldSaveEvent();
     }
 }

fabric/src/main/java/com/seibel/lod/fabric/wrappers/FabricDependencySetup.java

@@ -1,7 +1,10 @@
 package com.seibel.lod.fabric.wrappers;
 
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.DependencyHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IModChecker;
+import com.seibel.lod.fabric.wrappers.modAccessor.ModChecker;
 import com.seibel.lod.common.wrappers.config.LodConfigWrapperSingleton;
 
 /**
@@ -14,10 +17,16 @@ import com.seibel.lod.common.wrappers.config.LodConfigWrapperSingleton;
  * @author Ran
  * @version 12-1-2021
  */
-public class DependencySetup
+public class FabricDependencySetup
 {
 	public static void createInitialBindings()
 	{
 		SingletonHandler.bind(ILodConfigWrapperSingleton.class, LodConfigWrapperSingleton.INSTANCE);;
+		SingletonHandler.bind(IModChecker.class, ModChecker.INSTANCE);
+	}
+
+	public static void finishBinding()
+	{
+		SingletonHandler.finishBinding();
 	}
 }

fabric/src/main/java/com/seibel/lod/fabric/wrappers/modAccessor/SodiumAccessor.java

@@ -4,7 +4,7 @@ import java.util.HashSet;
 import java.util.stream.Collectors;
 
 import com.seibel.lod.core.api.ClientApi;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.chunk.AbstractChunkPosWrapper;
 import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
 import com.seibel.lod.core.wrapperInterfaces.modAccessor.ISodiumAccessor;

fabric/src/main/resources/fabric.mod.json

@@ -8,9 +8,9 @@
   "authors": ["${authors}"],
 
   "contact": {
-    "homepage": "https://www.curseforge.com/minecraft/mc-mods/lod-level-of-detail",
-    "sources": "https://gitlab.com/jeseibel/minecraft-lod-mod/",
-    "issues": "https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues"
+    "homepage": "${homepage}",
+    "sources": "${source}",
+    "issues": "${issues}"
   },
 
   "license": "CC0-1.0",
@@ -34,7 +34,7 @@
   "depends": {
     "fabricloader": "*",
     "fabric": "*",
-    "minecraft": "1.16.5",
+    "minecraft": ["1.16.5", "1.16.4", "1.16.3", "1.16.2"],
     "java": ">=8"
   },
   "suggests": {

forge/build.gradle

@@ -25,10 +25,19 @@ configurations {
     developmentForge.extendsFrom common
 }
 
+def addMod(path, enabled) {
+    if (enabled == "2")
+        dependencies { modImplementation(path) }
+    else if (enabled == "1")
+        dependencies { modCompileOnly(path) }
+}
+
 dependencies {
     // Forge loader
     forge "net.minecraftforge:forge:${rootProject.minecraft_version}-${rootProject.forge_version}"
 
+    addMod("curse.maven:TerraForged-363820:${rootProject.terraforged_version}", rootProject.enable_terraforged)
+    
     common(project(path: ":common", configuration: "namedElements")) { transitive false }
     shadowMe(project(path: ":common", configuration: "transformProductionForge")) { transitive = false }
 
@@ -54,37 +63,9 @@ task copyCommonResources(type: Copy) {
     into file("build/resources/main")
 }
 
-// Put stuff from gradle.properties into the mod info stuff
-def resourceTargets = ["META-INF/mods.toml"]
-def intoTargets = ["$buildDir/resources/main/"]
-def replaceProperties = [
-        version: mod_version,
-        mod_name: mod_name,
-        authors: mod_authors,
-        description: mod_description
-]
-
 processResources {
     dependsOn(copyCoreResources)
     dependsOn(copyCommonResources)
-    
-    inputs.properties replaceProperties
-    replaceProperties.put 'project', project
-    filesMatching(resourceTargets) {
-        expand replaceProperties
-    }
-
-    intoTargets.each { target ->
-        if (file(target).exists()) {
-            copy {
-                from(sourceSets.main.resources) {
-                    include resourceTargets
-                    expand replaceProperties
-                }
-                into target
-            }
-        }
-    }
 }
 
 shadowJar {

forge/src/main/java/com/seibel/lod/forge/ForgeMain.java

@@ -22,12 +22,13 @@ package com.seibel.lod.forge;
 import com.seibel.lod.common.LodCommonMain;
 import com.seibel.lod.common.forge.LodForgeMethodCaller;
 import com.seibel.lod.common.wrappers.config.ConfigGui;
-import com.seibel.lod.common.wrappers.minecraft.MinecraftWrapper;
+import com.seibel.lod.common.wrappers.minecraft.MinecraftClientWrapper;
 import com.seibel.lod.core.ModInfo;
+import com.seibel.lod.core.api.ApiShared;
 import com.seibel.lod.core.api.ClientApi;
-import com.seibel.lod.core.api.ModAccessorApi;
+import com.seibel.lod.core.handlers.dependencyInjection.ModAccessorHandler;
 import com.seibel.lod.core.handlers.ReflectionHandler;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.modAccessor.IModChecker;
 import com.seibel.lod.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
 import com.seibel.lod.forge.wrappers.ForgeDependencySetup;
@@ -66,16 +67,21 @@ public class ForgeMain implements LodForgeMethodCaller
 
 	private void init(final FMLCommonSetupEvent event)
 	{
-		// make sure the dependencies are set up before the mod needs them
+		ApiShared.LOGGER.info("Distant Horizons initializing...");
+		
 		LodCommonMain.initConfig();
 		LodCommonMain.startup(this, !FMLLoader.getDist().isClient());
+		
+		// make sure the dependencies are set up before the mod needs them
 		ForgeDependencySetup.createInitialBindings();
-		ClientApi.LOGGER.info("Distant Horizons initializing...");
-
-		SingletonHandler.bind(IModChecker.class, ModChecker.INSTANCE);
+		ForgeDependencySetup.finishBinding();
+		
+		// mod dependencies
 		if (ReflectionHandler.instance.optifinePresent()) {
-			ModAccessorApi.bind(IOptifineAccessor.class, new OptifineAccessor());
+			ModAccessorHandler.bind(IOptifineAccessor.class, new OptifineAccessor());
 		}
+		
+		ModAccessorHandler.finishBinding();
 	}
 
 
@@ -99,7 +105,7 @@ public class ForgeMain implements LodForgeMethodCaller
 
 	private ModelDataMap dataMap = new ModelDataMap.Builder().build();
 	@Override
-	public List<BakedQuad> getQuads(MinecraftWrapper mc, Block block, BlockState blockState, Direction direction, Random random) {
+	public List<BakedQuad> getQuads(MinecraftClientWrapper mc, Block block, BlockState blockState, Direction direction, Random random) {
 		return mc.getModelManager().getBlockModelShaper().getBlockModel(block.defaultBlockState()).getQuads(blockState, direction, random, dataMap);
 	}
 }

forge/src/main/java/com/seibel/lod/forge/mixins/MixinFogRenderer.java

@@ -5,20 +5,18 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-import com.mojang.blaze3d.platform.GlStateManager;
 import com.mojang.blaze3d.systems.RenderSystem;
-import com.seibel.lod.core.api.ClientApi;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.api.ApiShared;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
 
 import net.minecraft.client.Camera;
 import net.minecraft.client.renderer.FogRenderer;
 import net.minecraft.client.renderer.FogRenderer.FogMode;
-import net.minecraft.tags.FluidTags;
 import net.minecraft.world.effect.MobEffects;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.level.material.FogType;
 
 @Mixin(FogRenderer.class)
 public class MixinFogRenderer {
@@ -36,17 +34,17 @@ public class MixinFogRenderer {
 	    } catch (NullPointerException e) {
 	    	return; // Can happen due to forge calling this before setting up the mod
 	    }
-	    ClientApi.LOGGER.debug("LOD: MixinSetupFog called!");
-		FluidState fluidState = camera.getFluidInCamera();
+	    ApiShared.LOGGER.debug("LOD: MixinSetupFog called!");
+		FogType fogType = camera.getFluidInCamera();
 	    Entity entity = camera.getEntity();
 	    boolean isUnderWater = (entity instanceof LivingEntity) && ((LivingEntity)entity).hasEffect(MobEffects.BLINDNESS);
-	    isUnderWater |= fluidState.is(FluidTags.WATER);
-	    isUnderWater |= fluidState.is(FluidTags.LAVA);
+	    isUnderWater |= fogType.equals(FogType.WATER);
+	    isUnderWater |= fogType.equals(FogType.LAVA);
 	    
 	    if (!isUnderWater) {
 			if (fogMode == FogMode.FOG_TERRAIN && CONFIG.client().graphics().fogQuality().getDisableVanillaFog()) {
-			    RenderSystem.fogStart(A_REALLY_REALLY_BIG_VALUE);
-			    RenderSystem.fogEnd(A_EVEN_LARGER_VALUE);
+			    RenderSystem.setShaderFogStart(A_REALLY_REALLY_BIG_VALUE);
+			    RenderSystem.setShaderFogEnd(A_EVEN_LARGER_VALUE);
 			}
 	    }
 	}

forge/src/main/java/com/seibel/lod/forge/mixins/MixinOptionsScreen.java

@@ -3,7 +3,7 @@ package com.seibel.lod.forge.mixins;
 import com.seibel.lod.common.wrappers.config.ConfigGui;
 import com.seibel.lod.common.wrappers.config.TexturedButtonWidget;
 import com.seibel.lod.core.ModInfo;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
 import net.minecraft.client.gui.screens.OptionsScreen;
 import net.minecraft.client.gui.screens.Screen;

forge/src/main/java/com/seibel/lod/forge/mixins/MixinTFChunkGenerator.java

@@ -0,0 +1,49 @@
+package com.seibel.lod.forge.mixins;
+
+import java.util.Random;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+//import com.seibel.lod.core.api.ClientApi;
+import com.terraforged.mod.chunk.generator.FeatureGenerator;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.feature.ConfiguredFeature;
+
+@Mixin(FeatureGenerator.class)
+public class MixinTFChunkGenerator {
+
+	@Redirect(method = "decorate("
+			+ "Lnet/minecraft/world/level/StructureFeatureManager;"
+			+ "Lnet/minecraft/world/level/WorldGenLevel;"
+			+ "Lnet/minecraft/world/level/chunk/ChunkAccess;"
+			+ "Lnet/minecraft/world/level/biome/Biome;"
+			+ "Lnet/minecraft/core/BlockPos;"
+			+ "Lcom/terraforged/mod/profiler/watchdog/WatchdogContext;)V",
+		at = @At(
+			value = "INVOKE",
+			target = "Lnet/minecraft/world/level/levelgen/feature/ConfiguredFeature;place("
+					+ "Lnet/minecraft/world/level/WorldGenLevel;"
+					+ "Lnet/minecraft/world/level/chunk/ChunkGenerator;"
+					+ "Ljava/util/Random;Lnet/minecraft/core/BlockPos;)Z"
+		))
+	private boolean wrapDecorate$FeaturePlace(ConfiguredFeature<?, ?> feature, WorldGenLevel arg,
+			ChunkGenerator arg2, Random random, BlockPos arg3) {
+		synchronized((FeatureGenerator)(Object)this) {
+			//ClientApi.LOGGER.info("wrapDecorate FeaturePlace triggered");
+			return feature.place(arg, arg2, random, arg3);
+		}
+	}
+	
+	//METHOD: com.terraforged.mod.chunk.generator.FeatureGenerator.decorate(StructureFeatureManager manager,
+	// WorldGenLevel region, ChunkAccess chunk, Biome biome, BlockPos pos, WatchdogContext context)
+	
+	//TARGET: boolean net.minecraft.world.level.levelgen.feature.ConfiguredFeature.place
+	// (WorldGenLevel arg, ChunkGenerator arg2, Random random, BlockPos arg3)
+}
+
+

forge/src/main/java/com/seibel/lod/forge/wrappers/ForgeDependencySetup.java

@@ -1,8 +1,10 @@
 package com.seibel.lod.forge.wrappers;
 
 import com.seibel.lod.common.wrappers.config.LodConfigWrapperSingleton;
-import com.seibel.lod.core.util.SingletonHandler;
+import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler;
 import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
+import com.seibel.lod.core.wrapperInterfaces.modAccessor.IModChecker;
+import com.seibel.lod.forge.wrappers.modAccessor.ModChecker;
 
 /**
  * Binds all necessary dependencies so we
@@ -12,12 +14,18 @@ import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
  * 
  * @author James Seibel
  * @author Ran
- * @version 12-1-2021
+ * @version 3-5-2022
  */
 public class ForgeDependencySetup
 {
 	public static void createInitialBindings()
 	{
 		SingletonHandler.bind(ILodConfigWrapperSingleton.class, LodConfigWrapperSingleton.INSTANCE);
+		SingletonHandler.bind(IModChecker.class, ModChecker.INSTANCE);
+	}
+	
+	public static void finishBinding()
+	{
+		SingletonHandler.finishBinding();
 	}
 }

forge/src/main/resources/META-INF/mods.toml

@@ -2,7 +2,7 @@
 modLoader="javafml" #//mandatory
 loaderVersion="[36,)" # // mandatory. This is typically bumped every Minecraft version by Forge. See our download page for lists of versions.
 license="GNU GPLv3"
-issueTrackerURL="https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues"
+issueTrackerURL="${issues}"
 
 
 [[mods]] #//mandatory
@@ -10,7 +10,7 @@ issueTrackerURL="https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues"
 	version= "${version}" #//mandatory, gets the version number from jar populated by the build.gradle script
 	displayName="${mod_name}" #//mandatory
 	#//updateJSONURL="https://change.me.example.invalid/updates.json" # A URL to query for updates for this mod. See the JSON update specification https://mcforge.readthedocs.io/en/latest/gettingstarted/autoupdate/
-	displayURL="https://www.curseforge.com/minecraft/mc-mods/lod-level-of-detail"
+	displayURL="${homepage}"
 	logoFile="logo.png"
 	catalogueImageIcon="icon.png"
 	credits="Massive thanks to: Leonardo, Cola, Ran, and CoolGi. For their hard work to bring Distant Horizons to where it is today. - James"

forge/src/main/resources/lod.mixins.json

@@ -4,7 +4,8 @@
 	"package": "com.seibel.lod.forge.mixins",
 	"compatibilityLevel": "JAVA_8",
 	"mixins": [
-		"MixinChunkGenerator"
+		"MixinChunkGenerator",
+		"MixinTFChunkGenerator"
 	],
 	"client": [
 		"MixinOptionsScreen",

gradle.properties

@@ -3,7 +3,7 @@ org.gradle.jvmargs=-Xmx2048M
 minecraft_version=1.16.5
 
 archives_base_name=DistantHorizons
-mod_version=1.6.0a
+mod_version=1.6.2a
 maven_group=com.seibel.lod
 toml_version=3.6.4
 
@@ -12,17 +12,35 @@ mod_name=Distant Horizons
 mod_description=This mod generates and renders simplified terrain beyond the normal view distance at a low performance cost. Allowing you to see much farther without turning your game into a slideshow.
 mod_authors=James Seibel, Leonardo Amato, Cola, coolGi2007, Ran, Leetom
 mod_homepage=https://www.curseforge.com/minecraft/mc-mods/distant-horizons
+mod_source=https://gitlab.com/jeseibel/minecraft-lod-mod/
+mod_issues=https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues
+
 
 # Fabric loader
-fabric_loader_version=0.12.3
-fabric_api_version=0.34.2+1.16
-    # Fabric mods
+fabric_loader_version=0.13.2
+fabric_api_version=0.42.0+1.16
+    # Fabric mod versions
     modmenu_version=1.16.22
     lithium_version=mc1.16.5-0.6.6
     sodium_version=3488820
     iris_version=1.16.x-v1.1.4
 
+    # Fabric mod run
+    # 0 = Dont enable and dont run
+    # 1 = Can be refranced in code but dosnt run
+    # 2 = Can be refranced in code and runs in client
+    enable_lithium=0
+    enable_sodium=1
+    enable_iris=0
+
+
 # Forge loader
-forge_version=36.2.23
-    # Forge mods
-    ## currentlly no mods ##
+forge_version=36.2.28
+    # Forge mod versions
+	terraforged_version=3285909
+
+    # Forge mod run
+    # 0 = Dont enable and dont run
+    # 1 = Can be refranced in code but dosnt run
+    # 2 = Can be refranced in code and runs in client
+	enable_terraforged=1