Port to 1.16.5

Kottle -> KotlinForForge

.gitignore

@@ -7,3 +7,4 @@ run/
 build/
 classes/
 temp/
+logs

build.gradle

@@ -1,62 +0,0 @@
-apply plugin: "net.minecraftforge.gradle.forge"
-apply plugin: 'kotlin'
-
-archivesBaseName = jarName
-
-buildscript {
-    repositories {
-        mavenCentral()
-        maven {
-            name = "forge"
-            url = "http://files.minecraftforge.net/maven"
-        }
-    }
-    dependencies {
-        classpath "net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT"
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-repositories {
-    mavenCentral()
-    jcenter()
-    maven {
-        name = "shadowfacts"
-        url = "https://maven.shadowfacts.net/"
-    }
-}
-
-dependencies {
-    compile "net.shadowfacts:Forgelin:$forgelin_version"
-}
-
-minecraft {
-    version = mc_version + "-" + forge_version
-    mappings = mcp_mappings
-    runDir = 'run'
-}
-processResources {
-    from(sourceSets.main.resources) { exclude 'mcmod.info' }
-    from(sourceSets.main.resources) { include 'mcmod.info' expand 'version':version, 'mcversion':minecraft.version }
-
-    into "${buildDir}/classes/main"
-}
-
-def manifestCfg = {
-    attributes "FMLCorePlugin": "mods.betterfoliage.loader.BetterFoliageLoader"
-    attributes "FMLCorePluginContainsFMLMod": "mods.betterfoliage.BetterFoliageMod"
-    attributes "FMLAT": "BetterFoliage_at.cfg"
-}
-
-jar {
-    manifest manifestCfg
-    exclude "optifine"
-}
-
-task sourcesJar(type: Jar, dependsOn: classes) {
-    classifier = 'sources'
-    manifest manifestCfg
-    from(sourceSets.main.kotlin)
-    from(sourceSets.main.resources) { exclude 'mcmod.info' }
-    from(sourceSets.main.resources) { include 'mcmod.info' expand 'version':version, 'mcversion':minecraft.version }
-}

build.gradle.kts

@@ -0,0 +1,69 @@
+plugins {
+    kotlin("jvm").version("1.4.20")
+    id("net.minecraftforge.gradle").version("4.1.12")
+    id("org.spongepowered.mixin").version("0.7-SNAPSHOT")
+}
+//apply(plugin = "org.spongepowered.mixin")
+
+repositories {
+    maven("https://files.minecraftforge.net/maven")
+    maven("https://repo.spongepowered.org/maven")
+    maven("https://minecraft.curseforge.com/api/maven")
+    maven("https://maven.shedaniel.me/")
+    maven("https://www.cursemaven.com")
+    maven("https://thedarkcolour.github.io/KotlinForForge/")
+}
+
+dependencies {
+    "minecraft"("net.minecraftforge:forge:${properties["mcVersion"]}-${properties["forgeVersion"]}")
+
+//    "api"(fg.deobf("curse.maven:clothconfig-348521:2938583"))
+
+//    "implementation"(fg.deobf("curse.maven:biomesoplenty-220318:2988999"))
+    "implementation"("thedarkcolour:kotlinforforge:1.7.0")
+
+    "implementation"("org.spongepowered:mixin:0.8-SNAPSHOT")
+}
+
+configurations["annotationProcessor"].extendsFrom(configurations["implementation"])
+sourceSets {
+    get("main").ext["refMap"] = "betterfoliage.refmap.json"
+}
+
+minecraft {
+    mappings(properties["mappingsChannel"] as String, properties["mappingsVersion"] as String)
+    accessTransformer(file("src/main/resources/META-INF/accesstransformer.cfg"))
+
+    runs.create("client") {
+        workingDirectory(file("run"))
+        properties["forge.logging.markers"] = "CORE"
+        properties["forge.logging.console.level"] = "debug"
+        mods.create("betterfoliage") {
+            source(sourceSets["main"])
+        }
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+kotlin {
+    target.compilations.configureEach {
+        kotlinOptions.jvmTarget = "1.8"
+        kotlinOptions.freeCompilerArgs += listOf("-Xno-param-assertions", "-Xno-call-assertions")
+
+    }
+}
+
+tasks.getByName<Jar>("jar") {
+    archiveName = "BetterFoliage-${project.version}-Forge-${properties["mcVersion"]}.jar"
+    manifest {
+        from(file("src/main/resources/META-INF/MANIFEST.MF"))
+        attributes["Implementation-Version"] = project.version
+    }
+    exclude("net")
+    filesMatching("META-INF/mods.toml") { expand(project.properties) }
+    filesMatching("mcmod.info") { expand(project.properties) }
+}

gradle.properties

@@ -1,11 +1,14 @@
+org.gradle.jvmargs=-Xmx2G
+org.gradle.daemon=false
+
 group = com.github.octarine-noise
-jarName = BetterFoliage-MC1.12
+jarName = BetterFoliage-Forge
 
-version = 2.3.1
+version = 2.6.1
 
-mc_version = 1.12.2
+mcVersion = 1.16.5
-forge_version = 14.23.5.2847
+forgeVersion = 36.1.17
-mcp_mappings = stable_39
+mappingsChannel = official
+mappingsVersion = 1.16.5
 
-kotlin_version = 1.3.40
+#kottleVersion = 1.4.0
-forgelin_version = 1.8.4

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.9-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,5 +1,21 @@
 #!/usr/bin/env sh
 
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
 ##############################################################################
 ##
 ##  Gradle start up script for UN*X
@@ -28,7 +44,7 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
@@ -66,6 +82,7 @@ esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
@@ -109,10 +126,11 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin, switch paths to Windows format before running java
+# For Cygwin or MSYS, switch paths to Windows format before running java
-if $cygwin ; then
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
     JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
@@ -138,19 +156,19 @@ if $cygwin ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=$((i+1))
+        i=`expr $i + 1`
     done
     case $i in
-        (0) set -- ;;
+        0) set -- ;;
-        (1) set -- "$args0" ;;
+        1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
+        2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
@@ -159,14 +177,9 @@ save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }
-APP_ARGS=$(save "$@")
+APP_ARGS=`save "$@"`
 
 # Collect all arguments for the java command, following the shell quoting and substitution rules
 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,3 +1,19 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -13,15 +29,18 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -35,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -45,28 +64,14 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

settings.gradle

@@ -1,2 +0,0 @@
-rootProject.name = 'BetterFoliage'
-

settings.gradle.kts

@@ -0,0 +1,13 @@
+pluginManagement {
+    repositories {
+        maven("https://files.minecraftforge.net/maven")
+        maven("https://repo.spongepowered.org/maven")
+        gradlePluginPortal()
+    }
+    resolutionStrategy {
+        eachPlugin {
+            if (requested.id.let { it.namespace == "net.minecraftforge" && it.name == "gradle"} ) useModule("net.minecraftforge.gradle:ForgeGradle:${requested.version}")
+            if (requested.id.let { it.namespace == "org.spongepowered" && it.name == "mixin"} ) useModule("org.spongepowered:mixingradle:${requested.version}")
+        }
+    }
+}

src/main/java/mods/betterfoliage/MixinConnector.java

@@ -0,0 +1,18 @@
+package mods.betterfoliage;
+
+import org.spongepowered.asm.mixin.Mixins;
+import org.spongepowered.asm.mixin.connect.IMixinConnector;
+
+public class MixinConnector implements IMixinConnector {
+    @Override
+    public void connect() {
+        Mixins.addConfiguration("betterfoliage.common.mixins.json");
+
+        try {
+            Class.forName("optifine.OptiFineTransformationService");
+            Mixins.addConfiguration("betterfoliage.optifine.mixins.json");
+        } catch (ClassNotFoundException e) {
+            Mixins.addConfiguration("betterfoliage.vanilla.mixins.json");
+        }
+    }
+}

src/main/java/mods/betterfoliage/loader/BetterFoliageLoader.java

@@ -1,38 +0,0 @@
-package mods.betterfoliage.loader;
-
-import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin;
-
-import java.util.Map;
-
-@IFMLLoadingPlugin.TransformerExclusions({
-    "mods.betterfoliage.loader",
-    "mods.octarinecore.metaprog",
-    "kotlin"
-})
-@IFMLLoadingPlugin.MCVersion("1.12.2")
-@IFMLLoadingPlugin.SortingIndex(1400)
-public class BetterFoliageLoader implements IFMLLoadingPlugin {
-    @Override
-    public String[] getASMTransformerClass() {
-        return new String[] { "mods.betterfoliage.loader.BetterFoliageTransformer" };
-    }
-
-    @Override
-    public String getModContainerClass() {
-        return null;
-    }
-
-    @Override
-    public String getSetupClass() {
-        return null;
-    }
-
-    @Override
-    public void injectData(Map<String, Object> data) {
-    }
-
-    @Override
-    public String getAccessTransformerClass() {
-        return null;
-    }
-}

src/main/java/mods/betterfoliage/mixin/MixinBlock.java

@@ -0,0 +1,33 @@
+package mods.betterfoliage.mixin;
+
+import mods.betterfoliage.Hooks;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.world.IBlockReader;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+/**
+ * Mixin overriding the {@link VoxelShape} used for the neighbor block in {@link Block}.shouldSideBeRendered().
+ *
+ * This way log blocks can be made to not block rendering, without altering any {@link Block} or
+ * {@link BlockState} properties with potential gameplay ramifications.
+ */
+@Mixin(Block.class)
+public class MixinBlock {
+    private static final String shouldSideBeRendered = "Lnet/minecraft/block/Block;shouldRenderFace(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;)Z";
+    private static final String getVoxelShape = "Lnet/minecraft/block/BlockState;func_215702_a(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;)Lnet/minecraft/util/math/shapes/VoxelShape;";
+    private static final String getFaceOcclusionShape = "Lnet/minecraft/block/BlockState;getFaceOcclusionShape(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;)Lnet/minecraft/util/math/shapes/VoxelShape;";
+    private static final String isOpaqueCube = "Lnet/minecraft/block/Block;isOpaqueCube(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;)Z";
+
+    @Redirect(method = shouldSideBeRendered, at = @At(value = "INVOKE", target = getFaceOcclusionShape, ordinal = 1))
+    private static VoxelShape getVoxelShapeOverride(BlockState state, IBlockReader reader, BlockPos pos, Direction dir) {
+        return Hooks.getVoxelShapeOverride(state, reader, pos, dir);
+    }
+}

src/main/java/mods/betterfoliage/mixin/MixinBlockModelRenderer.java

@@ -0,0 +1,41 @@
+package mods.betterfoliage.mixin;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import mods.betterfoliage.model.SpecialRenderModel;
+import mods.betterfoliage.render.pipeline.RenderCtxVanilla;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.renderer.BlockModelRenderer;
+import net.minecraft.client.renderer.model.IBakedModel;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockDisplayReader;
+import net.minecraftforge.client.model.data.IModelData;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import java.util.Random;
+
+@Mixin(BlockModelRenderer.class)
+public class MixinBlockModelRenderer {
+
+    private static final String renderModel = "Lnet/minecraft/client/renderer/BlockModelRenderer;renderModel(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z";
+    private static final String renderModelFlat = "Lnet/minecraft/client/renderer/BlockModelRenderer;renderModelFlat(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z";
+    private static final String renderModelSmooth = "Lnet/minecraft/client/renderer/BlockModelRenderer;renderModelSmooth(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z";
+
+    @Redirect(method = renderModel, at = @At(value = "INVOKE", target = renderModelSmooth), remap = false)
+    public boolean onRenderModelSmooth(BlockModelRenderer renderer, IBlockDisplayReader world, IBakedModel model, BlockState state, BlockPos pos, MatrixStack matrixStack, IVertexBuilder buffer, boolean checkSides, Random random, long rand, int combinedOverlay, IModelData modelData) {
+        if (model instanceof SpecialRenderModel)
+            return RenderCtxVanilla.render(renderer, world, (SpecialRenderModel) model, state, pos, matrixStack, buffer, checkSides, random, rand, combinedOverlay, modelData, true);
+        else
+            return renderer.renderModelSmooth(world, model, state, pos, matrixStack, buffer, checkSides, random, rand, combinedOverlay, modelData);
+    }
+
+    @Redirect(method = renderModel, at = @At(value = "INVOKE", target = renderModelFlat), remap = false)
+    public boolean onRenderModelFlat(BlockModelRenderer renderer, IBlockDisplayReader world, IBakedModel model, BlockState state, BlockPos pos, MatrixStack matrixStack, IVertexBuilder buffer, boolean checkSides, Random random, long rand, int combinedOverlay, IModelData modelData) {
+        if (model instanceof SpecialRenderModel)
+            return RenderCtxVanilla.render(renderer, world, (SpecialRenderModel) model, state, pos, matrixStack, buffer, checkSides, random, rand, combinedOverlay, modelData, false);
+        else
+            return renderer.renderModelSmooth(world, model, state, pos, matrixStack, buffer, checkSides, random, rand, combinedOverlay, modelData);
+    }
+}

src/main/java/mods/betterfoliage/mixin/MixinBlockState.java

@@ -0,0 +1,31 @@
+package mods.betterfoliage.mixin;
+
+import mods.betterfoliage.Hooks;
+import net.minecraft.block.AbstractBlock;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockReader;
+import org.spongepowered.asm.mixin.Debug;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Coerce;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+/**
+ * Mixin to override the result of {@link BlockState}.getAmbientOcclusionLightValue().
+ *
+ * Needed to avoid excessive darkening of Round Logs at the corners, now that they are not full blocks.
+ */
+@Mixin(AbstractBlock.AbstractBlockState.class)
+@SuppressWarnings({"deprecation"})
+public class MixinBlockState {
+    private static final String callFrom = "Lnet/minecraft/block/AbstractBlock$AbstractBlockState;getShadeBrightness(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;)F";
+    // why is the INVOKEVIRTUAL target class Block in the bytecode, not AbstractBlock?
+    private static final String callTo = "Lnet/minecraft/block/Block;getShadeBrightness(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;)F";
+
+    @Redirect(method = callFrom, at = @At(value = "INVOKE", target = callTo))
+    float getAmbientOcclusionValue(Block block, BlockState state, IBlockReader reader, BlockPos pos) {
+        return Hooks.getAmbientOcclusionLightValueOverride(block.getShadeBrightness(state, reader, pos), state);
+    }
+}

src/main/java/mods/betterfoliage/mixin/MixinClientWorld.java

@@ -0,0 +1,44 @@
+package mods.betterfoliage.mixin;
+
+import mods.betterfoliage.Hooks;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.renderer.WorldRenderer;
+import net.minecraft.client.world.ClientWorld;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import java.util.Random;
+
+@Mixin(ClientWorld.class)
+public class MixinClientWorld {
+
+    private static final String worldAnimateTick = "Lnet/minecraft/client/world/ClientWorld;doAnimateTick(IIIILjava/util/Random;ZLnet/minecraft/util/math/BlockPos$Mutable;)V";
+    private static final String blockAnimateTick = "Lnet/minecraft/block/Block;animateTick(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Ljava/util/Random;)V";
+
+    private static final String worldNotify = "Lnet/minecraft/client/world/ClientWorld;sendBlockUpdated(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;Lnet/minecraft/block/BlockState;I)V";
+    private static final String rendererNotify = "Lnet/minecraft/client/renderer/WorldRenderer;blockChanged(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;Lnet/minecraft/block/BlockState;I)V";
+
+    /**
+     * Inject a callback to call for every random display tick. Used for adding custom particle effects to blocks.
+     */
+    @Redirect(method = worldAnimateTick, at = @At(value = "INVOKE", target = blockAnimateTick))
+    void onAnimateTick(Block block, BlockState state, World world, BlockPos pos, Random random) {
+        Hooks.onRandomDisplayTick(block, state, (ClientWorld) world, pos, random);
+        block.animateTick(state, world, pos, random);
+    }
+
+    /**
+     * Inject callback to get notified of client-side blockstate changes.
+     * Used to invalidate caches in the {@link mods.betterfoliage.chunk.ChunkOverlayManager}
+     */
+    @Redirect(method = worldNotify, at = @At(value = "INVOKE", target = rendererNotify))
+    void onClientBlockChanged(WorldRenderer renderer, IBlockReader world, BlockPos pos, BlockState oldState, BlockState newState, int flags) {
+        Hooks.onClientBlockChanged((ClientWorld) world, pos, oldState, newState, flags);
+        renderer.blockChanged(world, pos, oldState, newState, flags);
+    }
+}

src/main/java/mods/betterfoliage/mixin/MixinForgeBlockModelRenderer.java

@@ -0,0 +1,44 @@
+package mods.betterfoliage.mixin;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import mods.betterfoliage.model.SpecialRenderModel;
+import mods.betterfoliage.render.pipeline.RenderCtxForge;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.renderer.model.IBakedModel;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockDisplayReader;
+import net.minecraftforge.client.model.data.IModelData;
+import net.minecraftforge.client.model.pipeline.ForgeBlockModelRenderer;
+import net.minecraftforge.client.model.pipeline.VertexLighterFlat;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import java.util.Random;
+
+@Mixin(ForgeBlockModelRenderer.class)
+public class MixinForgeBlockModelRenderer {
+
+    private static final String renderModelFlat = "Lnet/minecraftforge/client/model/pipeline/ForgeBlockModelRenderer;renderModelFlat(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z";
+    private static final String renderModelSmooth = "Lnet/minecraftforge/client/model/pipeline/ForgeBlockModelRenderer;renderModelSmooth(Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;Lcom/mojang/blaze3d/vertex/IVertexBuilder;ZLjava/util/Random;JILnet/minecraftforge/client/model/data/IModelData;)Z";
+    private static final String render = "Lnet/minecraftforge/client/model/pipeline/ForgeBlockModelRenderer;render(Lnet/minecraftforge/client/model/pipeline/VertexLighterFlat;Lnet/minecraft/world/IBlockDisplayReader;Lnet/minecraft/client/renderer/model/IBakedModel;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;Lcom/mojang/blaze3d/matrix/MatrixStack;ZLjava/util/Random;JLnet/minecraftforge/client/model/data/IModelData;)Z";
+
+    @Redirect(method = {renderModelFlat, renderModelSmooth}, at = @At(value = "INVOKE", target = render), remap = false)
+    public boolean render(
+            VertexLighterFlat lighter,
+            IBlockDisplayReader world,
+            IBakedModel model,
+            BlockState state,
+            BlockPos pos,
+            MatrixStack matrixStack,
+            boolean checkSides,
+            Random rand,
+            long seed,
+            IModelData modelData
+    ) {
+        if (model instanceof SpecialRenderModel)
+            return RenderCtxForge.render(lighter, world, (SpecialRenderModel) model, state, pos, matrixStack, checkSides, rand, seed, modelData);
+        else
+            return ForgeBlockModelRenderer.render(lighter, world, model, state, pos, matrixStack, checkSides, rand, seed, modelData);
+    }
+}

src/main/java/mods/betterfoliage/mixin/MixinForgeCustomVertexLighting.java

@@ -0,0 +1,65 @@
+package mods.betterfoliage.mixin;
+
+import mods.betterfoliage.render.lighting.ForgeVertexLighter;
+import mods.betterfoliage.render.lighting.ForgeVertexLighterAccess;
+import net.minecraftforge.client.model.pipeline.VertexLighterFlat;
+import org.jetbrains.annotations.NotNull;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(VertexLighterFlat.class)
+abstract public class MixinForgeCustomVertexLighting implements ForgeVertexLighter, ForgeVertexLighterAccess {
+
+    private static final String processQuad = "Lnet/minecraftforge/client/model/pipeline/VertexLighterFlat;processQuad()V";
+    private static final String updateLightmap = "Lnet/minecraftforge/client/model/pipeline/VertexLighterFlat;updateLightmap([F[FFFF)V";
+    private static final String updateColor = "Lnet/minecraftforge/client/model/pipeline/VertexLighterFlat;updateColor([F[FFFFFI)V";
+    private static final String resetBlockInfo = "Lnet/minecraftforge/client/model/pipeline/VertexLighterFlat;resetBlockInfo()V";
+
+    @NotNull
+    public ForgeVertexLighter vertexLighter = this;
+
+    @NotNull
+    public ForgeVertexLighter getVertexLighter() {
+        return vertexLighter;
+    }
+
+    public void setVertexLighter(@NotNull ForgeVertexLighter vertexLighter) {
+        this.vertexLighter = vertexLighter;
+    }
+
+
+    @Shadow
+    protected abstract void updateLightmap(float[] normal, float[] lightmap, float x, float y, float z);
+    @Shadow
+    protected abstract void updateColor(float[] normal, float[] color, float x, float y, float z, float tint, int multiplier);
+
+    @Override
+    public void updateVertexLightmap(@NotNull float[] normal, @NotNull float[] lightmap, float x, float y, float z) {
+        updateLightmap(normal, lightmap, x, y, z);
+    }
+
+    @Override
+    public void updateVertexColor(@NotNull float[] normal, @NotNull float[] color, float x, float y, float z, float tint, int multiplier) {
+        updateColor(normal, color, x, y, z, tint, multiplier);
+    }
+
+
+    @Redirect(method = processQuad, at = @At(value = "INVOKE", target = updateColor), remap = false)
+    void onUpdateColor(VertexLighterFlat self, float[] normal, float[] color, float x, float y, float z, float tint, int multiplier) {
+        vertexLighter.updateVertexColor(normal, color, x, y, z, tint, multiplier);
+    }
+
+    @Redirect(method = processQuad, at = @At(value = "INVOKE", target = updateLightmap), remap = false)
+    void onUpdateLightmap(VertexLighterFlat self, float[] normal, float[] lightmap, float x, float y, float z) {
+        vertexLighter.updateVertexLightmap(normal, lightmap, x, y, z);
+    }
+
+    @Inject(method = resetBlockInfo, at = @At("RETURN"), remap = false)
+    void onReset(CallbackInfo ci) {
+        vertexLighter = this;
+    }
+}

src/main/java/mods/betterfoliage/mixin/MixinModelBakery.java

@@ -0,0 +1,43 @@
+package mods.betterfoliage.mixin;
+
+import mods.betterfoliage.BetterFoliageMod;
+import mods.betterfoliage.resource.discovery.BakeWrapperManager;
+import mods.betterfoliage.resource.discovery.ModelDefinitionsLoadedEvent;
+import net.minecraft.client.renderer.model.*;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.profiler.IProfiler;
+import net.minecraft.util.ResourceLocation;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.function.Function;
+
+@Mixin(ModelBakery.class)
+abstract public class MixinModelBakery {
+
+    private static final String processLoading = "Lnet/minecraft/client/renderer/model/ModelBakery;processLoading(Lnet/minecraft/profiler/IProfiler;I)V";
+    private static final String stitch = "Lnet/minecraft/client/renderer/texture/AtlasTexture;stitch(Lnet/minecraft/resources/IResourceManager;Ljava/util/stream/Stream;Lnet/minecraft/profiler/IProfiler;I)Lnet/minecraft/client/renderer/texture/AtlasTexture$SheetData;";
+    private static final String profilerSection = "Lnet/minecraft/profiler/IProfiler;popPush(Ljava/lang/String;)V";
+    private static final String getBakedModel = "Lnet/minecraft/client/renderer/model/ModelBakery;getBakedModel(Lnet/minecraft/util/ResourceLocation;Lnet/minecraft/client/renderer/model/IModelTransform;Ljava/util/function/Function;)Lnet/minecraft/client/renderer/model/IBakedModel;";
+    private static final String bakeModel = "Lnet/minecraft/client/renderer/model/IUnbakedModel;bake(Lnet/minecraft/client/renderer/model/ModelBakery;Ljava/util/function/Function;Lnet/minecraft/client/renderer/model/IModelTransform;Lnet/minecraft/util/ResourceLocation;)Lnet/minecraft/client/renderer/model/IBakedModel;";
+
+    @Inject(method = processLoading, at = @At(value = "INVOKE", target = profilerSection, ordinal = 4))
+    void onBeforeTextures(IProfiler profiler, int maxMipmapLevel, CallbackInfo ci) {
+        profiler.popPush("betterfoliage");
+        BetterFoliageMod.INSTANCE.getBus().post(new ModelDefinitionsLoadedEvent(ModelBakery.class.cast(this)));
+    }
+
+    @Redirect(method = getBakedModel, at = @At(value = "INVOKE", target = bakeModel))
+    IBakedModel onBakeModel(
+            IUnbakedModel unbaked,
+            ModelBakery bakery,
+            Function<RenderMaterial, TextureAtlasSprite> spriteGetter,
+            IModelTransform transform,
+            ResourceLocation locationIn
+    ) {
+        return BakeWrapperManager.INSTANCE.onBake(unbaked, bakery, spriteGetter, transform, locationIn);
+    }
+}

src/main/java/mods/betterfoliage/mixin/MixinOptifineBlockUtils.java

@@ -0,0 +1,38 @@
+package mods.betterfoliage.mixin;
+
+import mods.betterfoliage.Hooks;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.world.IBlockReader;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Pseudo;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Coerce;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Pseudo
+@Mixin(targets = "net.optifine.util.BlockUtils")
+public class MixinOptifineBlockUtils {
+    private static final String shouldSideBeRendered = "shouldSideBeRendered(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;Lnet/optifine/render/RenderEnv;)Z";
+
+    private static final String shouldSideBeRenderedCached = "shouldSideBeRenderedCached(Lnet/minecraft/block/BlockState;Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;Lnet/optifine/render/RenderEnv;Lnet/minecraft/block/BlockState;Lnet/minecraft/util/math/BlockPos;)Z";
+    private static final String getFaceOcclusionShape = "Lnet/minecraft/block/BlockState;getFaceOcclusionShape(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/Direction;)Lnet/minecraft/util/math/shapes/VoxelShape;";
+
+    @SuppressWarnings("UnresolvedMixinReference")
+    @Redirect(method = shouldSideBeRenderedCached, at = @At(value = "INVOKE", target = getFaceOcclusionShape, ordinal = 1))
+    private static VoxelShape getVoxelShapeOverride(BlockState state, IBlockReader reader, BlockPos pos, Direction dir) {
+        return Hooks.getVoxelShapeOverride(state, reader, pos, dir);
+    }
+
+    @SuppressWarnings("UnresolvedMixinReference")
+    @Inject(method = shouldSideBeRendered, at = @At(value = "HEAD"), cancellable = true)
+    private static void shouldForceSideRender(BlockState state, IBlockReader reader, BlockPos pos, Direction face, @Coerce Object renderEnv, CallbackInfoReturnable<Boolean> cir) {
+        if (Hooks.shouldForceSideRenderOF(state, reader, pos, face)) {
+            cir.setReturnValue(true);
+        }
+    }
+}

src/main/java/optifine/OptifineTransformerDevWrapper.java

@@ -1,65 +0,0 @@
-package optifine;
-
-import net.minecraft.launchwrapper.IClassTransformer;
-
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Stream;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
-
-public class OptifineTransformerDevWrapper implements IClassTransformer {
-
-    public static String OPTIFINE_CLASSNAME = "optifine/OptiFineClassTransformer.class";
-    private ZipFile ofZip = null;
-
-    public  OptifineTransformerDevWrapper() {
-        Stream<URL> loaderSources = Arrays.stream(((URLClassLoader) getClass().getClassLoader()).getURLs());
-        Optional<URL> optifineURL = loaderSources.filter(this::isOptifineJar).findFirst();
-        optifineURL.ifPresent(url -> ofZip = getZip(url));
-    }
-
-    private ZipFile getZip(URL url) {
-        try {
-            return new ZipFile(new File(url.toURI()));
-        } catch (Exception e) {
-            return null;
-        }
-    }
-
-    private boolean isOptifineJar(URL url) {
-        ZipFile zip = getZip(url);
-        return zip != null && zip.getEntry(OPTIFINE_CLASSNAME) != null;
-    }
-
-    @Override
-    public byte[] transform(String name, String transformedName, byte[] basicClass) {
-        if (ofZip == null) return basicClass;
-        ZipEntry replacement = ofZip.getEntry(name.replace(".", "/") + ".class");
-        if (replacement == null) return basicClass;
-
-        try {
-            return readAll(ofZip.getInputStream(replacement));
-        } catch (IOException e) {
-            return basicClass;
-        }
-    }
-
-    private byte[] readAll(InputStream is) throws IOException {
-        byte[] buf = new byte[4096];
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        int len;
-        do {
-            len = is.read(buf, 0, 4096);
-            if (len > 0) bos.write(buf, 0, len);
-        } while (len > -1);
-        is.close();
-        return bos.toByteArray();
-    }
-}

src/main/java/optifine/OptifineTweakerDevWrapper.java

@@ -1,28 +0,0 @@
-package optifine;
-
-import net.minecraft.launchwrapper.ITweaker;
-import net.minecraft.launchwrapper.LaunchClassLoader;
-
-import java.io.File;
-import java.util.List;
-
-public class OptifineTweakerDevWrapper implements ITweaker {
-    @Override
-    public void acceptOptions(List<String> args, File gameDir, File assetsDir, String profile) {
-    }
-
-    @Override
-    public void injectIntoClassLoader(LaunchClassLoader classLoader) {
-        classLoader.registerTransformer("optifine.OptifineTransformerDevWrapper");
-    }
-
-    @Override
-    public String getLaunchTarget() {
-        return "net.minecraft.client.main.Main";
-    }
-
-    @Override
-    public String[] getLaunchArguments() {
-        return new String[0];
-    }
-}

src/main/kotlin/mods/betterfoliage/BetterFoliage.kt

@@ -0,0 +1,101 @@
+package mods.betterfoliage
+
+import mods.betterfoliage.chunk.ChunkOverlayManager
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.integration.OptifineCustomColors
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.render.block.vanilla.RoundLogOverlayLayer
+import mods.betterfoliage.render.block.vanilla.StandardCactusDiscovery
+import mods.betterfoliage.render.block.vanilla.StandardCactusModel
+import mods.betterfoliage.render.block.vanilla.StandardDirtDiscovery
+import mods.betterfoliage.render.block.vanilla.StandardDirtModel
+import mods.betterfoliage.render.block.vanilla.StandardGrassDiscovery
+import mods.betterfoliage.render.block.vanilla.StandardGrassModel
+import mods.betterfoliage.render.block.vanilla.StandardLeafDiscovery
+import mods.betterfoliage.render.block.vanilla.StandardLeafModel
+import mods.betterfoliage.render.block.vanilla.StandardLilypadDiscovery
+import mods.betterfoliage.render.block.vanilla.StandardLilypadModel
+import mods.betterfoliage.render.block.vanilla.StandardRoundLogDiscovery
+import mods.betterfoliage.render.block.vanilla.StandardMyceliumDiscovery
+import mods.betterfoliage.render.block.vanilla.StandardMyceliumModel
+import mods.betterfoliage.render.block.vanilla.StandardNetherrackDiscovery
+import mods.betterfoliage.render.block.vanilla.StandardNetherrackModel
+import mods.betterfoliage.render.block.vanilla.StandardRoundLogModel
+import mods.betterfoliage.render.block.vanilla.StandardSandDiscovery
+import mods.betterfoliage.render.block.vanilla.StandardSandModel
+import mods.betterfoliage.render.lighting.AoSideHelper
+import mods.betterfoliage.render.particle.LeafWindTracker
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.BlockTypeCache
+import mods.betterfoliage.resource.discovery.ModelDefinitionsLoadedEvent
+import mods.betterfoliage.resource.generated.GeneratedTexturePack
+import mods.betterfoliage.render.particle.LeafParticleRegistry
+import mods.betterfoliage.render.particle.RisingSoulParticle
+import mods.betterfoliage.util.resourceManager
+import net.minecraft.block.BlockState
+import net.minecraft.client.Minecraft
+import net.minecraft.resources.IReloadableResourceManager
+import net.minecraftforge.eventbus.api.SubscribeEvent
+
+/**
+ * Object responsible for initializing (and holding a reference to) all the infrastructure of the mod
+ * except for the call hooks.
+ */
+object BetterFoliage {
+    /** Resource pack holding generated assets */
+    val generatedPack = GeneratedTexturePack("bf_gen", "Better Foliage generated assets")
+
+    /** List of recognized [BlockState]s */
+    var blockTypes = BlockTypeCache()
+
+    fun init() {
+        // discoverers
+        BetterFoliageMod.bus.register(BakeWrapperManager)
+        BetterFoliageMod.bus.register(LeafParticleRegistry)
+        resourceManager.registerReloadListener(LeafParticleRegistry)
+
+        ChunkOverlayManager.layers.add(RoundLogOverlayLayer)
+
+        listOf(
+            StandardLeafDiscovery,
+            StandardGrassDiscovery,
+            StandardDirtDiscovery,
+            StandardMyceliumDiscovery,
+            StandardSandDiscovery,
+            StandardLilypadDiscovery,
+            StandardCactusDiscovery,
+            StandardNetherrackDiscovery,
+            StandardRoundLogDiscovery
+        ).forEach {
+            BakeWrapperManager.discoverers.add(it)
+        }
+
+        // init singletons
+        val singletons = listOf(
+            AoSideHelper,
+            BlockConfig,
+            ChunkOverlayManager,
+            LeafWindTracker
+        )
+
+        val modelSingletons = listOf(
+            StandardLeafModel.Companion,
+            StandardGrassModel.Companion,
+            StandardDirtModel.Companion,
+            StandardMyceliumModel.Companion,
+            StandardSandModel.Companion,
+            StandardLilypadModel.Companion,
+            StandardCactusModel.Companion,
+            StandardNetherrackModel.Companion,
+            StandardRoundLogModel.Companion,
+            RisingSoulParticle.Companion
+        )
+
+        // init mod integrations
+        val integrations = listOf(
+            ShadersModIntegration,
+            OptifineCustomColors
+        )
+    }
+}
+

src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt

@@ -1,78 +1,40 @@
 package mods.betterfoliage
 
-import mods.betterfoliage.client.Client
+import mods.betterfoliage.config.BlockConfig
-import mods.betterfoliage.client.config.Config
+import mods.betterfoliage.config.Config
-import mods.betterfoliage.client.isAfterPostInit
+import net.minecraft.client.Minecraft
-import net.minecraftforge.common.config.Configuration
+import net.minecraftforge.fml.ModLoadingContext
-import net.minecraftforge.fml.common.FMLCommonHandler
 import net.minecraftforge.fml.common.Mod
-import net.minecraftforge.fml.common.event.FMLPostInitializationEvent
+import net.minecraftforge.fml.config.ModConfig
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent
+import org.apache.logging.log4j.Level
-import net.minecraftforge.fml.common.network.NetworkCheckHandler
+import org.apache.logging.log4j.LogManager
-import net.minecraftforge.fml.relauncher.Side
-import org.apache.logging.log4j.Level.DEBUG
-import org.apache.logging.log4j.Level.INFO
-import org.apache.logging.log4j.Logger
 import org.apache.logging.log4j.simple.SimpleLogger
 import org.apache.logging.log4j.util.PropertiesUtil
+import thedarkcolour.kotlinforforge.forge.MOD_BUS
 import java.io.File
 import java.io.PrintStream
-import java.util.*
+import java.util.Properties
 
-@Mod(
+@Mod(BetterFoliageMod.MOD_ID)
-    modid = BetterFoliageMod.MOD_ID,
-    name = BetterFoliageMod.MOD_NAME,
-    acceptedMinecraftVersions = BetterFoliageMod.MC_VERSIONS,
-    guiFactory = BetterFoliageMod.GUI_FACTORY,
-    dependencies = "after:forgelin",
-    modLanguageAdapter = "net.shadowfacts.forgelin.KotlinAdapter",
-    clientSideOnly = true
-)
 object BetterFoliageMod {
-
     const val MOD_ID = "betterfoliage"
-    const val MOD_NAME = "Better Foliage"
-    const val DOMAIN = "betterfoliage"
-    const val LEGACY_DOMAIN = "bettergrassandleaves"
-    const val MC_VERSIONS = "[1.12]"
-    const val GUI_FACTORY = "mods.betterfoliage.client.gui.ConfigGuiFactory"
 
-    lateinit var log: Logger
+    val bus = MOD_BUS
-    lateinit var logDetail: Logger
 
-    var config: Configuration? = null
+    val detailLogStream = PrintStream(File("logs/betterfoliage.log").apply {
+        parentFile.mkdirs()
+        if (!exists()) createNewFile()
+    })
+
+    fun logger(obj: Any) = LogManager.getLogger(obj)
+    fun detailLogger(obj: Any) = SimpleLogger(
+        obj::class.java.simpleName, Level.DEBUG, false, true, true, false, "yyyy-MM-dd HH:mm:ss", null, PropertiesUtil(Properties()), detailLogStream
+    )
 
     init {
-        // inject pack into default list at construction time to get domains enumerated
+        ModLoadingContext.get().registerConfig(ModConfig.Type.CLIENT, Config.build())
-        // there's no 2nd resource reload pass anymore
+        Minecraft.getInstance().resourcePackRepository.addPackFinder(BetterFoliage.generatedPack.finder)
-        Client.generatorPack.inject()
+        bus.register(BlockConfig)
+        BetterFoliage.init()
     }
-
-    @Mod.EventHandler
-    fun preInit(event: FMLPreInitializationEvent) {
-        log = event.modLog
-        val logDetailFile = File(event.modConfigurationDirectory.parentFile, "logs/betterfoliage.log").apply {
-            parentFile.mkdirs()
-            if (!exists()) createNewFile()
-        }
-        logDetail = SimpleLogger(
-            "BetterFoliage",
-            DEBUG,
-            false, false, true, false,
-            "yyyy-MM-dd HH:mm:ss",
-            null,
-            PropertiesUtil(Properties()),
-            PrintStream(logDetailFile)
-        )
-        config = Configuration(event.suggestedConfigurationFile, null, true)
-
-        Config.attach(config!!)
-        Client.init()
-        Client.log(INFO, "BetterFoliage initialized")
-        isAfterPostInit = true
-    }
-
-    /** Mod is cosmetic only, always allow connection. */
-    @NetworkCheckHandler
-    fun checkVersion(mods: Map<String, String>, side: Side) = true
 }

src/main/kotlin/mods/betterfoliage/CommonRefs.kt

@@ -0,0 +1,90 @@
+package mods.octarinecore
+
+import mods.betterfoliage.util.ClassRef
+import mods.betterfoliage.util.ClassRef.Companion.float
+import mods.betterfoliage.util.ClassRef.Companion.void
+import mods.betterfoliage.util.FieldRef
+import mods.betterfoliage.util.MethodRef
+import net.minecraft.block.Block
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.BlockModelRenderer
+import net.minecraft.client.renderer.BlockRendererDispatcher
+import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.client.renderer.chunk.ChunkRenderCache
+import net.minecraft.client.renderer.model.BakedQuad
+import net.minecraft.client.renderer.model.IUnbakedModel
+import net.minecraft.client.renderer.model.ModelBakery
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.ResourceLocation
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockDisplayReader
+import net.minecraft.world.IBlockReader
+import net.minecraftforge.client.model.pipeline.BlockInfo
+import net.minecraftforge.client.model.pipeline.VertexLighterFlat
+import java.util.Random
+
+// Java
+val String = ClassRef<String>("java.lang.String")
+val List = ClassRef<List<*>>("java.util.List")
+val Random = ClassRef<Random>("java.util.Random")
+fun <K, V> mapRef() = ClassRef<Map<K, V>>("java.util.Map")
+fun <K, V> mapRefMutable() = ClassRef<MutableMap<K, V>>("java.util.Map")
+
+// Minecraft
+val IBlockReader = ClassRef<IBlockReader>("net.minecraft.world.IBlockReader")
+val ILightReader = ClassRef<IBlockDisplayReader>("net.minecraft.world.IBlockDisplayReader")
+val BlockState = ClassRef<BlockState>("net.minecraft.block.BlockState")
+val BlockPos = ClassRef<BlockPos>("net.minecraft.util.math.BlockPos")
+val Block = ClassRef<Block>("net.minecraft.block.Block")
+
+val TextureAtlasSprite = ClassRef<TextureAtlasSprite>("net.minecraft.client.renderer.texture.TextureAtlasSprite")
+val BufferBuilder = ClassRef<BufferBuilder>("net.minecraft.client.renderer.BufferBuilder")
+val BufferBuilder_setSprite = MethodRef(BufferBuilder, "setSprite", void, TextureAtlasSprite)
+val BufferBuilder_sVertexBuilder = FieldRef(BufferBuilder, "sVertexBuilder", SVertexBuilder)
+val BlockRendererDispatcher = ClassRef<BlockRendererDispatcher>("net.minecraft.client.renderer.BlockRendererDispatcher")
+val ChunkRenderCache = ClassRef<ChunkRenderCache>("net.minecraft.client.renderer.chunk.ChunkRenderCache")
+val ResourceLocation = ClassRef<ResourceLocation>("net.minecraft.util.ResourceLocation")
+val BakedQuad = ClassRef<BakedQuad>("net.minecraft.client.renderer.model.BakedQuad")
+val BlockModelRenderer = ClassRef<BlockModelRenderer>("net.minecraft.client.renderer.BlockModelRenderer")
+
+val VertexLighterFlat = ClassRef<VertexLighterFlat>("net.minecraftforge.client.model.pipeline.VertexLighterFlat")
+val BlockInfo = ClassRef<BlockInfo>("net.minecraftforge.client.model.pipeline.BlockInfo")
+val VertexLighterFlat_blockInfo = FieldRef(VertexLighterFlat, "blockInfo", BlockInfo)
+val BlockInfo_shx = FieldRef(BlockInfo, "shx", float)
+val BlockInfo_shy = FieldRef(BlockInfo, "shy", float)
+val BlockInfo_shz = FieldRef(BlockInfo, "shz", float)
+
+object ModelBakery : ClassRef<ModelBakery>("net.minecraft.client.renderer.model.ModelBakery") {
+    val unbakedModels = FieldRef(this, "unbakedModels", mapRefMutable<ResourceLocation, IUnbakedModel>())
+    val topUnbakedModels = FieldRef(this, "topUnbakedModels", mapRefMutable<ResourceLocation, IUnbakedModel>())
+}
+
+// Optifine
+val OptifineClassTransformer = ClassRef<Any>("optifine.OptiFineClassTransformer")
+val BlockPosM = ClassRef<Any>("net.optifine.BlockPosM")
+object ChunkCacheOF : ClassRef<Any>("net.optifine.override.ChunkCacheOF") {
+    val chunkCache = FieldRef(this, "chunkCache", ChunkRenderCache)
+}
+
+object RenderEnv : ClassRef<Any>("net.optifine.render.RenderEnv") {
+    val reset = MethodRef(this, "reset", void, BlockState, BlockPos)
+}
+
+// Optifine custom colors
+val IColorizer = ClassRef<Any>("net.optifine.CustomColors\$IColorizer")
+object CustomColors : ClassRef<Any>("net.optifine.CustomColors") {
+    val getColorMultiplier = MethodRef(this, "getColorMultiplier", int, BakedQuad, BlockState, ILightReader, BlockPos, RenderEnv)
+}
+
+// Optifine shaders
+object SVertexBuilder : ClassRef<Any>("net.optifine.shaders.SVertexBuilder") {
+    val pushState = MethodRef(this, "pushEntity", void, long)
+    val popState = MethodRef(this, "popEntity", void)
+}
+
+object BlockAliases : ClassRef<Any>("net.optifine.shaders.BlockAliases") {
+    val getAliasBlockId = MethodRef(this, "getAliasBlockId", int, BlockState)
+}
+
+
+

src/main/kotlin/mods/betterfoliage/Events.kt

@@ -0,0 +1,8 @@
+package mods.betterfoliage
+
+import net.minecraft.client.renderer.model.ModelBakery
+import net.minecraft.client.renderer.texture.AtlasTexture
+import net.minecraft.resources.IResourceManager
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.eventbus.api.Event
+

src/main/kotlin/mods/betterfoliage/Hooks.kt

@@ -0,0 +1,76 @@
+@file:JvmName("Hooks")
+package mods.betterfoliage
+
+import mods.betterfoliage.chunk.ChunkOverlayManager
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.WeightedModelWrapper
+import mods.betterfoliage.render.block.vanilla.RoundLogKey
+import mods.betterfoliage.render.particle.FallingLeafParticle
+import mods.betterfoliage.render.particle.LeafBlockModel
+import mods.betterfoliage.render.particle.RisingSoulParticle
+import net.minecraft.block.Block
+import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
+import net.minecraft.client.Minecraft
+import net.minecraft.client.world.ClientWorld
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.shapes.VoxelShape
+import net.minecraft.util.math.shapes.VoxelShapes
+import net.minecraft.world.IBlockDisplayReader
+import net.minecraft.world.IBlockReader
+import net.minecraft.world.World
+import java.util.Random
+
+fun getAmbientOcclusionLightValueOverride(original: Float, state: BlockState): Float {
+    if (Config.enabled && Config.roundLogs.enabled && BetterFoliage.blockTypes.hasTyped<RoundLogKey>(state))
+        return Config.roundLogs.dimming.toFloat()
+    return original
+}
+
+fun onClientBlockChanged(worldClient: ClientWorld, pos: BlockPos, oldState: BlockState, newState: BlockState, flags: Int) {
+    ChunkOverlayManager.onBlockChange(worldClient, pos)
+}
+
+fun onRandomDisplayTick(block: Block, state: BlockState, world: ClientWorld, pos: BlockPos, random: Random) {
+    if (Config.enabled &&
+        Config.risingSoul.enabled &&
+        state.block == Blocks.SOUL_SAND &&
+        world.getBlockState(pos.relative(UP)).isAir &&
+        Math.random() < Config.risingSoul.chance) {
+            RisingSoulParticle(world, pos).addIfValid()
+    }
+
+    if (Config.enabled &&
+        Config.fallingLeaves.enabled &&
+        random.nextDouble() < Config.fallingLeaves.chance &&
+        world.getBlockState(pos.relative(DOWN)).isAir
+    ) {
+        (getActualRenderModel(world, pos, state, random) as? LeafBlockModel)?.let { leafModel ->
+            val blockColor = Minecraft.getInstance().blockColors.getColor(state, world, pos, 0)
+            FallingLeafParticle(world, pos, leafModel.key, blockColor, random).addIfValid()
+        }
+    }
+}
+
+fun getVoxelShapeOverride(state: BlockState, reader: IBlockReader, pos: BlockPos, dir: Direction): VoxelShape {
+    if (Config.enabled && Config.roundLogs.enabled && BetterFoliage.blockTypes.hasTyped<RoundLogKey>(state))
+        return VoxelShapes.empty()
+    return state.getFaceOcclusionShape(reader, pos, dir)
+}
+
+fun shouldForceSideRenderOF(state: BlockState, world: IBlockReader, pos: BlockPos, face: Direction) =
+    world.getBlockState(pos.relative(face)).let { neighbor -> BetterFoliage.blockTypes.hasTyped<RoundLogKey>(neighbor) }
+
+fun getActualRenderModel(world: IBlockDisplayReader, pos: BlockPos, state: BlockState, random: Random): SpecialRenderModel? {
+    val model = Minecraft.getInstance().blockRenderer.blockModelShaper.getBlockModel(state) as? SpecialRenderModel
+        ?: return null
+    if (model is WeightedModelWrapper) {
+        random.setSeed(state.getSeed(pos))
+        return model.getModel(random).model
+    }
+    return model
+}

src/main/kotlin/mods/betterfoliage/chunk/BlockContext.kt

@@ -0,0 +1,60 @@
+package mods.betterfoliage.chunk
+
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.offset
+import mods.betterfoliage.util.plus
+import mods.betterfoliage.util.semiRandom
+import net.minecraft.block.Block
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.chunk.ChunkRenderCache
+import net.minecraft.util.Direction
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockDisplayReader
+import net.minecraft.world.IWorldReader
+import net.minecraft.world.biome.Biome
+import net.minecraft.world.level.ColorResolver
+
+/**
+ * Represents the block being rendered. Has properties and methods to query the neighborhood of the block in
+ * block-relative coordinates.
+ */
+interface BlockCtx {
+    val world: IBlockDisplayReader
+    val pos: BlockPos
+
+    fun offset(dir: Direction) = offset(dir.offset)
+    fun offset(offset: Int3): BlockCtx
+
+    val state: BlockState get() = world.getBlockState(pos)
+    fun state(offset: Int3) = world.getBlockState(pos + offset)
+    fun state(dir: Direction) = state(dir.offset)
+
+    fun isAir(offset: Int3) = (pos + offset).let { world.getBlockState(it).isAir(world, it) }
+    fun isAir(dir: Direction) = isAir(dir.offset)
+
+    val biome: Biome? get() =
+        (world as? IWorldReader)?.getBiome(pos) ?:
+        (world as? ChunkRenderCache)?.level?.getBiome(pos)
+
+    val isFullBlock: Boolean get() = state.isCollisionShapeFullBlock(world, pos)
+
+    fun isNeighborSturdy(dir: Direction) = offset(dir).let { it.state.isFaceSturdy(it.world, it.pos, dir.opposite) }
+
+    fun shouldSideBeRendered(side: Direction) = Block.shouldRenderFace(state, world, pos, side)
+
+    /** Get a semi-random value based on the block coordinate and the given seed. */
+    fun semiRandom(seed: Int) = pos.semiRandom(seed)
+
+    /** Get an array of semi-random values based on the block coordinate. */
+    fun semiRandomArray(num: Int): Array<Int> = Array(num) { semiRandom(it) }
+
+    fun color(resolver: ColorResolver) = world.getBlockTint(pos, resolver)
+}
+
+class BasicBlockCtx(
+    override val world: IBlockDisplayReader,
+    override val pos: BlockPos
+) : BlockCtx {
+    override val state: BlockState = world.getBlockState(pos)
+    override fun offset(offset: Int3) = BasicBlockCtx(world, pos + offset)
+}

src/main/kotlin/mods/betterfoliage/chunk/Overlay.kt

@@ -0,0 +1,118 @@
+package mods.betterfoliage.chunk
+
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.isInstance
+import mods.octarinecore.ChunkCacheOF
+import net.minecraft.client.renderer.chunk.ChunkRenderCache
+import net.minecraft.client.world.ClientWorld
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.ChunkPos
+import net.minecraft.world.DimensionType
+import net.minecraft.world.IBlockDisplayReader
+import net.minecraft.world.IWorldReader
+import net.minecraftforge.common.MinecraftForge
+import net.minecraftforge.event.world.ChunkEvent
+import net.minecraftforge.event.world.WorldEvent
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import java.util.*
+import kotlin.collections.set
+
+val IBlockDisplayReader.dimType: DimensionType get() = when {
+    this is IWorldReader -> dimensionType()
+    this is ChunkRenderCache -> level.dimensionType()
+    this.isInstance(ChunkCacheOF) -> this[ChunkCacheOF.chunkCache].level.dimensionType()
+    else -> throw IllegalArgumentException("DimensionType of world with class ${this::class.qualifiedName} cannot be determined!")
+}
+
+/**
+ * Represents some form of arbitrary non-persistent data that can be calculated and cached for each block position
+ */
+interface ChunkOverlayLayer<T> {
+    fun calculate(ctx: BlockCtx): T
+    fun onBlockUpdate(world: IBlockDisplayReader, pos: BlockPos)
+}
+
+/**
+ * Query, lazy calculation and lifecycle management of multiple layers of chunk overlay data.
+ */
+object ChunkOverlayManager {
+
+    var tempCounter = 0
+
+    init {
+        MinecraftForge.EVENT_BUS.register(this)
+    }
+
+    val chunkData = IdentityHashMap<DimensionType, MutableMap<ChunkPos, ChunkOverlayData>>()
+    val layers = mutableListOf<ChunkOverlayLayer<*>>()
+
+    /**
+     * Get the overlay data for a given layer and position
+     *
+     * @param layer Overlay layer to query
+     * @param reader World to use if calculation of overlay value is necessary
+     * @param pos Block position
+     */
+    fun <T> get(layer: ChunkOverlayLayer<T>, ctx: BlockCtx): T? {
+        val data = chunkData[ctx.world.dimType]?.get(ChunkPos(ctx.pos)) ?: return null
+        data.get(layer, ctx.pos).let { value ->
+            if (value !== ChunkOverlayData.UNCALCULATED) return value
+            val newValue = layer.calculate(ctx)
+            data.set(layer, ctx.pos, newValue)
+            return newValue
+        }
+    }
+
+    /**
+     * Clear the overlay data for a given layer and position
+     *
+     * @param layer Overlay layer to clear
+     * @param pos Block position
+     */
+    fun <T> clear(dimension: DimensionType, layer: ChunkOverlayLayer<T>, pos: BlockPos) {
+        chunkData[dimension]?.get(ChunkPos(pos))?.clear(layer, pos)
+    }
+
+    fun onBlockChange(world: ClientWorld, pos: BlockPos) {
+        if (chunkData[world.dimType]?.containsKey(ChunkPos(pos)) == true) {
+            layers.forEach { layer -> layer.onBlockUpdate(world, pos) }
+        }
+    }
+
+    @SubscribeEvent
+    fun handleLoadWorld(event: WorldEvent.Load) = (event.world as? ClientWorld)?.let { world ->
+        chunkData[world.dimType] = mutableMapOf()
+    }
+
+    @SubscribeEvent
+    fun handleUnloadWorld(event: WorldEvent.Unload) = (event.world as? ClientWorld)?.let { world ->
+        chunkData.remove(world.dimType)
+    }
+
+    @SubscribeEvent
+    fun handleLoadChunk(event: ChunkEvent.Load) = (event.world as? ClientWorld)?.let { world ->
+        chunkData[world.dimType]?.let { chunks ->
+            // check for existence first because Optifine fires a TON of these
+            if (event.chunk.pos !in chunks.keys) chunks[event.chunk.pos] = ChunkOverlayData(layers)
+        }
+    }
+
+    @SubscribeEvent
+    fun handleUnloadChunk(event: ChunkEvent.Unload) = (event.world as? ClientWorld)?.let { world ->
+        chunkData[world.dimType]?.remove(event.chunk.pos)
+    }
+}
+
+class ChunkOverlayData(layers: List<ChunkOverlayLayer<*>>) {
+    val BlockPos.isValid: Boolean get() = y in validYRange
+    val rawData = layers.associateWith { emptyOverlay() }
+    fun <T> get(layer: ChunkOverlayLayer<T>, pos: BlockPos): T? = if (pos.isValid) rawData[layer]?.get(pos.x and 15)?.get(pos.z and 15)?.get(pos.y) as T? else null
+    fun <T> set(layer: ChunkOverlayLayer<T>, pos: BlockPos, data: T) = if (pos.isValid) rawData[layer]?.get(pos.x and 15)?.get(pos.z and 15)?.set(pos.y, data) else null
+    fun <T> clear(layer: ChunkOverlayLayer<T>, pos: BlockPos) = if (pos.isValid) rawData[layer]?.get(pos.x and 15)?.get(pos.z and 15)?.set(pos.y, UNCALCULATED) else null
+
+    companion object {
+        val UNCALCULATED = object {}
+        fun emptyOverlay() = Array(16) { Array(16) { Array<Any?>(256) { UNCALCULATED }}}
+        val validYRange = 0 until 256
+    }
+}

src/main/kotlin/mods/betterfoliage/client/Client.kt

@@ -1,121 +0,0 @@
-package mods.betterfoliage.client
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.gui.ConfigGuiFactory
-import mods.betterfoliage.client.integration.*
-import mods.betterfoliage.client.render.*
-import mods.betterfoliage.client.texture.*
-import mods.octarinecore.client.KeyHandler
-import mods.octarinecore.client.gui.textComponent
-import mods.octarinecore.client.render.AbstractBlockRenderingHandler
-import mods.octarinecore.client.resource.CenteringTextureGenerator
-import mods.octarinecore.client.resource.GeneratorPack
-import net.minecraft.block.Block
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.Minecraft
-import net.minecraft.util.math.BlockPos
-import net.minecraft.util.text.TextComponentTranslation
-import net.minecraft.util.text.TextFormatting
-import net.minecraftforge.fml.client.FMLClientHandler
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
-
-/**
- * Object responsible for initializing (and holding a reference to) all the infrastructure of the mod
- * except for the call hooks.
- *
- * This and all other singletons are annotated [SideOnly] to avoid someone accidentally partially
- * initializing the mod on a server environment.
- */
-@SideOnly(Side.CLIENT)
-object Client {
-
-    lateinit var renderers: List<AbstractBlockRenderingHandler>
-    val suppressRenderErrors = mutableSetOf<IBlockState>()
-
-    // texture generation stuff
-    val genGrass = GrassGenerator("bf_gen_grass")
-    val genLeaves = LeafGenerator("bf_gen_leaves")
-    val genReeds = CenteringTextureGenerator("bf_gen_reeds", 1, 2)
-
-    val generatorPack = GeneratorPack(
-        "Better Foliage generated",
-        genGrass,
-        genLeaves,
-        genReeds
-    )
-
-    fun init() {
-        // init renderers
-        renderers = listOf(
-            RenderGrass(),
-            RenderMycelium(),
-            RenderLeaves(),
-            RenderCactus(),
-            RenderLilypad(),
-            RenderReeds(),
-            RenderAlgae(),
-            RenderCoral(),
-            RenderLog(),
-            RenderNetherrack(),
-            RenderConnectedGrass(),
-            RenderConnectedGrassLog()
-        )
-
-        // init other singletons
-        val singletons = listOf(
-            StandardCactusRegistry,
-            LeafParticleRegistry,
-            ChunkOverlayManager,
-            LeafWindTracker,
-            RisingSoulTextures
-        )
-
-        // init mod integrations
-        val integrations = listOf(
-            ShadersModIntegration,
-            OptifineCustomColors,
-            ForestryIntegration,
-            IC2RubberIntegration,
-            TechRebornRubberIntegration
-        )
-
-        // add basic block support instances as last
-        GrassRegistry.addRegistry(StandardGrassRegistry)
-        LeafRegistry.addRegistry(StandardLeafRegistry)
-        LogRegistry.addRegistry(StandardLogRegistry)
-
-        // init config hotkey
-        val configKey = KeyHandler(BetterFoliageMod.MOD_NAME, 66, "key.betterfoliage.gui") {
-            FMLClientHandler.instance().showGuiScreen(
-                ConfigGuiFactory.createBFConfigGui(Minecraft.getMinecraft().currentScreen)
-            )
-        }
-    }
-
-    fun log(level: Level, msg: String) {
-        BetterFoliageMod.log.log(level, "[BetterFoliage] $msg")
-        BetterFoliageMod.logDetail.log(level, msg)
-    }
-
-    fun logDetail(msg: String) {
-        BetterFoliageMod.logDetail.log(Level.DEBUG, msg)
-    }
-
-    fun logRenderError(state: IBlockState, location: BlockPos) {
-        if (state in suppressRenderErrors) return
-        suppressRenderErrors.add(state)
-
-        val blockName = Block.REGISTRY.getNameForObject(state.block).toString()
-        val blockLoc = "${location.x},${location.y},${location.z}"
-        Minecraft.getMinecraft().ingameGUI.chatGUI.printChatMessage(TextComponentTranslation(
-            "betterfoliage.rendererror",
-            textComponent(blockName, TextFormatting.GOLD),
-            textComponent(blockLoc, TextFormatting.GOLD)
-        ))
-        logDetail("Error rendering block $state at $blockLoc")
-    }
-}
-

src/main/kotlin/mods/betterfoliage/client/Hooks.kt

@@ -1,101 +0,0 @@
-@file:JvmName("Hooks")
-@file:SideOnly(Side.CLIENT)
-package mods.betterfoliage.client
-
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.render.*
-import mods.betterfoliage.loader.Refs
-import mods.octarinecore.client.render.blockContext
-import mods.octarinecore.client.resource.LoadModelDataEvent
-import mods.octarinecore.common.plus
-import mods.octarinecore.metaprog.allAvailable
-import net.minecraft.block.Block
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.Minecraft
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.init.Blocks
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.BlockRenderLayer.CUTOUT
-import net.minecraft.util.BlockRenderLayer.CUTOUT_MIPPED
-import net.minecraft.util.EnumFacing
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraft.world.World
-import net.minecraftforge.client.model.ModelLoader
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-
-var isAfterPostInit = false
-val isOptifinePresent = allAvailable(Refs.OptifineClassTransformer)
-
-fun doesSideBlockRenderingOverride(original: Boolean, blockAccess: IBlockAccess, pos: BlockPos, side: EnumFacing): Boolean {
-    return original && !(Config.enabled && Config.roundLogs.enabled && Config.blocks.logClasses.matchesClass(blockAccess.getBlockState(pos).block));
-}
-
-fun isOpaqueCubeOverride(original: Boolean, state: IBlockState): Boolean {
-    // caution: blocks are initialized and the method called during startup
-    if (!isAfterPostInit) return original
-    return original && !(Config.enabled && Config.roundLogs.enabled && Config.blocks.logClasses.matchesClass(state.block))
-}
-
-fun getAmbientOcclusionLightValueOverride(original: Float, state: IBlockState): Float {
-    if (Config.enabled && Config.roundLogs.enabled && Config.blocks.logClasses.matchesClass(state.block)) return Config.roundLogs.dimming;
-    return original;
-}
-
-fun getUseNeighborBrightnessOverride(original: Boolean, state: IBlockState): Boolean {
-    return original || (Config.enabled && Config.roundLogs.enabled && Config.blocks.logClasses.matchesClass(state.block));
-}
-
-fun onRandomDisplayTick(world: World, state: IBlockState, pos: BlockPos) {
-    if (Config.enabled &&
-        Config.risingSoul.enabled &&
-        state.block == Blocks.SOUL_SAND &&
-        world.isAirBlock(pos + up1) &&
-        Math.random() < Config.risingSoul.chance) {
-            EntityRisingSoulFX(world, pos).addIfValid()
-    }
-
-    if (Config.enabled &&
-        Config.fallingLeaves.enabled &&
-        Config.blocks.leavesClasses.matchesClass(state.block) &&
-        world.isAirBlock(pos + down1) &&
-        Math.random() < Config.fallingLeaves.chance) {
-            EntityFallingLeavesFX(world, pos).addIfValid()
-    }
-}
-
-fun onAfterLoadModelDefinitions(loader: ModelLoader) {
-    MinecraftForge.EVENT_BUS.post(LoadModelDataEvent(loader))
-}
-
-fun renderWorldBlock(dispatcher: BlockRendererDispatcher,
-                     state: IBlockState,
-                     pos: BlockPos,
-                     blockAccess: IBlockAccess,
-                     worldRenderer: BufferBuilder,
-                     layer: BlockRenderLayer
-): Boolean {
-    val doBaseRender = state.canRenderInLayer(layer) || (layer == targetCutoutLayer && state.canRenderInLayer(otherCutoutLayer))
-    blockContext.let { ctx ->
-        ctx.set(blockAccess, pos)
-        Client.renderers.forEach { renderer ->
-            if (renderer.isEligible(ctx)) {
-                // render on the block's default layer
-                // also render on the cutout layer if the renderer requires it
-                if (doBaseRender || (renderer.addToCutout && layer == targetCutoutLayer)) {
-                    return renderer.render(ctx, dispatcher, worldRenderer, layer)
-                }
-            }
-        }
-    }
-
-    return if (doBaseRender) dispatcher.renderBlock(state, pos, blockAccess, worldRenderer) else false
-}
-
-fun canRenderBlockInLayer(block: Block, state: IBlockState, layer: BlockRenderLayer) = block.canRenderInLayer(state, layer) || layer == targetCutoutLayer
-
-val targetCutoutLayer: BlockRenderLayer get() = if (Minecraft.getMinecraft().gameSettings.mipmapLevels > 0) CUTOUT_MIPPED else CUTOUT
-val otherCutoutLayer: BlockRenderLayer get() = if (Minecraft.getMinecraft().gameSettings.mipmapLevels > 0) CUTOUT else CUTOUT_MIPPED

src/main/kotlin/mods/betterfoliage/client/chunk/Overlay.kt

@@ -1,124 +0,0 @@
-package mods.betterfoliage.client.chunk
-
-import mods.betterfoliage.client.Client
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.multiplayer.WorldClient
-import net.minecraft.entity.Entity
-import net.minecraft.entity.player.EntityPlayer
-import net.minecraft.util.SoundCategory
-import net.minecraft.util.SoundEvent
-import net.minecraft.util.math.BlockPos
-import net.minecraft.util.math.ChunkPos
-import net.minecraft.world.IBlockAccess
-import net.minecraft.world.IWorldEventListener
-import net.minecraft.world.World
-import net.minecraft.world.chunk.EmptyChunk
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.event.world.ChunkEvent
-import net.minecraftforge.event.world.WorldEvent
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
-import org.apache.logging.log4j.Level
-
-/**
- * Represents some form of arbitrary non-persistent data that can be calculated and cached for each block position
- */
-interface ChunkOverlayLayer<T> {
-    abstract fun calculate(world: IBlockAccess, pos: BlockPos): T
-    abstract fun onBlockUpdate(world: IBlockAccess, pos: BlockPos)
-}
-
-/**
- * Query, lazy calculation and lifecycle management of multiple layers of chunk overlay data.
- */
-object ChunkOverlayManager : IBlockUpdateListener {
-    init {
-        Client.log(Level.INFO, "Initializing client overlay manager")
-        MinecraftForge.EVENT_BUS.register(this)
-    }
-
-    val chunkData = mutableMapOf<ChunkPos, ChunkOverlayData>()
-    val layers = mutableListOf<ChunkOverlayLayer<*>>()
-
-    /**
-     * Get the overlay data for a given layer and position
-     *
-     * @param layer Overlay layer to query
-     * @param world World to use if calculation of overlay value is necessary
-     * @param pos Block position
-     */
-    fun <T> get(layer: ChunkOverlayLayer<T>, world: IBlockAccess, pos: BlockPos): T? {
-        val data = chunkData[ChunkPos(pos)] ?: return null
-        data.get(layer, pos).let { value ->
-            if (value !== ChunkOverlayData.UNCALCULATED) return value
-            val newValue = layer.calculate(world, pos)
-            data.set(layer, pos, newValue)
-            return newValue
-        }
-    }
-
-    /**
-     * Clear the overlay data for a given layer and position
-     *
-     * @param layer Overlay layer to clear
-     * @param pos Block position
-     */
-    fun <T> clear(layer: ChunkOverlayLayer<T>, pos: BlockPos) {
-        chunkData[ChunkPos(pos)]?.clear(layer, pos)
-    }
-
-    override fun notifyBlockUpdate(world: World, pos: BlockPos, oldState: IBlockState, newState: IBlockState, flags: Int) {
-        if (chunkData.containsKey(ChunkPos(pos))) layers.forEach { layer -> layer.onBlockUpdate(world, pos) }
-    }
-
-    @SubscribeEvent
-    fun handleLoadWorld(event: WorldEvent.Load) {
-        if (event.world is WorldClient) {
-            event.world.addEventListener(this)
-        }
-    }
-
-    @SubscribeEvent
-    fun handleLoadChunk(event: ChunkEvent.Load) {
-        if (event.world is WorldClient && event.chunk !is EmptyChunk) {
-            chunkData[event.chunk.pos] = ChunkOverlayData(layers)
-        }
-    }
-    @SubscribeEvent
-    fun handleUnloadChunk(event: ChunkEvent.Unload) {
-        if (event.world is WorldClient) {
-            chunkData.remove(event.chunk.pos)
-        }
-    }
-}
-
-class ChunkOverlayData(layers: List<ChunkOverlayLayer<*>>) {
-    val BlockPos.isValid: Boolean get() = y in validYRange
-    val rawData = layers.associateWith { emptyOverlay() }
-    fun <T> get(layer: ChunkOverlayLayer<T>, pos: BlockPos): T? = if (pos.isValid) rawData[layer]?.get(pos.x and 15)?.get(pos.z and 15)?.get(pos.y) as T? else null
-    fun <T> set(layer: ChunkOverlayLayer<T>, pos: BlockPos, data: T) = if (pos.isValid) rawData[layer]?.get(pos.x and 15)?.get(pos.z and 15)?.set(pos.y, data) else null
-    fun <T> clear(layer: ChunkOverlayLayer<T>, pos: BlockPos) = if (pos.isValid) rawData[layer]?.get(pos.x and 15)?.get(pos.z and 15)?.set(pos.y, UNCALCULATED) else null
-
-    companion object {
-        val UNCALCULATED = object {}
-        fun emptyOverlay() = Array(16) { Array(16) { Array<Any?>(256) { UNCALCULATED }}}
-        val validYRange = 0 until 256
-    }
-}
-
-/**
- * IWorldEventListener helper subclass
- * No-op for everything except notifyBlockUpdate()
- */
-interface IBlockUpdateListener : IWorldEventListener {
-    override fun playSoundToAllNearExcept(player: EntityPlayer?, soundIn: SoundEvent, category: SoundCategory, x: Double, y: Double, z: Double, volume: Float, pitch: Float) {}
-    override fun onEntityAdded(entityIn: Entity) {}
-    override fun broadcastSound(soundID: Int, pos: BlockPos, data: Int) {}
-    override fun playEvent(player: EntityPlayer?, type: Int, blockPosIn: BlockPos, data: Int) {}
-    override fun onEntityRemoved(entityIn: Entity) {}
-    override fun notifyLightSet(pos: BlockPos) {}
-    override fun spawnParticle(particleID: Int, ignoreRange: Boolean, xCoord: Double, yCoord: Double, zCoord: Double, xSpeed: Double, ySpeed: Double, zSpeed: Double, vararg parameters: Int) {}
-    override fun spawnParticle(id: Int, ignoreRange: Boolean, minimiseParticleLevel: Boolean, x: Double, y: Double, z: Double, xSpeed: Double, ySpeed: Double, zSpeed: Double, vararg parameters: Int) {}
-    override fun playRecord(soundIn: SoundEvent, pos: BlockPos) {}
-    override fun sendBlockBreakProgress(breakerId: Int, pos: BlockPos, progress: Int) {}
-    override fun markBlockRangeForRenderUpdate(x1: Int, y1: Int, z1: Int, x2: Int, y2: Int, z2: Int) {}
-}

src/main/kotlin/mods/betterfoliage/client/config/Config.kt

@@ -1,207 +0,0 @@
-package mods.betterfoliage.client.config
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.gui.BiomeListConfigEntry
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.octarinecore.common.config.*
-import net.minecraft.client.Minecraft
-import net.minecraft.world.biome.Biome
-import net.minecraftforge.fml.client.event.ConfigChangedEvent
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.lwjgl.opengl.GL11
-
-// BetterFoliage-specific property delegates
-private val OBSOLETE = ObsoleteConfigProperty()
-private fun featureEnable() = boolean(true).lang("enabled")
-fun biomeList(defaults: (Biome) -> Boolean) = intList {
-    Biome.REGISTRY
-        .filter { it != null && defaults(it) }
-        .map { Biome.REGISTRY.getIDForObject(it) }
-        .toTypedArray()
-}.apply { guiClass = BiomeListConfigEntry::class.java }
-
-// Biome filter methods
-private fun Biome.filterTemp(min: Float?, max: Float?) = (min == null || min <= defaultTemperature) && (max == null || max >= defaultTemperature)
-private fun Biome.filterRain(min: Float?, max: Float?) = (min == null || min <= rainfall) && (max == null || max >= rainfall)
-private fun Biome.filterClass(vararg name: String) = name.any { it in this.javaClass.name.toLowerCase() }
-
-// Config singleton
-@SideOnly(Side.CLIENT)
-object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAIN) {
-
-    var enabled by boolean(true)
-    var nVidia by boolean(GL11.glGetString(GL11.GL_VENDOR).toLowerCase().contains("nvidia"))
-
-    object shaders {
-        val leavesId by long(min = 1, max = 65535, default = ShadersModIntegration.leavesDefaultBlockId.toInt())
-        val grassId by long(min = 1, max = 65535, default = ShadersModIntegration.grassDefaultBlockId.toInt())
-    }
-
-    object blocks {
-        val leavesClasses = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "leaves_blocks_default.cfg")
-        val leavesModels = ModelTextureListConfigOption(BetterFoliageMod.DOMAIN, "leaves_models_default.cfg", 1)
-        val grassClasses = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "grass_blocks_default.cfg")
-        val grassModels = ModelTextureListConfigOption(BetterFoliageMod.DOMAIN, "grass_models_default.cfg", 1)
-        val mycelium = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "mycelium_blocks_default.cfg")
-        val dirt = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "dirt_default.cfg")
-        val crops = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "crop_default.cfg")
-        val logClasses = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "log_blocks_default.cfg")
-        val logModels = ModelTextureListConfigOption(BetterFoliageMod.DOMAIN, "log_models_default.cfg", 3)
-        val sand = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "sand_default.cfg")
-        val lilypad = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "lilypad_default.cfg")
-        val cactus = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "cactus_default.cfg")
-        val netherrack = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "netherrack_blocks_default.cfg")
-
-        val leavesWhitelist = OBSOLETE
-        val leavesBlacklist = OBSOLETE
-        val grassWhitelist = OBSOLETE
-        val grassBlacklist = OBSOLETE
-        val logsWhitelist = OBSOLETE
-        val logsBlacklist = OBSOLETE
-    }
-
-    object leaves {
-        val enabled by featureEnable()
-        val snowEnabled by boolean(true)
-        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
-        val vOffset by double(max=0.4, default=0.1).lang("vOffset")
-        val size by double(min=0.75, max=2.5, default=1.4).lang("size")
-        val dense by boolean(false)
-        val hideInternal by boolean(true)
-    }
-
-    object shortGrass {
-        val grassEnabled by boolean(true)
-        val myceliumEnabled by boolean(true)
-        val snowEnabled by boolean(true)
-        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
-        val heightMin by double(min=0.1, max=2.5, default=0.6).lang("heightMin")
-        val heightMax by double(min=0.1, max=2.5, default=0.8).lang("heightMax")
-        val size by double(min=0.5, max=1.5, default=1.0).lang("size")
-        val population by int(max=64, default=64).lang("population")
-        val useGenerated by boolean(false)
-        val shaderWind by boolean(true).lang("shaderWind")
-        val saturationThreshold by double(default=0.1)
-    }
-
-//    object hangingGrass {
-//        var enabled by featureEnable()
-//        var distance by distanceLimit()
-//        var size by double(min=0.25, max=1.5, default=0.75).lang("size")
-//        var separation by double(max=0.5, default=0.25)
-//    }
-
-    object connectedGrass {
-        val enabled by boolean(true)
-        val snowEnabled by boolean(false)
-    }
-
-    object roundLogs {
-        val enabled by featureEnable()
-        val radiusSmall by double(max=0.5, default=0.25)
-        val radiusLarge by double(max=0.5, default=0.44)
-        val dimming by float(default = 0.7)
-        val connectSolids by boolean(false)
-        val lenientConnect by boolean(true)
-        val connectPerpendicular by boolean(true)
-        val connectGrass by boolean(true)
-        val defaultY by boolean(false)
-        val zProtection by double(min = 0.9, default = 0.99)
-    }
-
-    object cactus {
-        val enabled by featureEnable()
-        val size by double(min=0.5, max=1.5, default=0.8).lang("size")
-        val sizeVariation by double(max=0.5, default=0.1)
-        val hOffset by double(max=0.5, default=0.1).lang("hOffset")
-    }
-
-    object lilypad {
-        val enabled by featureEnable()
-        val hOffset by double(max=0.25, default=0.1).lang("hOffset")
-        val flowerChance by int(max=64, default=16, min=0)
-    }
-
-    object reed {
-        val enabled by featureEnable()
-        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
-        val heightMin by double(min=1.5, max=3.5, default=1.7).lang("heightMin")
-        val heightMax by double(min=1.5, max=3.5, default=2.2).lang("heightMax")
-        val population by int(max=64, default=32).lang("population")
-        val biomes by biomeList { it.filterTemp(0.4f, null) && it.filterRain(0.4f, null) }
-        val shaderWind by boolean(true).lang("shaderWind")
-    }
-
-    object algae {
-        val enabled by featureEnable()
-        val hOffset by double(max=0.25, default=0.1).lang("hOffset")
-        val size by double(min=0.5, max=1.5, default=1.0).lang("size")
-        val heightMin by double(min=0.1, max=1.5, default=0.5).lang("heightMin")
-        val heightMax by double(min=0.1, max=1.5, default=1.0).lang("heightMax")
-        val population by int(max=64, default=48).lang("population")
-        val biomes by biomeList { it.filterClass("river", "ocean") }
-        val shaderWind by boolean(true).lang("shaderWind")
-    }
-
-    object coral {
-        val enabled by featureEnable()
-        val shallowWater by boolean(false)
-        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
-        val vOffset by double(max=0.4, default=0.1).lang("vOffset")
-        val size by double(min=0.5, max=1.5, default=0.7).lang("size")
-        val crustSize by double(min=0.5, max=1.5, default=1.4)
-        val chance by int(max=64, default=32)
-        val population by int(max=64, default=48).lang("population")
-        val biomes by biomeList { it.filterClass("river", "ocean", "beach") }
-    }
-
-    object netherrack {
-        val enabled by featureEnable()
-        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
-        val heightMin by double(min=0.1, max=1.5, default=0.6).lang("heightMin")
-        val heightMax by double(min=0.1, max=1.5, default=0.8).lang("heightMax")
-        val size by double(min=0.5, max=1.5, default=1.0).lang("size")
-    }
-
-    object fallingLeaves {
-        val enabled by featureEnable()
-        val speed by double(min=0.01, max=0.15, default=0.05)
-        val windStrength by double(min=0.1, max=2.0, default=0.5)
-        val stormStrength by double(min=0.1, max=2.0, default=0.8)
-        val size by double(min=0.25, max=1.5, default=0.75).lang("size")
-        val chance by double(min=0.001, max=1.0, default=0.05)
-        val perturb by double(min=0.01, max=1.0, default=0.25)
-        val lifetime by double(min=1.0, max=15.0, default=5.0)
-        val opacityHack by boolean(true)
-    }
-
-    object risingSoul {
-        val enabled by featureEnable()
-        val chance by double(min=0.001, max=1.0, default=0.02)
-        val perturb by double(min=0.01, max=0.25, default=0.05)
-        val headSize by double(min=0.25, max=1.5, default=1.0)
-        val trailSize by double(min=0.25, max=1.5, default=0.75)
-        val opacity by float(min=0.05, max=1.0, default=0.5)
-        val sizeDecay by double(min=0.5, max=1.0, default=0.97)
-        val opacityDecay by float(min=0.5, max=1.0, default=0.97)
-        val lifetime by double(min=1.0, max=15.0, default=4.0)
-        val trailLength by int(min=2, max=128, default=48)
-        val trailDensity by int(min=1, max=16, default=3)
-    }
-
-    val forceReloadOptions = listOf(
-        blocks.leavesClasses,
-        blocks.leavesModels,
-        blocks.grassClasses,
-        blocks.grassModels,
-        shortGrass["saturationThreshold"]!!
-    )
-
-    override fun onChange(event: ConfigChangedEvent.PostConfigChangedEvent) {
-        if (hasChanged(forceReloadOptions))
-            Minecraft.getMinecraft().refreshResources()
-        else
-            Minecraft.getMinecraft().renderGlobal.loadRenderers()
-    }
-}

src/main/kotlin/mods/betterfoliage/client/gui/BiomeListConfigEntry.kt

@@ -1,19 +0,0 @@
-package mods.betterfoliage.client.gui
-
-import mods.octarinecore.client.gui.IdListConfigEntry
-import net.minecraft.world.biome.Biome
-import net.minecraftforge.fml.client.config.GuiConfig
-import net.minecraftforge.fml.client.config.GuiConfigEntries
-import net.minecraftforge.fml.client.config.IConfigElement
-
-/** Toggleable list of all defined biomes. */
-class BiomeListConfigEntry(
-    owningScreen: GuiConfig,
-    owningEntryList: GuiConfigEntries,
-    configElement: IConfigElement)
-: IdListConfigEntry<Biome>(owningScreen, owningEntryList, configElement) {
-
-    override val baseSet: List<Biome> get() = Biome.REGISTRY.filterNotNull()
-    override val Biome.itemId: Int get() = Biome.REGISTRY.getIDForObject(this)
-    override val Biome.itemName: String get() = this.biomeName
-}

src/main/kotlin/mods/betterfoliage/client/gui/ConfigGuiFactory.kt

@@ -1,29 +0,0 @@
-package mods.betterfoliage.client.gui
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.config.Config
-import net.minecraft.client.Minecraft
-import net.minecraft.client.gui.GuiScreen
-import net.minecraftforge.fml.client.IModGuiFactory
-import net.minecraftforge.fml.client.config.GuiConfig
-
-class ConfigGuiFactory : IModGuiFactory {
-
-    override fun initialize(minecraftInstance: Minecraft?) { }
-    override fun hasConfigGui() = true
-    override fun runtimeGuiCategories() = hashSetOf<IModGuiFactory.RuntimeOptionCategoryElement>()
-    override fun createConfigGui(parentScreen: GuiScreen?) = createBFConfigGui(parentScreen)
-
-    companion object {
-        @JvmStatic
-        fun createBFConfigGui(parentScreen: GuiScreen?) = GuiConfig(
-            parentScreen,
-            Config.rootGuiElements,
-            BetterFoliageMod.MOD_ID,
-            null,
-            false,
-            false,
-            BetterFoliageMod.MOD_NAME
-        )
-    }
-}

src/main/kotlin/mods/betterfoliage/client/integration/ForestryIntegration.kt

@@ -1,154 +0,0 @@
-package mods.betterfoliage.client.integration
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.render.LogRegistry
-import mods.betterfoliage.client.render.StandardLogRegistry
-import mods.betterfoliage.client.render.column.ColumnTextureInfo
-import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.betterfoliage.client.texture.LeafInfo
-import mods.betterfoliage.client.texture.LeafRegistry
-import mods.betterfoliage.client.texture.StandardLeafKey
-import mods.betterfoliage.loader.Refs
-import mods.octarinecore.client.resource.ModelRenderKey
-import mods.octarinecore.client.resource.ModelRenderRegistry
-import mods.octarinecore.client.resource.ModelRenderRegistryBase
-import mods.octarinecore.getTileEntitySafe
-import mods.octarinecore.metaprog.ClassRef
-import mods.octarinecore.metaprog.FieldRef
-import mods.octarinecore.metaprog.MethodRef
-import mods.octarinecore.metaprog.allAvailable
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.Minecraft
-import net.minecraft.client.renderer.block.model.ModelResourceLocation
-import net.minecraft.util.ResourceLocation
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraftforge.client.event.TextureStitchEvent
-import net.minecraftforge.client.model.IModel
-import net.minecraftforge.fml.common.Loader
-import net.minecraftforge.fml.common.eventhandler.EventPriority
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
-import kotlin.collections.Map
-import kotlin.collections.component1
-import kotlin.collections.component2
-import kotlin.collections.emptyMap
-import kotlin.collections.find
-import kotlin.collections.forEach
-import kotlin.collections.get
-import kotlin.collections.listOf
-import kotlin.collections.mapValues
-import kotlin.collections.mutableMapOf
-import kotlin.collections.set
-
-@SideOnly(Side.CLIENT)
-object ForestryIntegration {
-
-    val TextureLeaves = ClassRef("forestry.arboriculture.models.TextureLeaves")
-    val TeLleafTextures = FieldRef(TextureLeaves, "leafTextures", Refs.Map)
-    val TeLplain = FieldRef(TextureLeaves, "plain", Refs.ResourceLocation)
-    val TeLfancy = FieldRef(TextureLeaves, "fancy", Refs.ResourceLocation)
-    val TeLpollplain = FieldRef(TextureLeaves, "pollinatedPlain", Refs.ResourceLocation)
-    val TeLpollfancy = FieldRef(TextureLeaves, "pollinatedFancy", Refs.ResourceLocation)
-    val TileLeaves = ClassRef("forestry.arboriculture.tiles.TileLeaves")
-    val TiLgetLeaveSprite = MethodRef(TileLeaves, "getLeaveSprite", Refs.ResourceLocation, ClassRef.boolean)
-
-    val PropertyWoodType = ClassRef("forestry.arboriculture.blocks.PropertyWoodType")
-    val IWoodType = ClassRef("forestry.api.arboriculture.IWoodType")
-    val barkTex = MethodRef(IWoodType, "getBarkTexture", Refs.String)
-    val heartTex = MethodRef(IWoodType, "getHeartTexture", Refs.String)
-
-    val PropertyTreeType = ClassRef("forestry.arboriculture.blocks.PropertyTreeType")
-    val TreeDefinition = ClassRef("forestry.arboriculture.genetics.TreeDefinition")
-    val IAlleleTreeSpecies = ClassRef("forestry.api.arboriculture.IAlleleTreeSpecies")
-    val ILeafSpriteProvider = ClassRef("forestry.api.arboriculture.ILeafSpriteProvider")
-    val TdSpecies = FieldRef(TreeDefinition, "species", IAlleleTreeSpecies)
-    val getLeafSpriteProvider = MethodRef(IAlleleTreeSpecies, "getLeafSpriteProvider", ILeafSpriteProvider)
-    val getSprite = MethodRef(ILeafSpriteProvider, "getSprite", Refs.ResourceLocation, ClassRef.boolean, ClassRef.boolean)
-
-    init {
-        if (Loader.isModLoaded("forestry") && allAvailable(TiLgetLeaveSprite, getLeafSpriteProvider, getSprite)) {
-            Client.log(Level.INFO, "Forestry support initialized")
-            LeafRegistry.addRegistry(ForestryLeafRegistry)
-            LogRegistry.addRegistry(ForestryLogRegistry)
-        }
-    }
-}
-
-object ForestryLeafRegistry : ModelRenderRegistry<LeafInfo> {
-    val logger = BetterFoliageMod.logDetail
-    val textureToKey = mutableMapOf<ResourceLocation, ModelRenderKey<LeafInfo>>()
-    var textureToValue = emptyMap<ResourceLocation, LeafInfo>()
-
-    override fun get(state: IBlockState, world: IBlockAccess, pos: BlockPos): LeafInfo? {
-        // check variant property (used in decorative leaves)
-        state.properties.entries.find {
-            ForestryIntegration.PropertyTreeType.isInstance(it.key) && ForestryIntegration.TreeDefinition.isInstance(it.value)
-        } ?.let {
-            val species = ForestryIntegration.TdSpecies.get(it.value)
-            val spriteProvider = ForestryIntegration.getLeafSpriteProvider.invoke(species!!)
-            val textureLoc = ForestryIntegration.getSprite.invoke(spriteProvider!!, false, Minecraft.isFancyGraphicsEnabled())
-            return textureToValue[textureLoc]
-        }
-
-        // extract leaf texture information from TileEntity
-        val tile = world.getTileEntitySafe(pos) ?: return null
-        if (!ForestryIntegration.TileLeaves.isInstance(tile)) return null
-        val textureLoc = ForestryIntegration.TiLgetLeaveSprite.invoke(tile, Minecraft.isFancyGraphicsEnabled()) ?: return null
-        return textureToValue[textureLoc]
-    }
-
-    @SubscribeEvent
-    fun handlePreStitch(event: TextureStitchEvent.Pre) {
-        textureToValue = emptyMap()
-
-        val allLeaves = ForestryIntegration.TeLleafTextures.getStatic() as Map<*, *>
-        allLeaves.entries.forEach {
-            logger.log(Level.DEBUG, "ForestryLeavesSupport: base leaf type ${it.key.toString()}")
-            listOf(
-                ForestryIntegration.TeLplain.get(it.value) as ResourceLocation,
-                ForestryIntegration.TeLfancy.get(it.value) as ResourceLocation,
-                ForestryIntegration.TeLpollplain.get(it.value) as ResourceLocation,
-                ForestryIntegration.TeLpollfancy.get(it.value) as ResourceLocation
-            ).forEach { textureLocation ->
-                val key = StandardLeafKey(logger, textureLocation.toString()).apply { onPreStitch(event.map) }
-                textureToKey[textureLocation] = key
-            }
-        }
-    }
-
-    @SubscribeEvent(priority = EventPriority.LOW)
-    fun handlePostStitch(event: TextureStitchEvent.Post) {
-        textureToValue = textureToKey.mapValues { (_, key) -> key.resolveSprites(event.map) }
-        textureToKey.clear()
-    }
-}
-
-object ForestryLogRegistry : ModelRenderRegistryBase<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-
-    override fun processModel(state: IBlockState, modelLoc: ModelResourceLocation, model: IModel): ModelRenderKey<ColumnTextureInfo>? {
-        // respect class list to avoid triggering on fences, stairs, etc.
-        if (!Config.blocks.logClasses.matchesClass(state.block)) return null
-
-        // find wood type property
-        val woodType = state.properties.entries.find {
-            ForestryIntegration.PropertyWoodType.isInstance(it.key) && ForestryIntegration.IWoodType.isInstance(it.value)
-        } ?: return null
-
-        logger.log(Level.DEBUG, "ForestryLogRegistry: block state $state")
-        logger.log(Level.DEBUG, "ForestryLogRegistry:     variant ${woodType.value}")
-
-        // get texture names for wood type
-        val bark = ForestryIntegration.barkTex.invoke(woodType.value) as String?
-        val heart = ForestryIntegration.heartTex.invoke(woodType.value) as String?
-
-        logger.log(Level.DEBUG, "ForestryLogSupport:    textures [heart=$heart, bark=$bark]")
-        if (bark != null && heart != null) return SimpleColumnInfo.Key(logger, StandardLogRegistry.getAxis(state), listOf(heart, heart, bark))
-        return null
-    }
-}

src/main/kotlin/mods/betterfoliage/client/integration/OptifineCustomColors.kt

@@ -1,60 +0,0 @@
-package mods.betterfoliage.client.integration
-
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.loader.Refs
-import mods.octarinecore.ThreadLocalDelegate
-import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.common.Int3
-import mods.octarinecore.metaprog.allAvailable
-import mods.octarinecore.metaprog.reflectField
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.Minecraft
-import net.minecraft.client.renderer.block.model.BakedQuad
-import net.minecraft.client.renderer.vertex.DefaultVertexFormats
-import net.minecraft.util.EnumFacing
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
-
-/**
- * Integration for OptiFine custom block colors.
- */
-@Suppress("UNCHECKED_CAST")
-@SideOnly(Side.CLIENT)
-object OptifineCustomColors {
-
-    val isColorAvailable = allAvailable(
-        Refs.CustomColors, Refs.getColorMultiplier
-    )
-
-    init {
-        Client.log(Level.INFO, "Optifine custom color support is ${if (isColorAvailable) "enabled" else "disabled" }")
-    }
-
-    val renderEnv by ThreadLocalDelegate { OptifineRenderEnv() }
-    val fakeQuad = BakedQuad(IntArray(0), 1, EnumFacing.UP, null, true, DefaultVertexFormats.BLOCK)
-
-    fun getBlockColor(ctx: BlockContext): Int {
-        val ofColor = if (isColorAvailable && Minecraft.getMinecraft().gameSettings.reflectField<Boolean>("ofCustomColors") == true) {
-            renderEnv.reset(ctx.blockState(Int3.zero), ctx.pos)
-            Refs.getColorMultiplier.invokeStatic(fakeQuad, ctx.blockState(Int3.zero), ctx.world!!, ctx.pos, renderEnv.wrapped) as? Int
-        } else null
-        return if (ofColor == null || ofColor == -1) ctx.blockData(Int3.zero).color else ofColor
-    }
-}
-
-@SideOnly(Side.CLIENT)
-class OptifineRenderEnv {
-    val wrapped: Any = Refs.RenderEnv.element!!.getDeclaredConstructor(
-        Refs.IBlockState.element, Refs.BlockPos.element
-    ).let {
-        it.isAccessible = true
-        it.newInstance(null, null)
-    }
-
-    fun reset(state: IBlockState, pos: BlockPos) {
-        Refs.RenderEnv_reset.invoke(wrapped, state, pos)
-    }
-}

src/main/kotlin/mods/betterfoliage/client/integration/RubberIntegration.kt

@@ -1,147 +0,0 @@
-package mods.betterfoliage.client.integration
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.render.LogRegistry
-import mods.betterfoliage.client.render.column.ColumnTextureInfo
-import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.octarinecore.client.render.Quad
-import mods.octarinecore.client.render.QuadIconResolver
-import mods.octarinecore.client.render.ShadingContext
-import mods.octarinecore.client.render.blockContext
-import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.rotate
-import mods.octarinecore.metaprog.ClassRef
-import mods.octarinecore.metaprog.allAvailable
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.renderer.block.model.ModelResourceLocation
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.client.renderer.texture.TextureMap
-import net.minecraft.util.EnumFacing
-import net.minecraft.util.ResourceLocation
-import net.minecraftforge.client.model.IModel
-import net.minecraftforge.fml.common.Loader
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
-import org.apache.logging.log4j.Logger
-
-@SideOnly(Side.CLIENT)
-object IC2RubberIntegration {
-
-    val BlockRubWood = ClassRef("ic2.core.block.BlockRubWood")
-
-    init {
-        if (Loader.isModLoaded("ic2") && allAvailable(BlockRubWood)) {
-            Client.log(Level.INFO, "IC2 rubber support initialized")
-            LogRegistry.addRegistry(IC2LogSupport)
-        }
-    }
-}
-
-@SideOnly(Side.CLIENT)
-object TechRebornRubberIntegration {
-
-    val BlockRubberLog = ClassRef("techreborn.blocks.BlockRubberLog")
-
-    init {
-        if (Loader.isModLoaded("techreborn") && allAvailable(BlockRubberLog)) {
-            Client.log(Level.INFO, "TechReborn rubber support initialized")
-            LogRegistry.addRegistry(TechRebornLogSupport)
-        }
-    }
-}
-
-class RubberLogInfo(
-    axis: EnumFacing.Axis?,
-    val spotDir: EnumFacing,
-    topTexture: TextureAtlasSprite,
-    bottomTexture: TextureAtlasSprite,
-    val spotTexture: TextureAtlasSprite,
-    sideTextures: List<TextureAtlasSprite>
-) : SimpleColumnInfo(axis, topTexture, bottomTexture, sideTextures) {
-
-    override val side: QuadIconResolver = { ctx: ShadingContext, idx: Int, quad: Quad ->
-        val worldFace = (if ((idx and 1) == 0) EnumFacing.SOUTH else EnumFacing.EAST).rotate(ctx.rotation)
-        if (worldFace == spotDir) spotTexture else {
-            val sideIdx = if (this.sideTextures.size > 1) (blockContext.random(1) + dirToIdx[worldFace.ordinal]) % this.sideTextures.size else 0
-            this.sideTextures[sideIdx]
-        }
-    }
-
-    class Key(override val logger: Logger, val axis: EnumFacing.Axis?, val spotDir: EnumFacing, val textures: List<String>): ModelRenderKey<ColumnTextureInfo> {
-        override fun resolveSprites(atlas: TextureMap) = RubberLogInfo(
-            axis,
-            spotDir,
-            atlas[textures[0]] ?: atlas.missingSprite,
-            atlas[textures[1]] ?: atlas.missingSprite,
-            atlas[textures[2]] ?: atlas.missingSprite,
-            textures.drop(3).map { atlas[it] ?: atlas.missingSprite }
-        )
-    }
-}
-
-object IC2LogSupport : ModelRenderRegistryBase<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-
-    override fun processModel(state: IBlockState, modelLoc: ModelResourceLocation, model: IModel): ModelRenderKey<ColumnTextureInfo>? {
-        // check for proper block class, existence of ModelBlock, and "state" blockstate property
-        if (!IC2RubberIntegration.BlockRubWood.isInstance(state.block)) return null
-        val blockLoc = model.modelBlockAndLoc.firstOrNull() ?: return null
-        val type = state.properties.entries.find { it.key.getName() == "state" }?.value?.toString() ?: return null
-
-        // logs with no rubber spot
-        if (blockLoc.derivesFrom(ResourceLocation("block/cube_column"))) {
-            val axis = when(type) {
-                "plain_y" -> EnumFacing.Axis.Y
-                "plain_x" -> EnumFacing.Axis.X
-                "plain_z" -> EnumFacing.Axis.Z
-                else -> null
-            }
-            val textureNames = listOf("end", "end", "side").map { blockLoc.first.resolveTextureName(it) }
-            if (textureNames.any { it == "missingno" }) return null
-            logger.log(Level.DEBUG, "IC2LogSupport: block state ${state.toString()}")
-            logger.log(Level.DEBUG, "IC2LogSupport:             axis=$axis, end=${textureNames[0]}, side=${textureNames[2]}")
-            return SimpleColumnInfo.Key(logger, axis, textureNames)
-        }
-
-        // logs with rubber spot
-        val spotDir = when(type) {
-            "dry_north", "wet_north" -> EnumFacing.NORTH
-            "dry_south", "wet_south" -> EnumFacing.SOUTH
-            "dry_west", "wet_west" -> EnumFacing.WEST
-            "dry_east", "wet_east" -> EnumFacing.EAST
-            else -> null
-        }
-        val textureNames = listOf("up", "down", "north", "south").map { blockLoc.first.resolveTextureName(it) }
-        if (textureNames.any { it == "missingno" }) return null
-        logger.log(Level.DEBUG, "IC2LogSupport: block state ${state.toString()}")
-        logger.log(Level.DEBUG, "IC2LogSupport:             spotDir=$spotDir, up=${textureNames[0]}, down=${textureNames[1]}, side=${textureNames[2]}, spot=${textureNames[3]}")
-        return if (spotDir != null) RubberLogInfo.Key(logger, EnumFacing.Axis.Y, spotDir, textureNames) else SimpleColumnInfo.Key(logger, EnumFacing.Axis.Y, textureNames)
-    }
-}
-
-object TechRebornLogSupport : ModelRenderRegistryBase<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-
-    override fun processModel(state: IBlockState, modelLoc: ModelResourceLocation, model: IModel): ModelRenderKey<ColumnTextureInfo>? {
-        // check for proper block class, existence of ModelBlock
-        if (!TechRebornRubberIntegration.BlockRubberLog.isInstance(state.block)) return null
-        val blockLoc = model.modelBlockAndLoc.firstOrNull() ?: return null
-
-        val hasSap = state.properties.entries.find { it.key.getName() == "hassap" }?.value as? Boolean ?: return null
-        val sapSide = state.properties.entries.find { it.key.getName() == "sapside" }?.value as? EnumFacing ?: return null
-
-        logger.log(Level.DEBUG, "$logName: block state $state")
-        if (hasSap) {
-            val textureNames = listOf("end", "end", "sapside", "side").map { blockLoc.first.resolveTextureName(it) }
-            logger.log(Level.DEBUG, "$logName:             spotDir=$sapSide, end=${textureNames[0]}, side=${textureNames[2]}, spot=${textureNames[3]}")
-            if (textureNames.all { it != "missingno" }) return RubberLogInfo.Key(logger, EnumFacing.Axis.Y, sapSide, textureNames)
-        } else {
-            val textureNames = listOf("end", "end", "side").map { blockLoc.first.resolveTextureName(it) }
-            logger.log(Level.DEBUG, "$logName:             end=${textureNames[0]}, side=${textureNames[2]}")
-            if (textureNames.all { it != "missingno" })return SimpleColumnInfo.Key(logger, EnumFacing.Axis.Y, textureNames)
-        }
-        return null
-    }
-}

src/main/kotlin/mods/betterfoliage/client/integration/ShadersModIntegration.kt

@@ -1,81 +0,0 @@
-package mods.betterfoliage.client.integration
-
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.loader.Refs
-import mods.octarinecore.metaprog.allAvailable
-import net.minecraft.block.Block
-import net.minecraft.block.BlockTallGrass
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.init.Blocks
-import net.minecraft.util.EnumBlockRenderType
-import net.minecraft.util.EnumBlockRenderType.MODEL
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
-
-/**
- * Integration for ShadersMod.
- */
-@SideOnly(Side.CLIENT)
-object ShadersModIntegration {
-
-    @JvmStatic val isAvailable = allAvailable(Refs.sVertexBuilder, Refs.pushEntity_state, Refs.pushEntity_num, Refs.popEntity)
-
-    val grassDefaultBlockId = blockIdFor(Blocks.TALLGRASS.defaultState.withProperty(BlockTallGrass.TYPE, BlockTallGrass.EnumType.GRASS))
-    val leavesDefaultBlockId = blockIdFor(Blocks.LEAVES.defaultState)
-    fun blockIdFor(blockState: IBlockState) = Block.REGISTRY.getIDForObject(blockState.block).toLong() and 65535
-
-//    fun entityDataFor(blockState: IBlockState) =
-//        (Block.REGISTRY.getIDForObject(blockState.block).toLong() and 65535) //or
-//        ((blockState.renderType.ordinal.toLong() and 65535) shl 16) or
-//        (blockState.block.getMetaFromState(blockState).toLong() shl 32)
-
-    fun logEntityData(name: String, blockState: IBlockState) {
-        val blockId = Block.REGISTRY.getIDForObject(blockState.block).toLong() and 65535
-        val meta = blockState.renderType.ordinal.toLong() and 65535
-        val renderType = blockState.renderType.ordinal.toLong() and 65535
-        Client.log(INFO, "ShadersMod integration for $name")
-        Client.log(INFO, "     blockState=$blockState")
-        Client.log(INFO, "     blockId=$blockId, meta=$meta, type=$renderType")
-    }
-    /**
-     * Called from transformed ShadersMod code.
-     * @see mods.betterfoliage.loader.BetterFoliageTransformer
-     */
-    @JvmStatic fun getBlockIdOverride(original: Long, blockState: IBlockState): Long {
-        if (Config.blocks.leavesClasses.matchesClass(blockState.block)) return Config.shaders.leavesId
-        if (Config.blocks.crops.matchesClass(blockState.block)) return Config.shaders.grassId
-        return original
-    }
-
-    init {
-        Client.log(INFO, "ShadersMod integration is ${if (isAvailable) "enabled" else "disabled" }")
-    }
-
-    /** Quads rendered inside this block will use the given block entity data in shader programs. */
-    inline fun renderAs(blockId: Long, renderType: EnumBlockRenderType, renderer: BufferBuilder, enabled: Boolean = true, func: ()->Unit) {
-        val blockData = blockId or (renderType.ordinal shl 16).toLong()
-        if ((isAvailable && enabled)) {
-            val vertexBuilder = Refs.sVertexBuilder.get(renderer)!!
-            Refs.pushEntity_num.invoke(vertexBuilder, blockId)
-            func()
-            Refs.popEntity.invoke(vertexBuilder)
-        } else {
-            func()
-        }
-    }
-
-    /** Quads rendered inside this block will use the given block entity data in shader programs. */
-    inline fun renderAs(state: IBlockState, renderType: EnumBlockRenderType, renderer: BufferBuilder, enabled: Boolean = true, func: ()->Unit) =
-        renderAs(blockIdFor(state), renderType, renderer, enabled, func)
-
-    /** Quads rendered inside this block will behave as tallgrass blocks in shader programs. */
-    inline fun grass(renderer: BufferBuilder, enabled: Boolean = true, func: ()->Unit) =
-        renderAs(Config.shaders.grassId, MODEL, renderer, enabled, func)
-
-    /** Quads rendered inside this block will behave as leaf blocks in shader programs. */
-    inline fun leaves(renderer: BufferBuilder, enabled: Boolean = true, func: ()->Unit) =
-        renderAs(Config.shaders.leavesId, MODEL, renderer, enabled, func)
-}

src/main/kotlin/mods/betterfoliage/client/render/EntityFallingLeavesFX.kt

@@ -1,136 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.texture.LeafParticleRegistry
-import mods.betterfoliage.client.texture.LeafRegistry
-import mods.octarinecore.PI2
-import mods.octarinecore.client.render.AbstractEntityFX
-import mods.octarinecore.client.render.HSB
-import mods.octarinecore.common.Double3
-import mods.octarinecore.minmax
-import mods.octarinecore.random
-import net.minecraft.client.Minecraft
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.math.BlockPos
-import net.minecraft.util.math.MathHelper
-import net.minecraft.world.World
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.event.world.WorldEvent
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
-import net.minecraftforge.fml.common.gameevent.TickEvent
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.lwjgl.opengl.GL11
-import java.lang.Math.*
-import java.util.*
-
-@SideOnly(Side.CLIENT)
-class EntityFallingLeavesFX(world: World, pos: BlockPos) :
-AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble(), pos.z.toDouble() + 0.5) {
-
-    companion object {
-        @JvmStatic val biomeBrightnessMultiplier = 0.5f
-    }
-
-    var particleRot = rand.nextInt(64)
-    var rotPositive = true
-    val isMirrored = (rand.nextInt() and 1) == 1
-    var wasCollided = false
-
-    init {
-        particleMaxAge = MathHelper.floor(random(0.6, 1.0) * Config.fallingLeaves.lifetime * 20.0)
-        motionY = -Config.fallingLeaves.speed
-        particleScale = Config.fallingLeaves.size.toFloat() * 0.1f
-
-        val state = world.getBlockState(pos)
-        val blockColor = Minecraft.getMinecraft().blockColors.colorMultiplier(state, world, pos, 0)
-        val leafInfo = LeafRegistry[state, world, pos]
-        if (leafInfo != null) {
-            particleTexture = leafInfo.particleTextures[rand.nextInt(1024)]
-            calculateParticleColor(leafInfo.averageColor, blockColor)
-        } else {
-            particleTexture = LeafParticleRegistry["default"][rand.nextInt(1024)]
-            setColor(blockColor)
-        }
-    }
-
-    override val isValid: Boolean get() = (particleTexture != null)
-
-    override fun update() {
-        if (rand.nextFloat() > 0.95f) rotPositive = !rotPositive
-        if (particleAge > particleMaxAge - 20) particleAlpha = 0.05f * (particleMaxAge - particleAge)
-
-        if (onGround || wasCollided) {
-            velocity.setTo(0.0, 0.0, 0.0)
-            if (!wasCollided) {
-                particleAge = Math.max(particleAge, particleMaxAge - 20)
-                wasCollided = true
-            }
-        } else {
-            velocity.setTo(cos[particleRot], 0.0, sin[particleRot]).mul(Config.fallingLeaves.perturb)
-                    .add(LeafWindTracker.current).add(0.0, -1.0, 0.0).mul(Config.fallingLeaves.speed)
-            particleRot = (particleRot + (if (rotPositive) 1 else -1)) and 63
-        }
-    }
-
-    override fun render(worldRenderer: BufferBuilder, partialTickTime: Float) {
-        if (Config.fallingLeaves.opacityHack) GL11.glDepthMask(true)
-        renderParticleQuad(worldRenderer, partialTickTime, rotation = particleRot, isMirrored = isMirrored)
-    }
-
-    fun calculateParticleColor(textureAvgColor: Int, blockColor: Int) {
-        val texture = HSB.fromColor(textureAvgColor)
-        val block = HSB.fromColor(blockColor)
-
-        val weightTex = texture.saturation / (texture.saturation + block.saturation)
-        val weightBlock = 1.0f - weightTex
-
-        // avoid circular average for hue for performance reasons
-        // one of the color components should dominate anyway
-        val particle = HSB(
-            weightTex * texture.hue + weightBlock * block.hue,
-            weightTex * texture.saturation + weightBlock * block.saturation,
-            weightTex * texture.brightness + weightBlock * block.brightness * biomeBrightnessMultiplier
-        )
-        setColor(particle.asColor)
-    }
-}
-
-@SideOnly(Side.CLIENT)
-object LeafWindTracker {
-    var random = Random()
-    val target = Double3.zero
-    val current = Double3.zero
-    var nextChange: Long = 0
-
-    init {
-        MinecraftForge.EVENT_BUS.register(this)
-    }
-
-    fun changeWind(world: World) {
-        nextChange = world.worldInfo.worldTime + 120 + random.nextInt(80)
-        val direction = PI2 * random.nextDouble()
-        val speed = abs(random.nextGaussian()) * Config.fallingLeaves.windStrength +
-            (if (!world.isRaining) 0.0 else abs(random.nextGaussian()) * Config.fallingLeaves.stormStrength)
-        target.setTo(cos(direction) * speed, 0.0, sin(direction) * speed)
-    }
-
-    @SubscribeEvent
-    fun handleWorldTick(event: TickEvent.ClientTickEvent) {
-        if (event.phase == TickEvent.Phase.START) Minecraft.getMinecraft().world?.let { world ->
-            // change target wind speed
-            if (world.worldInfo.worldTime >= nextChange) changeWind(world)
-
-            // change current wind speed
-            val changeRate = if (world.isRaining) 0.015 else 0.005
-            current.add(
-                (target.x - current.x).minmax(-changeRate, changeRate),
-                0.0,
-                (target.z - current.z).minmax(-changeRate, changeRate)
-            )
-        }
-    }
-
-    @SubscribeEvent
-    fun handleWorldLoad(event: WorldEvent.Load) { if (event.world.isRemote) changeWind(event.world) }
-}

src/main/kotlin/mods/betterfoliage/client/render/EntityRisingSoulFX.kt

@@ -1,77 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.AbstractEntityFX
-import mods.octarinecore.client.resource.ResourceHandler
-import mods.octarinecore.common.Double3
-import mods.octarinecore.forEachPairIndexed
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.math.BlockPos
-import net.minecraft.util.math.MathHelper
-import net.minecraft.world.World
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
-import java.util.*
-
-@SideOnly(Side.CLIENT)
-class EntityRisingSoulFX(world: World, pos: BlockPos) :
-AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.toDouble() + 0.5) {
-
-    val particleTrail: Deque<Double3> = LinkedList<Double3>()
-    val initialPhase = rand.nextInt(64)
-
-    init {
-        motionY = 0.1
-        particleGravity = 0.0f
-        particleTexture = RisingSoulTextures.headIcons[rand.nextInt(256)]
-        particleMaxAge = MathHelper.floor((0.6 + 0.4 * rand.nextDouble()) * Config.risingSoul.lifetime * 20.0)
-    }
-
-    override val isValid: Boolean get() = true
-
-    override fun update() {
-        val phase = (initialPhase + particleAge) % 64
-        velocity.setTo(cos[phase] * Config.risingSoul.perturb, 0.1, sin[phase] * Config.risingSoul.perturb)
-
-        particleTrail.addFirst(currentPos.copy())
-        while (particleTrail.size > Config.risingSoul.trailLength) particleTrail.removeLast()
-
-        if (!Config.enabled) setExpired()
-    }
-
-    override fun render(worldRenderer: BufferBuilder, partialTickTime: Float) {
-        var alpha = Config.risingSoul.opacity
-        if (particleAge > particleMaxAge - 40) alpha *= (particleMaxAge - particleAge) / 40.0f
-
-        renderParticleQuad(worldRenderer, partialTickTime,
-            size = Config.risingSoul.headSize * 0.25,
-            alpha = alpha
-        )
-
-        var scale = Config.risingSoul.trailSize * 0.25
-        particleTrail.forEachPairIndexed { idx, current, previous ->
-            scale *= Config.risingSoul.sizeDecay
-            alpha *= Config.risingSoul.opacityDecay
-            if (idx % Config.risingSoul.trailDensity == 0) renderParticleQuad(worldRenderer, partialTickTime,
-                currentPos = current,
-                prevPos = previous,
-                size = scale,
-                alpha = alpha,
-                icon = RisingSoulTextures.trackIcon.icon!!
-            )
-        }
-    }
-}
-
-@SideOnly(Side.CLIENT)
-object RisingSoulTextures : ResourceHandler(BetterFoliageMod.MOD_ID) {
-    val headIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/rising_soul_%d")
-    val trackIcon = iconStatic(BetterFoliageMod.LEGACY_DOMAIN, "blocks/soul_track")
-
-    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${headIcons.num} soul particle textures")
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/ModelColumn.kt

@@ -1,146 +0,0 @@
-@file:JvmName("ModelColumn")
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.*
-import mods.octarinecore.common.Double3
-import mods.octarinecore.exchange
-import net.minecraft.util.EnumFacing.*
-import org.lwjgl.opengl.GL11
-
-/** Weight of the same-side AO values on the outer edges of the 45deg chamfered column faces. */
-const val chamferAffinity = 0.9f
-
-/** Amount to shrink column extension bits to stop Z-fighting. */
-val zProtectionScale: Double3 get() = Double3(Config.roundLogs.zProtection, 1.0, Config.roundLogs.zProtection)
-
-fun Model.columnSide(radius: Double, yBottom: Double, yTop: Double, transform: (Quad) -> Quad = { it }) {
-    val halfRadius = radius * 0.5
-    listOf(
-        verticalRectangle(x1 = 0.0, z1 = 0.5, x2 = 0.5 - radius, z2 = 0.5, yBottom = yBottom, yTop = yTop)
-        .clampUV(minU = 0.0, maxU = 0.5 - radius)
-        .setAoShader(faceOrientedInterpolate(overrideFace = SOUTH))
-        .setAoShader(faceOrientedAuto(corner = cornerAo(Axis.Y)), predicate = { v, vi -> vi == 1 || vi == 2}),
-
-        verticalRectangle(x1 = 0.5 - radius, z1 = 0.5, x2 = 0.5 - halfRadius, z2 = 0.5 - halfRadius, yBottom = yBottom, yTop = yTop)
-        .clampUV(minU = 0.5 - radius)
-        .setAoShader(
-            faceOrientedAuto(overrideFace = SOUTH, corner = cornerInterpolate(Axis.Y, chamferAffinity, Config.roundLogs.dimming))
-        )
-        .setAoShader(
-            faceOrientedAuto(overrideFace = SOUTH, corner = cornerInterpolate(Axis.Y, 0.5f, Config.roundLogs.dimming)),
-            predicate = { v, vi -> vi == 1 || vi == 2}
-        )
-    ).forEach { transform(it.setFlatShader(FaceFlat(SOUTH))).add() }
-
-    listOf(
-        verticalRectangle(x1 = 0.5 - halfRadius, z1 = 0.5 - halfRadius, x2 = 0.5, z2 = 0.5 - radius, yBottom = yBottom, yTop = yTop)
-        .clampUV(maxU = radius - 0.5)
-        .setAoShader(
-            faceOrientedAuto(overrideFace = EAST, corner = cornerInterpolate(Axis.Y, chamferAffinity, Config.roundLogs.dimming)))
-        .setAoShader(
-            faceOrientedAuto(overrideFace = EAST, corner = cornerInterpolate(Axis.Y, 0.5f, Config.roundLogs.dimming)),
-            predicate = { v, vi -> vi == 0 || vi == 3}
-        ),
-
-        verticalRectangle(x1 = 0.5, z1 = 0.5 - radius, x2 = 0.5, z2 = 0.0, yBottom = yBottom, yTop = yTop)
-        .clampUV(minU = radius - 0.5, maxU = 0.0)
-        .setAoShader(faceOrientedInterpolate(overrideFace = EAST))
-        .setAoShader(faceOrientedAuto(corner = cornerAo(Axis.Y)), predicate = { v, vi -> vi == 0 || vi == 3})
-    ).forEach { transform(it.setFlatShader(FaceFlat(EAST))).add() }
-
-    quads.exchange(1, 2)
-}
-
-/**
- * Create a model of the side of a square column quadrant.
- *
- * @param[transform] transformation to apply to the model
- */
-fun Model.columnSideSquare(yBottom: Double, yTop: Double, transform: (Quad) -> Quad = { it }) {
-    listOf(
-        verticalRectangle(x1 = 0.0, z1 = 0.5, x2 = 0.5, z2 = 0.5, yBottom = yBottom, yTop = yTop)
-        .clampUV(minU = 0.0)
-        .setAoShader(faceOrientedInterpolate(overrideFace = SOUTH))
-        .setAoShader(faceOrientedAuto(corner = cornerAo(Axis.Y)), predicate = { v, vi -> vi == 1 || vi == 2}),
-
-        verticalRectangle(x1 = 0.5, z1 = 0.5, x2 = 0.5, z2 = 0.0, yBottom = yBottom, yTop = yTop)
-        .clampUV(maxU = 0.0)
-        .setAoShader(faceOrientedInterpolate(overrideFace = EAST))
-        .setAoShader(faceOrientedAuto(corner = cornerAo(Axis.Y)), predicate = { v, vi -> vi == 0 || vi == 3})
-    ).forEach {
-        transform(it.setFlatShader(faceOrientedAuto(corner = cornerFlat))).add()
-    }
-}
-
-/**
- * Create a model of the top lid of a chamfered column quadrant.
- *
- * @param[radius] the chamfer radius
- * @param[transform] transformation to apply to the model
- */
-fun Model.columnLid(radius: Double, transform: (Quad)->Quad = { it }) {
-    val v1 = Vertex(Double3(0.0, 0.5, 0.0), UV(0.0, 0.0))
-    val v2 = Vertex(Double3(0.0, 0.5, 0.5), UV(0.0, 0.5))
-    val v3 = Vertex(Double3(0.5 - radius, 0.5, 0.5), UV(0.5 - radius, 0.5))
-    val v4 = Vertex(Double3(0.5 - radius * 0.5, 0.5, 0.5 - radius * 0.5), UV(0.5, 0.5))
-    val v5 = Vertex(Double3(0.5, 0.5, 0.5 - radius), UV(0.5, 0.5 - radius))
-    val v6 = Vertex(Double3(0.5, 0.5, 0.0), UV(0.5, 0.0))
-
-    val q1 = Quad(v1, v2, v3, v4).setAoShader(faceOrientedAuto(overrideFace = UP, corner = cornerAo(Axis.Y)))
-             .transformVI { vertex, idx -> vertex.copy(aoShader = when(idx) {
-                 0 -> FaceCenter(UP)
-                 1 -> EdgeInterpolateFallback(UP, SOUTH, 0.0)
-                 else -> vertex.aoShader
-             })}
-             .cycleVertices(if (Config.nVidia) 0 else 1)
-    val q2 = Quad(v1, v4, v5, v6).setAoShader(faceOrientedAuto(overrideFace = UP, corner = cornerAo(Axis.Y)))
-             .transformVI { vertex, idx -> vertex.copy(aoShader = when(idx) {
-                 0 -> FaceCenter(UP)
-                 3 -> EdgeInterpolateFallback(UP, EAST, 0.0)
-                 else -> vertex.aoShader
-             })}
-             .cycleVertices(if (Config.nVidia) 0 else 1)
-    listOf(q1, q2).forEach { transform(it.setFlatShader(FaceFlat(UP))).add() }
-}
-
-/**
- * Create a model of the top lid of a square column quadrant.
- *
- * @param[transform] transformation to apply to the model
- */
-fun Model.columnLidSquare(transform: (Quad)-> Quad = { it }) {
-    transform(
-        horizontalRectangle(x1 = 0.0, x2 = 0.5, z1 = 0.0, z2 = 0.5, y = 0.5)
-        .transformVI { vertex, idx -> vertex.copy(uv = UV(vertex.xyz.x, vertex.xyz.z), aoShader = when(idx) {
-            0 -> FaceCenter(UP)
-            1 -> EdgeInterpolateFallback(UP, SOUTH, 0.0)
-            2 -> CornerSingleFallback(UP, SOUTH, EAST, UP)
-            else -> EdgeInterpolateFallback(UP, EAST, 0.0)
-        }) }
-        .setFlatShader(FaceFlat(UP))
-    ).add()
-}
-
-/**
- * Transform a chamfered side quadrant model of a column that extends from the top of the block.
- * (clamp UV coordinates, apply some scaling to avoid Z-fighting).
- *
- * @param[size] amount that the model extends from the top
- */
-fun topExtension(size: Double) = { q: Quad ->
-    q.clampUV(minV = 0.5 - size).transformVI { vertex, idx ->
-        if (idx < 2) vertex else vertex.copy(xyz = vertex.xyz * zProtectionScale)
-    }
-}
-/**
- * Transform a chamfered side quadrant model of a column that extends from the bottom of the block.
- * (clamp UV coordinates, apply some scaling to avoid Z-fighting).
- *
- * @param[size] amount that the model extends from the bottom
- */
-fun bottomExtension(size: Double) = { q: Quad ->
-    q.clampUV(maxV = -0.5 + size).transformVI { vertex, idx ->
-        if (idx > 1) vertex else vertex.copy(xyz = vertex.xyz * zProtectionScale)
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderAlgae.kt

@@ -1,57 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.octarinecore.client.render.*
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.Rotation
-import net.minecraft.block.material.Material
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
-
-@SideOnly(Side.CLIENT)
-class RenderAlgae : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    val noise = simplexNoise()
-
-    val algaeIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_algae_%d")
-    val algaeModels = modelSet(64, RenderGrass.grassTopQuads(Config.algae.heightMin, Config.algae.heightMax))
-
-    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${algaeIcons.num} algae textures")
-    }
-
-    override fun isEligible(ctx: BlockContext) =
-        Config.enabled && Config.algae.enabled &&
-        ctx.blockState(up2).material == Material.WATER &&
-        ctx.blockState(up1).material == Material.WATER &&
-        Config.blocks.dirt.matchesClass(ctx.block) &&
-        ctx.biomeId in Config.algae.biomes &&
-        noise[ctx.pos] < Config.algae.population
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-        if (!layer.isCutout) return baseRender
-
-        modelRenderer.updateShading(Int3.zero, allFaces)
-
-        val rand = ctx.semiRandomArray(3)
-
-        ShadersModIntegration.grass(renderer, Config.algae.shaderWind) {
-            modelRenderer.render(
-                renderer,
-                algaeModels[rand[2]],
-                Rotation.identity,
-                icon = { _, qi, _ -> algaeIcons[rand[qi and 1]]!! },
-                postProcess = noPost
-            )
-        }
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderCactus.kt

@@ -1,111 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.render.column.ColumnTextureInfo
-import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.octarinecore.client.render.*
-import mods.octarinecore.client.resource.ModelRenderRegistryConfigurable
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.Rotation
-import mods.octarinecore.common.config.ModelTextureList
-import mods.octarinecore.common.config.SimpleBlockMatcher
-import net.minecraft.block.BlockCactus
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.*
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
-
-object StandardCactusRegistry : ModelRenderRegistryConfigurable<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-    override val matchClasses = SimpleBlockMatcher(BlockCactus::class.java)
-    override val modelTextures = listOf(ModelTextureList("block/cactus", "top", "bottom", "side"))
-    override fun processModel(state: IBlockState, textures: List<String>) = SimpleColumnInfo.Key(logger, Axis.Y, textures)
-    init { MinecraftForge.EVENT_BUS.register(this) }
-}
-
-@SideOnly(Side.CLIENT)
-class RenderCactus : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    val cactusStemRadius = 0.4375
-    val cactusArmRotation = listOf(NORTH, SOUTH, EAST, WEST).map { Rotation.rot90[it.ordinal] }
-
-    val iconCross = iconStatic(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_cactus")
-    val iconArm = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_cactus_arm_%d")
-
-    val modelStem = model {
-        horizontalRectangle(x1 = -cactusStemRadius, x2 = cactusStemRadius, z1 = -cactusStemRadius, z2 = cactusStemRadius, y = 0.5)
-        .scaleUV(cactusStemRadius * 2.0)
-        .let { listOf(it.flipped.move(1.0 to DOWN), it) }
-        .forEach { it.setAoShader(faceOrientedAuto(corner = cornerAo(Axis.Y), edge = null)).add() }
-
-        verticalRectangle(x1 = -0.5, z1 = cactusStemRadius, x2 = 0.5, z2 = cactusStemRadius, yBottom = -0.5, yTop = 0.5)
-        .setAoShader(faceOrientedAuto(corner = cornerAo(Axis.Y), edge = null))
-        .toCross(UP).addAll()
-    }
-    val modelCross = modelSet(64) { modelIdx ->
-        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -0.5 * 1.41, yTop = 0.5 * 1.41)
-        .setAoShader(edgeOrientedAuto(corner = cornerAoMaxGreen))
-        .scale(1.4)
-        .transformV { v ->
-            val perturb = xzDisk(modelIdx) * Config.cactus.sizeVariation
-            Vertex(v.xyz + (if (v.uv.u < 0.0) perturb else -perturb), v.uv, v.aoShader)
-        }
-        .toCross(UP).addAll()
-    }
-    val modelArm = modelSet(64) { modelIdx ->
-        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.0, yTop = 1.0)
-        .scale(Config.cactus.size).move(0.5 to UP)
-
-        .setAoShader(faceOrientedAuto(overrideFace = UP, corner = cornerAo(Axis.Y), edge = null))
-        .toCross(UP) { it.move(xzDisk(modelIdx) * Config.cactus.hOffset) }.addAll()
-    }
-
-    override fun afterPreStitch() {
-        Client.log(Level.INFO, "Registered ${iconArm.num} cactus arm textures")
-    }
-
-    override fun isEligible(ctx: BlockContext): Boolean =
-        Config.enabled && Config.cactus.enabled &&
-        Config.blocks.cactus.matchesClass(ctx.block)
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        // render the whole block on the cutout layer
-        if (!layer.isCutout) return false
-
-        // get AO data
-        modelRenderer.updateShading(Int3.zero, allFaces)
-        val icons = StandardCactusRegistry[ctx] ?: return renderWorldBlockBase(ctx, dispatcher, renderer, null)
-
-        modelRenderer.render(
-            renderer,
-            modelStem.model,
-            Rotation.identity,
-            icon = { ctx, qi, q -> when(qi) {
-                0 -> icons.bottom(ctx, qi, q); 1 -> icons.top(ctx, qi, q); else -> icons.side(ctx, qi, q)
-            } },
-            postProcess = noPost
-        )
-        modelRenderer.render(
-            renderer,
-            modelCross[ctx.random(0)],
-            Rotation.identity,
-            icon = { _, _, _ -> iconCross.icon!!},
-            postProcess = noPost
-        )
-        modelRenderer.render(
-            renderer,
-            modelArm[ctx.random(1)],
-            cactusArmRotation[ctx.random(2) % 4],
-            icon = { _, _, _ -> iconArm[ctx.random(3)]!!},
-            postProcess = noPost
-        )
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrass.kt

@@ -1,36 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.AbstractBlockRenderingHandler
-import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.client.render.withOffset
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.forgeDirsHorizontal
-import mods.octarinecore.common.offset
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-
-@SideOnly(Side.CLIENT)
-class RenderConnectedGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-    override fun isEligible(ctx: BlockContext) =
-        Config.enabled && Config.connectedGrass.enabled &&
-        Config.blocks.dirt.matchesClass(ctx.block) &&
-        Config.blocks.grassClasses.matchesClass(ctx.block(up1)) &&
-        (Config.connectedGrass.snowEnabled || !ctx.blockState(up2).isSnow)
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        // if the block sides are not visible anyway, render normally
-        if (forgeDirsHorizontal.all { ctx.blockState(it.offset).isOpaqueCube }) return renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-
-        if (ctx.isSurroundedBy { it.isOpaqueCube } ) return false
-        return ctx.withOffset(Int3.zero, up1) {
-            ctx.withOffset(up1, up2) {
-                renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-            }
-        }
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrassLog.kt

@@ -1,36 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.AbstractBlockRenderingHandler
-import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.client.render.withOffset
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.offset
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.*
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-
-@SideOnly(Side.CLIENT)
-class RenderConnectedGrassLog : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    val grassCheckDirs = listOf(EAST, WEST, NORTH, SOUTH)
-
-    override fun isEligible(ctx: BlockContext) =
-        Config.enabled && Config.roundLogs.enabled && Config.roundLogs.connectGrass &&
-        Config.blocks.dirt.matchesClass(ctx.block) &&
-        Config.blocks.logClasses.matchesClass(ctx.block(up1))
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val grassDir = grassCheckDirs.find {
-            Config.blocks.grassClasses.matchesClass(ctx.block(it.offset))
-        } ?: return renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-
-        return ctx.withOffset(Int3.zero, grassDir.offset) {
-            renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-        }
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderCoral.kt

@@ -1,77 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.*
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.forgeDirOffsets
-import mods.octarinecore.common.forgeDirs
-import mods.octarinecore.random
-import net.minecraft.block.material.Material
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.Axis
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
-
-@SideOnly(Side.CLIENT)
-class RenderCoral : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    val noise = simplexNoise()
-
-    val coralIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_coral_%d")
-    val crustIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_crust_%d")
-    val coralModels = modelSet(64) { modelIdx ->
-        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.0, yTop = 1.0)
-        .scale(Config.coral.size).move(0.5 to UP)
-        .toCross(UP) { it.move(xzDisk(modelIdx) * Config.coral.hOffset) }.addAll()
-
-        val separation = random(0.01, Config.coral.vOffset)
-        horizontalRectangle(x1 = -0.5, x2 = 0.5, z1 = -0.5, z2 = 0.5, y = 0.0)
-        .scale(Config.coral.crustSize).move(0.5 + separation to UP).add()
-
-        transformQ {
-            it.setAoShader(faceOrientedAuto(overrideFace = UP, corner = cornerAo(Axis.Y)))
-            .setFlatShader(faceOrientedAuto(overrideFace = UP, corner = cornerFlat))
-        }
-    }
-
-    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${coralIcons.num} coral textures")
-        Client.log(INFO, "Registered ${crustIcons.num} coral crust textures")
-    }
-
-    override fun isEligible(ctx: BlockContext) =
-        Config.enabled && Config.coral.enabled &&
-        (ctx.blockState(up2).material == Material.WATER || Config.coral.shallowWater) &&
-        ctx.blockState(up1).material == Material.WATER &&
-        Config.blocks.sand.matchesClass(ctx.block) &&
-        ctx.biomeId in Config.coral.biomes &&
-        noise[ctx.pos] < Config.coral.population
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-        if (!layer.isCutout) return baseRender
-
-        modelRenderer.updateShading(Int3.zero, allFaces)
-
-        forgeDirs.forEachIndexed { idx, face ->
-            if (!ctx.blockState(forgeDirOffsets[idx]).isOpaqueCube && blockContext.random(idx) < Config.coral.chance) {
-                var variation = blockContext.random(6)
-                modelRenderer.render(
-                    renderer,
-                    coralModels[variation++],
-                    rotationFromUp[idx],
-                    icon = { _, qi, _ -> if (qi == 4) crustIcons[variation]!! else coralIcons[variation + (qi and 1)]!!},
-                    postProcess = noPost
-                )
-            }
-        }
-
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderGrass.kt

@@ -1,127 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.OptifineCustomColors
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.betterfoliage.client.texture.GrassRegistry
-import mods.octarinecore.client.render.*
-import mods.octarinecore.common.*
-import mods.octarinecore.random
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumBlockRenderType
-import net.minecraft.util.EnumBlockRenderType.MODEL
-import net.minecraft.util.EnumFacing.Axis
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
-
-@SideOnly(Side.CLIENT)
-class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    companion object {
-        @JvmStatic fun grassTopQuads(heightMin: Double, heightMax: Double): Model.(Int)->Unit = { modelIdx ->
-            verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.5,
-                    yTop = 0.5 + random(heightMin, heightMax)
-            )
-            .setAoShader(faceOrientedAuto(overrideFace = UP, corner = cornerAo(Axis.Y)))
-            .setFlatShader(faceOrientedAuto(overrideFace = UP, corner = cornerFlat))
-            .toCross(UP) { it.move(xzDisk(modelIdx) * Config.shortGrass.hOffset) }.addAll()
-        }
-    }
-
-    val noise = simplexNoise()
-
-    val normalIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_grass_long_%d")
-    val snowedIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_grass_snowed_%d")
-    val normalGenIcon = iconStatic(Client.genGrass.generatedResource("minecraft:blocks/tallgrass", "snowed" to false))
-    val snowedGenIcon = iconStatic(Client.genGrass.generatedResource("minecraft:blocks/tallgrass", "snowed" to true))
-
-    val grassModels = modelSet(64, grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax))
-
-    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${normalIcons.num} grass textures")
-        Client.log(INFO, "Registered ${snowedIcons.num} snowed grass textures")
-    }
-
-    override fun isEligible(ctx: BlockContext) =
-        Config.enabled &&
-        (Config.shortGrass.grassEnabled || Config.connectedGrass.enabled) &&
-        GrassRegistry[ctx] != null
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        // render the whole block on the cutout layer
-        if (!layer.isCutout) return false
-
-        val isConnected = ctx.block(down1).let {
-            Config.blocks.dirt.matchesClass(it) ||
-            Config.blocks.grassClasses.matchesClass(it)
-        }
-        val isSnowed = ctx.blockState(up1).isSnow
-        val connectedGrass = isConnected && Config.connectedGrass.enabled && (!isSnowed || Config.connectedGrass.snowEnabled)
-
-        val grass = GrassRegistry[ctx]
-        if (grass == null) {
-            // shouldn't happen
-            Client.logRenderError(ctx.blockState(Int3.zero), ctx.pos)
-            return renderWorldBlockBase(ctx, dispatcher, renderer, null)
-        }
-        val blockColor = OptifineCustomColors.getBlockColor(ctx)
-
-        if (connectedGrass) {
-            // get full AO data
-            modelRenderer.updateShading(Int3.zero, allFaces)
-
-            // check occlusion
-            val isHidden = forgeDirs.map { ctx.blockState(it.offset).isOpaqueCube }
-
-            // render full grass block
-            ShadersModIntegration.renderAs(ctx.blockState(Int3.zero), MODEL, renderer) {
-                modelRenderer.render(
-                    renderer,
-                    fullCube,
-                    quadFilter = { qi, _ -> !isHidden[qi] },
-                    icon = { _, _, _ -> grass.grassTopTexture },
-                    postProcess = { ctx, _, _, _, _ ->
-                        rotateUV(2)
-                        if (isSnowed) {
-                            if (!ctx.aoEnabled) setGrey(1.4f)
-                        } else if (ctx.aoEnabled && grass.overrideColor == null) multiplyColor(blockColor)
-                    }
-                )
-            }
-        } else {
-            renderWorldBlockBase(ctx, dispatcher, renderer, null)
-
-            // get AO data only for block top
-            modelRenderer.updateShading(Int3.zero, topOnly)
-        }
-
-        if (!Config.shortGrass.grassEnabled) return true
-        if (isSnowed && !Config.shortGrass.snowEnabled) return true
-        if (ctx.blockState(up1).isOpaqueCube) return true
-        if (Config.shortGrass.population < 64 && noise[ctx.pos] >= Config.shortGrass.population) return true
-
-        // render grass quads
-        val iconset = if (isSnowed) snowedIcons else normalIcons
-        val iconGen = if (isSnowed) snowedGenIcon else normalGenIcon
-        val rand = ctx.semiRandomArray(2)
-
-        ShadersModIntegration.grass(renderer, Config.shortGrass.shaderWind) {
-            modelRenderer.render(
-                renderer,
-                grassModels[rand[0]],
-                Rotation.identity,
-                ctx.blockCenter + (if (isSnowed) snowOffset else Double3.zero),
-                icon = { _, qi, _ -> if (Config.shortGrass.useGenerated) iconGen.icon!! else iconset[rand[qi and 1]]!! },
-                postProcess = { _, _, _, _, _ -> if (isSnowed) setGrey(1.0f) else multiplyColor(grass.overrideColor ?: blockColor) }
-            )
-        }
-
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderLeaves.kt

@@ -1,94 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.OptifineCustomColors
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.betterfoliage.client.texture.LeafRegistry
-import mods.octarinecore.PI2
-import mods.octarinecore.client.render.*
-import mods.octarinecore.common.Double3
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.Rotation
-import mods.octarinecore.common.vec
-import mods.octarinecore.random
-import net.minecraft.block.material.Material
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.DOWN
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import java.lang.Math.cos
-import java.lang.Math.sin
-
-@SideOnly(Side.CLIENT)
-class RenderLeaves : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    val leavesModel = model {
-        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -0.5 * 1.41, yTop = 0.5 * 1.41)
-        .setAoShader(edgeOrientedAuto(corner = cornerAoMaxGreen))
-        .setFlatShader(FlatOffset(Int3.zero))
-        .scale(Config.leaves.size)
-        .toCross(UP).addAll()
-    }
-    val snowedIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_leaves_snowed_%d")
-
-    val perturbs = vectorSet(64) { idx ->
-        val angle = PI2 * idx / 64.0
-        Double3(cos(angle), 0.0, sin(angle)) * Config.leaves.hOffset +
-            UP.vec * random(-1.0, 1.0) * Config.leaves.vOffset
-    }
-
-    override fun isEligible(ctx: BlockContext) =
-        Config.enabled &&
-        Config.leaves.enabled &&
-        LeafRegistry[ctx] != null &&
-        !(Config.leaves.hideInternal && ctx.isSurroundedBy { it.isFullCube || it.material == Material.LEAVES } )
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val isSnowed = ctx.blockState(up1).material.let {
-            it == Material.SNOW || it == Material.CRAFTED_SNOW
-        }
-        val leafInfo = LeafRegistry[ctx]
-        if (leafInfo == null) {
-            // shouldn't happen
-            Client.logRenderError(ctx.blockState(Int3.zero), ctx.pos)
-            return renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-        }
-        val blockColor = OptifineCustomColors.getBlockColor(ctx)
-
-        renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-        if (!layer.isCutout) return true
-
-        modelRenderer.updateShading(Int3.zero, allFaces)
-        ShadersModIntegration.leaves(renderer) {
-            val rand = ctx.semiRandomArray(2)
-            (if (Config.leaves.dense) denseLeavesRot else normalLeavesRot).forEach { rotation ->
-                modelRenderer.render(
-                    renderer,
-                    leavesModel.model,
-                    rotation,
-                    ctx.blockCenter + perturbs[rand[0]],
-                    icon = { _, _, _ -> leafInfo.roundLeafTexture },
-                    postProcess = { _, _, _, _, _ ->
-                        rotateUV(rand[1])
-                        multiplyColor(blockColor)
-                    }
-                )
-            }
-            if (isSnowed && Config.leaves.snowEnabled) modelRenderer.render(
-                renderer,
-                leavesModel.model,
-                Rotation.identity,
-                ctx.blockCenter + perturbs[rand[0]],
-                icon = { _, _, _ -> snowedIcon[rand[1]]!! },
-                postProcess = whitewash
-            )
-        }
-
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderLilypad.kt

@@ -1,79 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.octarinecore.client.render.*
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.Rotation
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.DOWN
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
-
-@SideOnly(Side.CLIENT)
-class RenderLilypad : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    val rootModel = model {
-        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -1.5, yTop = -0.5)
-        .setFlatShader(FlatOffsetNoColor(Int3.zero))
-        .toCross(UP).addAll()
-    }
-    val flowerModel = model {
-        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.0, yTop = 1.0)
-        .scale(0.5).move(0.5 to DOWN)
-        .setFlatShader(FlatOffsetNoColor(Int3.zero))
-        .toCross(UP).addAll()
-    }
-    val rootIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_lilypad_roots_%d")
-    val flowerIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_lilypad_flower_%d")
-    val perturbs = vectorSet(64) { modelIdx -> xzDisk(modelIdx) * Config.lilypad.hOffset }
-
-    override fun afterPreStitch() {
-        Client.log(Level.INFO, "Registered ${rootIcon.num} lilypad root textures")
-        Client.log(Level.INFO, "Registered ${flowerIcon.num} lilypad flower textures")
-    }
-
-    override fun isEligible(ctx: BlockContext): Boolean =
-        Config.enabled && Config.lilypad.enabled &&
-        Config.blocks.lilypad.matchesClass(ctx.block)
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        // render the whole block on the cutout layer
-        if (!layer.isCutout) return false
-
-        renderWorldBlockBase(ctx, dispatcher, renderer, null)
-        modelRenderer.updateShading(Int3.zero, allFaces)
-
-        val rand = ctx.semiRandomArray(5)
-
-        ShadersModIntegration.grass(renderer) {
-            modelRenderer.render(
-                renderer,
-                rootModel.model,
-                Rotation.identity,
-                ctx.blockCenter.add(perturbs[rand[2]]),
-                forceFlat = true,
-                icon = { ctx, qi, q -> rootIcon[rand[qi and 1]]!! },
-                postProcess = noPost
-            )
-        }
-
-        if (rand[3] < Config.lilypad.flowerChance) modelRenderer.render(
-            renderer,
-            flowerModel.model,
-            Rotation.identity,
-            ctx.blockCenter.add(perturbs[rand[4]]),
-            forceFlat = true,
-            icon = { _, _, _ -> flowerIcon[rand[0]]!! },
-            postProcess = noPost
-        )
-
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderLog.kt

@@ -1,67 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.render.column.AbstractRenderColumn
-import mods.betterfoliage.client.render.column.ColumnRenderLayer
-import mods.betterfoliage.client.render.column.ColumnTextureInfo
-import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.config.ConfigurableBlockMatcher
-import mods.octarinecore.common.config.ModelTextureList
-import mods.octarinecore.tryDefault
-import net.minecraft.block.BlockLog
-import net.minecraft.block.state.IBlockState
-import net.minecraft.util.EnumFacing.Axis
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-
-class RenderLog : AbstractRenderColumn(BetterFoliageMod.MOD_ID) {
-
-    override val addToCutout: Boolean get() = false
-
-    override fun isEligible(ctx: BlockContext) =
-        Config.enabled && Config.roundLogs.enabled &&
-        Config.blocks.logClasses.matchesClass(ctx.block)
-
-    override val overlayLayer = RoundLogOverlayLayer()
-    override val connectPerpendicular: Boolean get() = Config.roundLogs.connectPerpendicular
-    override val radiusSmall: Double get() = Config.roundLogs.radiusSmall
-    override val radiusLarge: Double get() = Config.roundLogs.radiusLarge
-    init {
-        ChunkOverlayManager.layers.add(overlayLayer)
-    }
-}
-
-class RoundLogOverlayLayer : ColumnRenderLayer() {
-    override val registry: ModelRenderRegistry<ColumnTextureInfo> get() = LogRegistry
-    override val blockPredicate = { state: IBlockState -> Config.blocks.logClasses.matchesClass(state.block) }
-    override val surroundPredicate = { state: IBlockState -> state.isOpaqueCube && !Config.blocks.logClasses.matchesClass(state.block) }
-
-    override val connectSolids: Boolean get() = Config.roundLogs.connectSolids
-    override val lenientConnect: Boolean get() = Config.roundLogs.lenientConnect
-    override val defaultToY: Boolean get() = Config.roundLogs.defaultY
-}
-
-@SideOnly(Side.CLIENT)
-object LogRegistry : ModelRenderRegistryRoot<ColumnTextureInfo>()
-
-object StandardLogRegistry : ModelRenderRegistryConfigurable<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-    override val matchClasses: ConfigurableBlockMatcher get() = Config.blocks.logClasses
-    override val modelTextures: List<ModelTextureList> get() = Config.blocks.logModels.list
-    override fun processModel(state: IBlockState, textures: List<String>) = SimpleColumnInfo.Key(logger, getAxis(state), textures)
-
-    fun getAxis(state: IBlockState): Axis? {
-        val axis = tryDefault(null) { state.getValue(BlockLog.LOG_AXIS).toString() } ?:
-        state.properties.entries.find { it.key.getName().toLowerCase() == "axis" }?.value?.toString()
-        return when (axis) {
-            "x" -> Axis.X
-            "y" -> Axis.Y
-            "z" -> Axis.Z
-            else -> null
-        }
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderMycelium.kt

@@ -1,57 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.AbstractBlockRenderingHandler
-import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.client.render.modelRenderer
-import mods.octarinecore.client.render.noPost
-import mods.octarinecore.common.Double3
-import mods.octarinecore.common.Rotation
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
-
-@SideOnly(Side.CLIENT)
-class RenderMycelium : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    val myceliumIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_mycel_%d")
-    val myceliumModel = modelSet(64, RenderGrass.grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax))
-
-    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${myceliumIcon.num} mycelium textures")
-    }
-
-    override fun isEligible(ctx: BlockContext): Boolean {
-        if (!Config.enabled || !Config.shortGrass.myceliumEnabled) return false
-        return Config.blocks.mycelium.matchesClass(ctx.block)
-    }
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        // render the whole block on the cutout layer
-        if (!layer.isCutout) return false
-
-        val isSnowed = ctx.blockState(up1).isSnow
-
-        renderWorldBlockBase(ctx, dispatcher, renderer, null)
-
-        if (isSnowed && !Config.shortGrass.snowEnabled) return true
-        if (ctx.blockState(up1).isOpaqueCube) return true
-
-        val rand = ctx.semiRandomArray(2)
-        modelRenderer.render(
-            renderer,
-            myceliumModel[rand[0]],
-            Rotation.identity,
-            ctx.blockCenter + (if (isSnowed) snowOffset else Double3.zero),
-            icon = { _, qi, _ -> myceliumIcon[rand[qi and 1]]!! },
-            postProcess = if (isSnowed) whitewash else noPost
-        )
-
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderNetherrack.kt

@@ -1,59 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.*
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.Rotation
-import mods.octarinecore.random
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.*
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
-
-@SideOnly(Side.CLIENT)
-class RenderNetherrack : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    val netherrackIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_netherrack_%d")
-    val netherrackModel = modelSet(64) { modelIdx ->
-        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yTop = -0.5,
-        yBottom = -0.5 - random(Config.netherrack.heightMin, Config.netherrack.heightMax))
-        .setAoShader(faceOrientedAuto(overrideFace = DOWN, corner = cornerAo(Axis.Y)))
-        .setFlatShader(faceOrientedAuto(overrideFace = DOWN, corner = cornerFlat))
-        .toCross(UP) { it.move(xzDisk(modelIdx) * Config.shortGrass.hOffset) }.addAll()
-
-    }
-
-    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${netherrackIcon.num} netherrack textures")
-    }
-
-    override fun isEligible(ctx: BlockContext): Boolean {
-        if (!Config.enabled || !Config.netherrack.enabled) return false
-        return Config.blocks.netherrack.matchesClass(ctx.block)
-    }
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-        if (!layer.isCutout) return baseRender
-
-        if (ctx.blockState(down1).isOpaqueCube) return baseRender
-
-        modelRenderer.updateShading(Int3.zero, allFaces)
-
-        val rand = ctx.semiRandomArray(2)
-        modelRenderer.render(
-            renderer,
-            netherrackModel[rand[0]],
-            Rotation.identity,
-            icon = { _, qi, _ -> netherrackIcon[rand[qi and 1]]!! },
-            postProcess = noPost
-        )
-
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/RenderReeds.kt

@@ -1,74 +0,0 @@
-package mods.betterfoliage.client.render
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.octarinecore.client.render.*
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.Rotation
-import mods.octarinecore.random
-import net.minecraft.block.material.Material
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
-
-@SideOnly(Side.CLIENT)
-class RenderReeds : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
-
-    val noise = simplexNoise()
-    val reedIcons = iconSet(Client.genReeds.generatedResource("${BetterFoliageMod.LEGACY_DOMAIN}:blocks/better_reed_%d"))
-    val reedModels = modelSet(64) { modelIdx ->
-        val height = random(Config.reed.heightMin, Config.reed.heightMax)
-        val waterline = 0.875f
-        val vCutLine = 0.5 - waterline / height
-        listOf(
-            // below waterline
-            verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.5, yTop = 0.5 + waterline)
-            .setFlatShader(FlatOffsetNoColor(up1)).clampUV(minV = vCutLine),
-
-            // above waterline
-            verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.5 + waterline, yTop = 0.5 + height)
-            .setFlatShader(FlatOffsetNoColor(up2)).clampUV(maxV = vCutLine)
-        ).forEach {
-            it.clampUV(minU = -0.25, maxU = 0.25)
-            .toCross(UP) { it.move(xzDisk(modelIdx) * Config.reed.hOffset) }.addAll()
-        }
-    }
-
-    override fun afterPreStitch() {
-        Client.log(Level.INFO, "Registered ${reedIcons.num} reed textures")
-    }
-
-    override fun isEligible(ctx: BlockContext) =
-        Config.enabled && Config.reed.enabled &&
-        ctx.blockState(up2).material == Material.AIR &&
-        ctx.blockState(up1).material == Material.WATER &&
-        Config.blocks.dirt.matchesClass(ctx.block) &&
-        ctx.biomeId in Config.reed.biomes &&
-        noise[ctx.pos] < Config.reed.population
-
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-        if (!layer.isCutout) return baseRender
-
-        modelRenderer.updateShading(Int3.zero, allFaces)
-
-        val iconVar = ctx.random(1)
-        ShadersModIntegration.grass(renderer, Config.reed.shaderWind) {
-            modelRenderer.render(
-                renderer,
-                reedModels[ctx.random(0)],
-                Rotation.identity,
-                forceFlat = true,
-                icon = { _, _, _ -> reedIcons[iconVar]!! },
-                postProcess = noPost
-            )
-        }
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/Utils.kt

@@ -1,62 +0,0 @@
-@file:JvmName("Utils")
-package mods.betterfoliage.client.render
-
-import mods.octarinecore.PI2
-import mods.octarinecore.client.render.*
-import mods.octarinecore.common.Double3
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.Rotation
-import mods.octarinecore.common.times
-import net.minecraft.block.Block
-import net.minecraft.block.material.Material
-import net.minecraft.block.state.IBlockState
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing
-import net.minecraft.util.EnumFacing.*
-
-val up1 = Int3(1 to UP)
-val up2 = Int3(2 to UP)
-val down1 = Int3(1 to DOWN)
-val snowOffset = UP * 0.0625
-
-val normalLeavesRot = arrayOf(Rotation.identity)
-val denseLeavesRot = arrayOf(Rotation.identity, Rotation.rot90[EAST.ordinal], Rotation.rot90[SOUTH.ordinal])
-
-val whitewash: PostProcessLambda = { _, _, _, _, _ -> setGrey(1.4f) }
-val greywash: PostProcessLambda = { _, _, _, _, _ -> setGrey(1.0f) }
-
-val IBlockState.isSnow: Boolean get() = material.let { it == Material.SNOW || it == Material.CRAFTED_SNOW }
-
-fun Quad.toCross(rotAxis: EnumFacing, trans: (Quad)->Quad) =
-    (0..3).map { rotIdx ->
-        trans(rotate(Rotation.rot90[rotAxis.ordinal] * rotIdx).mirrorUV(rotIdx > 1, false))
-    }
-fun Quad.toCross(rotAxis: EnumFacing) = toCross(rotAxis) { it }
-
-fun xzDisk(modelIdx: Int) = (PI2 * modelIdx / 64.0).let { Double3(Math.cos(it), 0.0, Math.sin(it)) }
-
-val rotationFromUp = arrayOf(
-    Rotation.rot90[EAST.ordinal] * 2,
-    Rotation.identity,
-    Rotation.rot90[WEST.ordinal],
-    Rotation.rot90[EAST.ordinal],
-    Rotation.rot90[SOUTH.ordinal],
-    Rotation.rot90[NORTH.ordinal]
-)
-
-fun Model.mix(first: Model, second: Model, predicate: (Int)->Boolean) {
-    first.quads.forEachIndexed { qi, quad ->
-        val otherQuad = second.quads[qi]
-        Quad(
-            if (predicate(0)) otherQuad.v1.copy() else quad.v1.copy(),
-            if (predicate(1)) otherQuad.v2.copy() else quad.v2.copy(),
-            if (predicate(2)) otherQuad.v3.copy() else quad.v3.copy(),
-            if (predicate(3)) otherQuad.v4.copy() else quad.v4.copy()
-        ).add()
-    }
-}
-
-val BlockRenderLayer.isCutout: Boolean get() = (this == BlockRenderLayer.CUTOUT) || (this == BlockRenderLayer.CUTOUT_MIPPED)
-
-fun IBlockState.canRenderInLayer(layer: BlockRenderLayer) = this.block.canRenderInLayer(this, layer)
-fun IBlockState.canRenderInCutout() = this.block.canRenderInLayer(this, BlockRenderLayer.CUTOUT) || this.block.canRenderInLayer(this, BlockRenderLayer.CUTOUT_MIPPED)

src/main/kotlin/mods/betterfoliage/client/render/column/AbstractRenderer.kt

@@ -1,224 +0,0 @@
-package mods.betterfoliage.client.render.column
-
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.chunk.ChunkOverlayLayer
-import mods.betterfoliage.client.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.ShadersModIntegration.renderAs
-import mods.betterfoliage.client.render.*
-import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.BlockType.*
-import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.QuadrantType
-import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.QuadrantType.*
-import mods.octarinecore.client.render.*
-import mods.octarinecore.client.resource.ModelRenderRegistry
-import mods.octarinecore.common.*
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumBlockRenderType
-import net.minecraft.util.EnumBlockRenderType.MODEL
-import net.minecraft.util.EnumFacing.*
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-
-@SideOnly(Side.CLIENT)
-@Suppress("NOTHING_TO_INLINE")
-abstract class AbstractRenderColumn(modId: String) : AbstractBlockRenderingHandler(modId) {
-
-    /** The rotations necessary to bring the models in position for the 4 quadrants */
-    val quadrantRotations = Array(4) { Rotation.rot90[UP.ordinal] * it }
-
-    // ============================
-    // Configuration
-    // ============================
-    abstract val overlayLayer: ColumnRenderLayer
-    abstract val connectPerpendicular: Boolean
-    abstract val radiusSmall: Double
-    abstract val radiusLarge: Double
-
-    // ============================
-    // Models
-    // ============================
-    val sideSquare = model { columnSideSquare(-0.5, 0.5) }
-    val sideRoundSmall = model { columnSide(radiusSmall, -0.5, 0.5) }
-    val sideRoundLarge = model { columnSide(radiusLarge, -0.5, 0.5) }
-
-    val extendTopSquare = model { columnSideSquare(0.5, 0.5 + radiusLarge, topExtension(radiusLarge)) }
-    val extendTopRoundSmall = model { columnSide(radiusSmall, 0.5, 0.5 + radiusLarge, topExtension(radiusLarge)) }
-    val extendTopRoundLarge = model { columnSide(radiusLarge, 0.5, 0.5 + radiusLarge, topExtension(radiusLarge)) }
-    inline fun extendTop(type: QuadrantType) = when(type) {
-        SMALL_RADIUS -> extendTopRoundSmall.model
-        LARGE_RADIUS -> extendTopRoundLarge.model
-        SQUARE -> extendTopSquare.model
-        INVISIBLE -> extendTopSquare.model
-        else -> null
-    }
-
-    val extendBottomSquare = model { columnSideSquare(-0.5 - radiusLarge, -0.5, bottomExtension(radiusLarge)) }
-    val extendBottomRoundSmall = model { columnSide(radiusSmall, -0.5 - radiusLarge, -0.5, bottomExtension(radiusLarge)) }
-    val extendBottomRoundLarge = model { columnSide(radiusLarge, -0.5 - radiusLarge, -0.5, bottomExtension(radiusLarge)) }
-    inline fun extendBottom(type: QuadrantType) = when (type) {
-        SMALL_RADIUS -> extendBottomRoundSmall.model
-        LARGE_RADIUS -> extendBottomRoundLarge.model
-        SQUARE -> extendBottomSquare.model
-        INVISIBLE -> extendBottomSquare.model
-        else -> null
-    }
-
-    val topSquare = model { columnLidSquare() }
-    val topRoundSmall = model { columnLid(radiusSmall) }
-    val topRoundLarge = model { columnLid(radiusLarge) }
-    inline fun flatTop(type: QuadrantType) = when(type) {
-        SMALL_RADIUS -> topRoundSmall.model
-        LARGE_RADIUS -> topRoundLarge.model
-        SQUARE -> topSquare.model
-        INVISIBLE -> topSquare.model
-        else -> null
-    }
-
-    val bottomSquare = model { columnLidSquare() { it.rotate(rot(EAST) * 2 + rot(UP)).mirrorUV(true, true) } }
-    val bottomRoundSmall = model { columnLid(radiusSmall) { it.rotate(rot(EAST) * 2 + rot(UP)).mirrorUV(true, true) } }
-    val bottomRoundLarge = model { columnLid(radiusLarge) { it.rotate(rot(EAST) * 2 + rot(UP)).mirrorUV(true, true) } }
-    inline fun flatBottom(type: QuadrantType) = when(type) {
-        SMALL_RADIUS -> bottomRoundSmall.model
-        LARGE_RADIUS -> bottomRoundLarge.model
-        SQUARE -> bottomSquare.model
-        INVISIBLE -> bottomSquare.model
-        else -> null
-    }
-
-    val transitionTop = model { mix(sideRoundLarge.model, sideRoundSmall.model) { it > 1 } }
-    val transitionBottom = model { mix(sideRoundSmall.model, sideRoundLarge.model) { it > 1 } }
-
-    inline fun continuous(q1: QuadrantType, q2: QuadrantType) =
-        q1 == q2 || ((q1 == SQUARE || q1 == INVISIBLE) && (q2 == SQUARE || q2 == INVISIBLE))
-
-    @Suppress("NON_EXHAUSTIVE_WHEN")
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-
-        val roundLog = ChunkOverlayManager.get(overlayLayer, ctx.world!!, ctx.pos)
-        when(roundLog) {
-            ColumnLayerData.SkipRender -> return true
-            ColumnLayerData.NormalRender -> return renderWorldBlockBase(ctx, dispatcher, renderer, null)
-            ColumnLayerData.ResolveError, null -> {
-                Client.logRenderError(ctx.blockState(Int3.zero), ctx.pos)
-                return renderWorldBlockBase(ctx, dispatcher, renderer, null)
-            }
-        }
-
-        // if log axis is not defined and "Default to vertical" config option is not set, render normally
-        if ((roundLog as ColumnLayerData.SpecialRender).column.axis == null && !overlayLayer.defaultToY) {
-            return renderWorldBlockBase(ctx, dispatcher, renderer, null)
-        }
-
-        // get AO data
-        modelRenderer.updateShading(Int3.zero, allFaces)
-
-        val baseRotation = rotationFromUp[((roundLog.column.axis ?: Axis.Y) to AxisDirection.POSITIVE).face.ordinal]
-        renderAs(ctx.blockState(Int3.zero), MODEL, renderer) {
-            quadrantRotations.forEachIndexed { idx, quadrantRotation ->
-                // set rotation for the current quadrant
-                val rotation = baseRotation + quadrantRotation
-
-                // disallow sharp discontinuities in the chamfer radius, or tapering-in where inappropriate
-                if (roundLog.quadrants[idx] == LARGE_RADIUS &&
-                    roundLog.upType == PARALLEL && roundLog.quadrantsTop[idx] != LARGE_RADIUS &&
-                    roundLog.downType == PARALLEL && roundLog.quadrantsBottom[idx] != LARGE_RADIUS) {
-                    roundLog.quadrants[idx] = SMALL_RADIUS
-                }
-
-                // render side of current quadrant
-                val sideModel = when (roundLog.quadrants[idx]) {
-                    SMALL_RADIUS -> sideRoundSmall.model
-                    LARGE_RADIUS -> if (roundLog.upType == PARALLEL && roundLog.quadrantsTop[idx] == SMALL_RADIUS) transitionTop.model
-                    else if (roundLog.downType == PARALLEL && roundLog.quadrantsBottom[idx] == SMALL_RADIUS) transitionBottom.model
-                    else sideRoundLarge.model
-                    SQUARE -> sideSquare.model
-                    else -> null
-                }
-
-                if (sideModel != null) modelRenderer.render(
-                    renderer,
-                    sideModel,
-                    rotation,
-                    icon = roundLog.column.side,
-                    postProcess = noPost
-                )
-
-                // render top and bottom end of current quadrant
-                var upModel: Model? = null
-                var downModel: Model? = null
-                var upIcon = roundLog.column.top
-                var downIcon = roundLog.column.bottom
-                var isLidUp = true
-                var isLidDown = true
-
-                when (roundLog.upType) {
-                    NONSOLID -> upModel = flatTop(roundLog.quadrants[idx])
-                    PERPENDICULAR -> {
-                        if (!connectPerpendicular) {
-                            upModel = flatTop(roundLog.quadrants[idx])
-                        } else {
-                            upIcon = roundLog.column.side
-                            upModel = extendTop(roundLog.quadrants[idx])
-                            isLidUp = false
-                        }
-                    }
-                    PARALLEL -> {
-                        if (!continuous(roundLog.quadrants[idx], roundLog.quadrantsTop[idx])) {
-                            if (roundLog.quadrants[idx] == SQUARE || roundLog.quadrants[idx] == INVISIBLE) {
-                                upModel = topSquare.model
-                            }
-                        }
-                    }
-                }
-                when (roundLog.downType) {
-                    NONSOLID -> downModel = flatBottom(roundLog.quadrants[idx])
-                    PERPENDICULAR -> {
-                        if (!connectPerpendicular) {
-                            downModel = flatBottom(roundLog.quadrants[idx])
-                        } else {
-                            downIcon = roundLog.column.side
-                            downModel = extendBottom(roundLog.quadrants[idx])
-                            isLidDown = false
-                        }
-                    }
-                    PARALLEL -> {
-                        if (!continuous(roundLog.quadrants[idx], roundLog.quadrantsBottom[idx]) &&
-                            (roundLog.quadrants[idx] == SQUARE || roundLog.quadrants[idx] == INVISIBLE)) {
-                            downModel = bottomSquare.model
-                        }
-                    }
-                }
-
-                if (upModel != null) modelRenderer.render(
-                    renderer,
-                    upModel,
-                    rotation,
-                    icon = upIcon,
-                    postProcess = { _, _, _, _, _ ->
-                        if (isLidUp) {
-                            rotateUV(idx + if (roundLog.column.axis == Axis.X) 1 else 0)
-                        }
-                    }
-                )
-                if (downModel != null) modelRenderer.render(
-                    renderer,
-                    downModel,
-                    rotation,
-                    icon = downIcon,
-                    postProcess = { _, _, _, _, _ ->
-                        if (isLidDown) {
-                            rotateUV((if (roundLog.column.axis == Axis.X) 0 else 3) - idx)
-                        }
-                    }
-                )
-            }
-        }
-        return true
-    }
-}

src/main/kotlin/mods/betterfoliage/client/render/column/RenderData.kt

@@ -1,50 +0,0 @@
-package mods.betterfoliage.client.render.column
-
-import mods.octarinecore.client.render.QuadIconResolver
-import mods.octarinecore.client.render.blockContext
-import mods.octarinecore.client.resource.ModelRenderKey
-import mods.octarinecore.client.resource.get
-import mods.octarinecore.common.rotate
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.client.renderer.texture.TextureMap
-import net.minecraft.util.EnumFacing
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Logger
-
-@SideOnly(Side.CLIENT)
-interface ColumnTextureInfo {
-    val axis: EnumFacing.Axis?
-    val top: QuadIconResolver
-    val bottom: QuadIconResolver
-    val side: QuadIconResolver
-}
-
-@SideOnly(Side.CLIENT)
-open class SimpleColumnInfo(
-    override val axis: EnumFacing.Axis?,
-    val topTexture: TextureAtlasSprite,
-    val bottomTexture: TextureAtlasSprite,
-    val sideTextures: List<TextureAtlasSprite>
-) : ColumnTextureInfo {
-
-    // index offsets for EnumFacings, to make it less likely for neighboring faces to get the same bark texture
-    val dirToIdx = arrayOf(0, 1, 2, 4, 3, 5)
-
-    override val top: QuadIconResolver = { _, _, _ -> topTexture }
-    override val bottom: QuadIconResolver = { _, _, _ -> bottomTexture }
-    override val side: QuadIconResolver = { ctx, idx, _ ->
-        val worldFace = (if ((idx and 1) == 0) EnumFacing.SOUTH else EnumFacing.EAST).rotate(ctx.rotation)
-        val sideIdx = if (sideTextures.size > 1) (blockContext.random(1) + dirToIdx[worldFace.ordinal]) % sideTextures.size else 0
-        sideTextures[sideIdx]
-    }
-
-    class Key(override val logger: Logger, val axis: EnumFacing.Axis?, val textures: List<String>) : ModelRenderKey<ColumnTextureInfo> {
-        override fun resolveSprites(atlas: TextureMap) = SimpleColumnInfo(
-            axis,
-            atlas[textures[0]] ?: atlas.missingSprite,
-            atlas[textures[1]] ?: atlas.missingSprite,
-            textures.drop(2).map { atlas[it] ?: atlas.missingSprite }
-        )
-    }
-}

src/main/kotlin/mods/betterfoliage/client/texture/GrassRegistry.kt

@@ -1,68 +0,0 @@
-package mods.betterfoliage.client.texture
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.client.render.HSB
-import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.config.ConfigurableBlockMatcher
-import mods.octarinecore.common.config.IBlockMatcher
-import mods.octarinecore.common.config.ModelTextureList
-import mods.octarinecore.findFirst
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.client.renderer.texture.TextureMap
-import net.minecraft.util.EnumFacing
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
-import org.apache.logging.log4j.Logger
-import java.lang.Math.min
-
-const val defaultGrassColor = 0
-
-/** Rendering-related information for a grass block. */
-class GrassInfo(
-    /** Top texture of the grass block. */
-    val grassTopTexture: TextureAtlasSprite,
-
-    /**
-     * Color to use for Short Grass rendering instead of the biome color.
-     *
-     * Value is null if the texture is mostly grey (the saturation of its average color is under a configurable limit),
-     * the average color of the texture otherwise.
-     */
-    val overrideColor: Int?
-)
-
-object GrassRegistry : ModelRenderRegistryRoot<GrassInfo>()
-
-object StandardGrassRegistry : ModelRenderRegistryConfigurable<GrassInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-    override val matchClasses: ConfigurableBlockMatcher get() = Config.blocks.grassClasses
-    override val modelTextures: List<ModelTextureList> get() = Config.blocks.grassModels.list
-    override fun processModel(state: IBlockState, textures: List<String>) = StandardGrassKey(logger, textures[0])
-}
-
-class StandardGrassKey(override val logger: Logger, val textureName: String) : ModelRenderKey<GrassInfo> {
-    override fun resolveSprites(atlas: TextureMap): GrassInfo {
-        val logName = "StandardGrassKey"
-        val texture = atlas[textureName] ?: atlas.missingSprite
-        logger.log(Level.DEBUG, "$logName: texture $textureName")
-        val hsb = HSB.fromColor(texture.averageColor ?: defaultGrassColor)
-        val overrideColor = if (hsb.saturation >= Config.shortGrass.saturationThreshold) {
-            logger.log(Level.DEBUG, "$logName:         brightness ${hsb.brightness}")
-            logger.log(Level.DEBUG, "$logName:         saturation ${hsb.saturation} >= ${Config.shortGrass.saturationThreshold}, using texture color")
-            hsb.copy(brightness = min(0.9f, hsb.brightness * 2.0f)).asColor
-        } else {
-            logger.log(Level.DEBUG, "$logName:         saturation ${hsb.saturation} < ${Config.shortGrass.saturationThreshold}, using block color")
-            null
-        }
-        return GrassInfo(texture, overrideColor)
-    }
-}

src/main/kotlin/mods/betterfoliage/client/texture/LeafParticleRegistry.kt

@@ -1,69 +0,0 @@
-package mods.betterfoliage.client.texture
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.octarinecore.client.resource.*
-import mods.octarinecore.stripStart
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.util.ResourceLocation
-import net.minecraftforge.client.event.TextureStitchEvent
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.common.eventhandler.EventPriority
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
-
-object LeafParticleRegistry {
-    val typeMappings = TextureMatcher()
-    val particles = hashMapOf<String, IconSet>()
-
-    operator fun get(type: String) = particles[type] ?: particles["default"]!!
-
-    init { MinecraftForge.EVENT_BUS.register(this) }
-
-    @SubscribeEvent(priority = EventPriority.HIGH)
-    fun handleLoadModelData(event: LoadModelDataEvent) {
-        particles.clear()
-        typeMappings.loadMappings(ResourceLocation(BetterFoliageMod.DOMAIN, "leaf_texture_mappings.cfg"))
-    }
-
-    @SubscribeEvent
-    fun handlePreStitch(event: TextureStitchEvent.Pre) {
-        val allTypes = (typeMappings.mappings.map { it.type } + "default").distinct()
-        allTypes.forEach { leafType ->
-            val particleSet = IconSet("betterfoliage", "blocks/falling_leaf_${leafType}_%d").apply { onPreStitch(event.map) }
-            if (leafType == "default" || particleSet.num > 0) particles[leafType] = particleSet
-        }
-    }
-
-    @SubscribeEvent
-    fun handlePostStitch(event: TextureStitchEvent.Post) {
-        particles.forEach { (_, particleSet) -> particleSet.onPostStitch(event.map) }
-    }
-}
-
-class TextureMatcher {
-
-    data class Mapping(val domain: String?, val path: String, val type: String) {
-        fun matches(iconLocation: ResourceLocation): Boolean {
-            return (domain == null || domain == iconLocation.namespace) &&
-                iconLocation.path.stripStart("blocks/").contains(path, ignoreCase = true)
-        }
-    }
-
-    val mappings: MutableList<Mapping> = mutableListOf()
-
-    fun getType(resource: ResourceLocation) = mappings.filter { it.matches(resource) }.map { it.type }.firstOrNull()
-    fun getType(iconName: String) = ResourceLocation(iconName).let { getType(it) }
-
-    fun loadMappings(mappingLocation: ResourceLocation) {
-        mappings.clear()
-        resourceManager[mappingLocation]?.getLines()?.let { lines ->
-            lines.filter { !it.startsWith("//") }.filter { !it.isEmpty() }.forEach { line ->
-                val line2 = line.trim().split('=')
-                if (line2.size == 2) {
-                    val mapping = line2[0].trim().split(':')
-                    if (mapping.size == 1) mappings.add(Mapping(null, mapping[0].trim(), line2[1].trim()))
-                    else if (mapping.size == 2) mappings.add(Mapping(mapping[0].trim(), mapping[1].trim(), line2[1].trim()))
-                }
-            }
-        }
-    }
-}

src/main/kotlin/mods/betterfoliage/client/texture/LeafRegistry.kt

@@ -1,70 +0,0 @@
-package mods.betterfoliage.client.texture
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.config.ConfigurableBlockMatcher
-import mods.octarinecore.common.config.IBlockMatcher
-import mods.octarinecore.common.config.ModelTextureList
-import mods.octarinecore.findFirst
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.client.renderer.texture.TextureMap
-import net.minecraft.util.EnumFacing
-import net.minecraft.util.ResourceLocation
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraftforge.client.event.TextureStitchEvent
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.common.eventhandler.EventPriority
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
-import org.apache.logging.log4j.Logger
-
-const val defaultLeafColor = 0
-
-/** Rendering-related information for a leaf block. */
-class LeafInfo(
-    /** The generated round leaf texture. */
-    val roundLeafTexture: TextureAtlasSprite,
-
-    /** Type of the leaf block (configurable by user). */
-    val leafType: String,
-
-    /** Average color of the round leaf texture. */
-    val averageColor: Int = roundLeafTexture.averageColor ?: defaultLeafColor
-) {
-    /** [IconSet] of the textures to use for leaf particles emitted from this block. */
-    val particleTextures: IconSet get() = LeafParticleRegistry[leafType]
-}
-
-object LeafRegistry : ModelRenderRegistryRoot<LeafInfo>()
-
-object StandardLeafRegistry : ModelRenderRegistryConfigurable<LeafInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-    override val matchClasses: ConfigurableBlockMatcher get() = Config.blocks.leavesClasses
-    override val modelTextures: List<ModelTextureList> get() = Config.blocks.leavesModels.list
-    override fun processModel(state: IBlockState, textures: List<String>) = StandardLeafKey(logger, textures[0])
-}
-
-class StandardLeafKey(override val logger: Logger, val textureName: String) : ModelRenderKey<LeafInfo> {
-    lateinit var leafType: String
-    lateinit var generated: ResourceLocation
-
-    override fun onPreStitch(atlas: TextureMap) {
-        val logName = "StandardLeafKey"
-        leafType = LeafParticleRegistry.typeMappings.getType(textureName) ?: "default"
-        generated = Client.genLeaves.generatedResource(textureName, "type" to leafType)
-        atlas.registerSprite(generated)
-
-        logger.log(Level.DEBUG, "$logName: leaf texture   $textureName")
-        logger.log(Level.DEBUG, "$logName:      particle $leafType")
-    }
-
-    override fun resolveSprites(atlas: TextureMap) = LeafInfo(atlas[generated] ?: atlas.missingSprite, leafType)
-}

src/main/kotlin/mods/betterfoliage/client/texture/Utils.kt

@@ -1,11 +0,0 @@
-@file:JvmName("Utils")
-package mods.betterfoliage.client.texture
-
-fun blendRGB(rgb1: Int, rgb2: Int, weight1: Int, weight2: Int): Int {
-    val r = (((rgb1 shr 16) and 255) * weight1 + ((rgb2 shr 16) and 255) * weight2) / (weight1 + weight2)
-    val g = (((rgb1 shr 8) and 255) * weight1 + ((rgb2 shr 8) and 255) * weight2) / (weight1 + weight2)
-    val b = ((rgb1 and 255) * weight1 + (rgb2 and 255) * weight2) / (weight1 + weight2)
-    val a = (rgb1 shr 24) and 255
-    val result = ((a shl 24) or (r shl 16) or (g shl 8) or b).toInt()
-    return result
-}

src/main/kotlin/mods/betterfoliage/config/Config.kt

@@ -0,0 +1,180 @@
+package mods.betterfoliage.config
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.resource.discovery.ConfigurableBlockMatcher
+import mods.betterfoliage.resource.discovery.ModelTextureListConfiguration
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import net.minecraftforge.fml.config.ModConfig
+import java.util.Random
+
+private fun featureEnable() = boolean(true).lang("enabled")
+
+abstract class PopulationConfigCategory() : ConfigCategory() {
+    abstract val enabled: Boolean
+    abstract val population: Int
+
+    fun enabled(random: Random) = random.nextInt(64) < population && enabled
+}
+
+// Config singleton
+object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.MOD_ID) {
+
+    val enabled by boolean(true)
+    val nVidia by boolean(false)
+
+    object leaves : ConfigCategory() {
+        val enabled by featureEnable()
+        val snowEnabled by boolean(true)
+        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
+        val vOffset by double(max=0.4, default=0.1).lang("vOffset")
+        val size by double(min=0.75, max=2.5, default=1.4).lang("size")
+        val dense by boolean(false)
+        val hideInternal by boolean(true)
+        val saturationThreshold by double(default=0.1)
+    }
+
+    object shortGrass : PopulationConfigCategory(){
+        override val enabled by featureEnable()
+        val myceliumEnabled by boolean(true)
+        val snowEnabled by boolean(true)
+        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
+        val heightMin by double(min=0.1, max=2.5, default=0.6).lang("heightMin")
+        val heightMax by double(min=0.1, max=2.5, default=0.8).lang("heightMax")
+        val size by double(min=0.5, max=1.5, default=1.0).lang("size")
+        override val population by int(max=64, default=64).lang("population")
+        val useGenerated by boolean(false)
+        val shaderWind by boolean(true).lang("shaderWind")
+        val saturationThreshold by double(default=0.1)
+    }
+
+    object connectedGrass : ConfigCategory(){
+        val enabled by featureEnable()
+        val snowEnabled by boolean(false)
+    }
+
+    object roundLogs : ConfigCategory(){
+        val enabled by featureEnable()
+        val plantsOnly by boolean(true)
+        val radiusSmall by double(max=0.5, default=0.25)
+        val radiusLarge by double(max=0.5, default=0.44)
+        val dimming by double(default = 0.7)
+        val connectSolids by boolean(false)
+        val lenientConnect by boolean(true)
+        val connectPerpendicular by boolean(true)
+        val connectGrass by boolean(true)
+        val defaultY by boolean(false)
+        val zProtection by double(min = 0.9, default = 0.99)
+    }
+
+    object cactus : ConfigCategory(){
+        val enabled by featureEnable()
+        val size by double(min=1.0, max=2.0, default=1.3).lang("size")
+        val sizeVariation by double(max=0.5, default=0.1)
+        val hOffset by double(max=0.5, default=0.1).lang("hOffset")
+    }
+
+    object lilypad : PopulationConfigCategory(){
+        override val enabled by featureEnable()
+        val hOffset by double(max=0.25, default=0.1).lang("hOffset")
+        override val population by int(max=64, default=16, min=0)
+        val shaderWind by boolean(true).lang("shaderWind")
+    }
+
+    object reed : PopulationConfigCategory(){
+        override val enabled by featureEnable()
+        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
+        val heightMin by double(min=1.5, max=3.5, default=1.7).lang("heightMin")
+        val heightMax by double(min=1.5, max=3.5, default=2.2).lang("heightMax")
+        override val population by int(max=64, default=32).lang("population")
+        val minBiomeTemp by double(default=0.4)
+        val minBiomeRainfall by double(default=0.4)
+//        val biomes by biomeList { it.filterTemp(0.4f, null) && it.filterRain(0.4f, null) }
+        val shaderWind by boolean(true).lang("shaderWind")
+    }
+
+    object algae : PopulationConfigCategory(){
+        override val enabled by featureEnable()
+        val hOffset by double(max=0.25, default=0.1).lang("hOffset")
+        val size by double(min=0.5, max=1.5, default=1.0).lang("size")
+        val heightMin by double(min=0.1, max=1.5, default=0.5).lang("heightMin")
+        val heightMax by double(min=0.1, max=1.5, default=1.0).lang("heightMax")
+        override val population by int(max=64, default=48).lang("population")
+//        val biomes by biomeList { it.filterClass("river", "ocean") }
+        val shaderWind by boolean(true).lang("shaderWind")
+    }
+
+    object coral : PopulationConfigCategory(){
+        override val enabled by featureEnable()
+        val shallowWater by boolean(false)
+        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
+        val vOffset by double(max=0.4, default=0.1).lang("vOffset")
+        val size by double(min=0.5, max=1.5, default=0.7).lang("size")
+        val crustSize by double(min=0.5, max=1.5, default=1.4)
+        val chance by int(max=64, default=32)
+        override val population by int(max=64, default=48).lang("population")
+//        val biomes by biomeList { it.filterClass("river", "ocean", "beach") }
+    }
+
+    object netherrack : ConfigCategory(){
+        val enabled by featureEnable()
+        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
+        val heightMin by double(min=0.1, max=1.5, default=0.2).lang("heightMin")
+        val heightMax by double(min=0.1, max=1.5, default=0.5).lang("heightMax")
+        val size by double(min=0.5, max=1.5, default=1.0).lang("size")
+    }
+
+    object fallingLeaves : ConfigCategory(){
+        val enabled by featureEnable()
+        val speed by double(min=0.01, max=0.15, default=0.05)
+        val windStrength by double(min=0.1, max=2.0, default=0.5)
+        val stormStrength by double(min=0.1, max=2.0, default=0.8)
+        val size by double(min=0.25, max=1.5, default=0.75).lang("size")
+        val chance by double(min=0.001, max=1.0, default=0.02)
+        val perturb by double(min=0.01, max=1.0, default=0.25)
+        val lifetime by double(min=1.0, max=15.0, default=5.0)
+        val opacityHack by boolean(true)
+    }
+
+    object risingSoul : ConfigCategory(){
+        val enabled by featureEnable()
+        val chance by double(min=0.001, max=1.0, default=0.02)
+        val perturb by double(min=0.01, max=0.25, default=0.05)
+        val headSize by double(min=0.25, max=1.5, default=1.0)
+        val trailSize by double(min=0.25, max=1.5, default=0.75)
+        val opacity by double(min=0.05, max=1.0, default=0.5)
+        val sizeDecay by double(min=0.5, max=1.0, default=0.97)
+        val opacityDecay by double(min=0.5, max=1.0, default=0.97)
+        val lifetime by double(min=1.0, max=15.0, default=4.0)
+        val trailLength by int(min=2, max=128, default=48)
+        val trailDensity by int(min=1, max=16, default=3)
+    }
+
+}
+
+object BlockConfig {
+    private val list = mutableListOf<Any>()
+
+    val leafBlocks = blocks("leaves_blocks_default.cfg")
+    val leafModels = models("leaves_models_default.cfg")
+    val grassBlocks = blocks("grass_blocks_default.cfg")
+    val grassModels = models("grass_models_default.cfg")
+    val mycelium = blocks("mycelium_blocks_default.cfg")
+//    val dirt = blocks("dirt_default.cfg")
+    val crops = blocks("crop_default.cfg")
+    val logBlocks = blocks("log_blocks_default.cfg")
+    val logModels = models("log_models_default.cfg")
+    val lilypad = blocks("lilypad_default.cfg")
+
+    init { BetterFoliageMod.bus.register(this) }
+    private fun blocks(cfgName: String) = ConfigurableBlockMatcher(ResourceLocation(BetterFoliageMod.MOD_ID, cfgName)).apply { list.add(this) }
+    private fun models(cfgName: String) = ModelTextureListConfiguration(ResourceLocation(BetterFoliageMod.MOD_ID, cfgName)).apply { list.add(this) }
+
+    @SubscribeEvent
+    fun onConfig(event: ModConfig.ModConfigEvent) {
+        list.forEach { when(it) {
+            is ConfigurableBlockMatcher -> it.readDefaults()
+            is ModelTextureListConfiguration -> it.readDefaults()
+        } }
+    }
+}

src/main/kotlin/mods/betterfoliage/config/DelegatingConfig.kt

@@ -0,0 +1,89 @@
+@file:JvmName("DelegatingConfigKt")
+
+package mods.betterfoliage.config
+
+import mods.betterfoliage.util.reflectDelegates
+import mods.betterfoliage.util.reflectNestedObjects
+import net.minecraftforge.common.ForgeConfigSpec
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+open class DelegatingConfig(val modId: String, val langPrefix: String) {
+    fun build() = ForgeConfigSpec.Builder().apply { ConfigBuildContext(langPrefix, emptyList(), this).addCategory(this@DelegatingConfig) }.build()
+}
+
+class ConfigBuildContext(val langPrefix: String, val path: List<String>, val builder: ForgeConfigSpec.Builder) {
+
+    fun addCategory(configObj: Any) {
+        configObj.reflectNestedObjects.forEach { (name, category) ->
+            builder.push(name)
+            descend(name).addCategory(category)
+            builder.pop()
+        }
+        configObj.reflectDelegates(ConfigDelegate::class.java).forEach { (name, delegate) ->
+            descend(name).apply { delegate.addToBuilder(this) }
+        }
+    }
+
+    fun descend(pathName: String) = ConfigBuildContext(langPrefix, path + pathName, builder)
+}
+
+open class ConfigCategory(val comment: String? = null) {
+}
+
+abstract class ConfigDelegate<T> : ReadOnlyProperty<Any, T> {
+    lateinit var configValue: ForgeConfigSpec.ConfigValue<T>
+    var cachedValue: T? = null
+
+    override fun getValue(thisRef: Any, property: KProperty<*>): T {
+        if (cachedValue == null) cachedValue = configValue.get()
+        return cachedValue!!
+    }
+
+    abstract fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder): ForgeConfigSpec.ConfigValue<T>
+    fun addToBuilder(ctx: ConfigBuildContext) {
+        val langKey = ctx.langPrefix + "." + (langPrefixOverride ?: ctx.path.joinToString("."))
+        ctx.builder.translation(langKey)
+        configValue = getConfigValue(ctx.path.last(), ctx.builder)
+    }
+
+    var langPrefixOverride: String? = null
+    fun lang(prefix: String) = apply { langPrefixOverride = prefix }
+
+}
+
+class DelegatingBooleanValue(val defaultValue: Boolean) : ConfigDelegate<Boolean>() {
+    override fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder) = builder.define(name, defaultValue)
+}
+
+class DelegatingIntValue(
+    val minValue: Int = 0,
+    val maxValue: Int = 1,
+    val defaultValue: Int = 0
+) : ConfigDelegate<Int>() {
+    override fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder) = builder.defineInRange(name, defaultValue, minValue, maxValue)
+}
+
+class DelegatingLongValue(
+    val minValue: Long = 0,
+    val maxValue: Long = 1,
+    val defaultValue: Long = 0
+) : ConfigDelegate<Long>() {
+    override fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder) = builder.defineInRange(name, defaultValue, minValue, maxValue)
+}
+
+class DelegatingDoubleValue(
+    val minValue: Double = 0.0,
+    val maxValue: Double = 1.0,
+    val defaultValue: Double = 0.0
+) : ConfigDelegate<Double>() {
+    override fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder) = builder.defineInRange(name, defaultValue, minValue, maxValue)
+}
+
+// ============================
+// Delegate factory methods
+// ============================
+fun double(min: Double = 0.0, max: Double = 1.0, default: Double) = DelegatingDoubleValue(min, max, default)
+fun int(min: Int = 0, max: Int, default: Int) = DelegatingIntValue(min, max, default)
+fun long(min: Long = 0, max: Long, default: Long) = DelegatingLongValue(min, max, default)
+fun boolean(default: Boolean) = DelegatingBooleanValue(default)

src/main/kotlin/mods/betterfoliage/config/MiscDefaults.kt

@@ -0,0 +1,20 @@
+package mods.betterfoliage.config
+
+import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
+import net.minecraft.block.material.Material
+import net.minecraft.world.biome.Biome
+
+val CACTUS_BLOCKS = listOf(Blocks.CACTUS)
+val DIRT_BLOCKS = listOf(Blocks.DIRT, Blocks.COARSE_DIRT, Blocks.PODZOL)
+val SAND_BLOCKS = listOf(Blocks.SAND, Blocks.RED_SAND)
+val NETHERRACK_BLOCKS = listOf(Blocks.NETHERRACK)
+val LILYPAD_BLOCKS = listOf(Blocks.LILY_PAD)
+val MYCELIUM_BLOCKS = listOf(Blocks.MYCELIUM)
+
+val SALTWATER_BIOMES = listOf(Biome.Category.BEACH, Biome.Category.OCEAN)
+
+val SNOW_MATERIALS = listOf(Material.TOP_SNOW, Material.SNOW)
+val BlockState.isSnow: Boolean get() = material in SNOW_MATERIALS
+
+val ACCEPTED_ROUND_LOG_MATERIALS = listOf(Material.WOOD, Material.GRASS)

src/main/kotlin/mods/betterfoliage/integration/OptifineCustomColors.kt

@@ -0,0 +1,54 @@
+package mods.betterfoliage.integration
+
+import mods.betterfoliage.chunk.BlockCtx
+import mods.betterfoliage.util.ThreadLocalDelegate
+import mods.betterfoliage.util.allAvailable
+import mods.betterfoliage.util.reflectField
+import mods.octarinecore.BlockPos
+import mods.octarinecore.BlockState
+import mods.octarinecore.CustomColors
+import mods.octarinecore.RenderEnv
+import net.minecraft.block.BlockState
+import net.minecraft.client.Minecraft
+import net.minecraft.client.renderer.model.BakedQuad
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.level.ColorResolver
+import org.apache.logging.log4j.Level.INFO
+import org.apache.logging.log4j.LogManager
+
+/**
+ * Integration for OptiFine custom block colors.
+ */
+@Suppress("UNCHECKED_CAST")
+object OptifineCustomColors {
+    val logger = LogManager.getLogger(this)
+
+    val isColorAvailable = allAvailable(CustomColors, CustomColors.getColorMultiplier)
+
+    init {
+        logger.log(INFO, "Optifine custom color support is ${if (isColorAvailable) "enabled" else "disabled" }")
+    }
+
+    val renderEnv by ThreadLocalDelegate { OptifineRenderEnv() }
+    val fakeQuad = BakedQuad(IntArray(0), 1, UP, null, true)
+
+    fun getBlockColor(ctx: BlockCtx, resolver: ColorResolver): Int {
+        val ofColor = if (isColorAvailable && Minecraft.getInstance().options.reflectField<Boolean>("ofCustomColors") == true) {
+            renderEnv.reset(ctx.state, ctx.pos)
+            CustomColors.getColorMultiplier.invokeStatic(fakeQuad, ctx.state, ctx.world, ctx.pos, renderEnv.wrapped) as? Int
+        } else null
+        return if (ofColor == null || ofColor == -1) ctx.color(resolver) else ofColor
+    }
+}
+
+class OptifineRenderEnv {
+    val wrapped: Any = RenderEnv.element!!.getDeclaredConstructor(BlockState.element, BlockPos.element).let {
+        it.isAccessible = true
+        it.newInstance(null, null)
+    }
+
+    fun reset(state: BlockState, pos: BlockPos) {
+        RenderEnv.reset.invoke(wrapped, state, pos)
+    }
+}

src/main/kotlin/mods/betterfoliage/integration/ShadersModIntegration.kt

@@ -0,0 +1,66 @@
+package mods.betterfoliage.integration
+
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.render.pipeline.RenderCtxVanilla
+import mods.betterfoliage.util.HasLogger
+import mods.betterfoliage.util.allAvailable
+import mods.betterfoliage.util.get
+import mods.octarinecore.*
+import net.minecraft.block.BlockRenderType
+import net.minecraft.block.BlockRenderType.MODEL
+import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
+import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockDisplayReader
+import org.apache.logging.log4j.Level.INFO
+
+/**
+ * Integration for ShadersMod.
+ */
+object ShadersModIntegration : HasLogger() {
+    @JvmStatic val isAvailable = allAvailable(SVertexBuilder, SVertexBuilder.pushState, SVertexBuilder.popState, BlockAliases.getAliasBlockId)
+
+    val defaultLeaves = Blocks.OAK_LEAVES.defaultBlockState()
+    val defaultGrass = Blocks.GRASS.defaultBlockState()
+
+    /**
+     * Called from transformed ShadersMod code.
+     * @see mods.betterfoliage.loader.BetterFoliageTransformer
+     */
+    @JvmStatic fun getBlockStateOverride(state: BlockState, world: IBlockDisplayReader, pos: BlockPos): BlockState {
+//        if (LeafRegistry[state, world, pos] != null) return defaultLeaves
+//        if (BlockConfig.crops.matchesClass(state.block)) return defaultGrass
+        return state
+    }
+
+    init {
+        logger.log(INFO, "ShadersMod integration is ${if (isAvailable) "enabled" else "disabled" }")
+    }
+
+    /** Quads rendered inside this block will use the given block entity data in shader programs. */
+    inline fun renderAs(buffer: BufferBuilder, state: BlockState, renderType: BlockRenderType, enabled: Boolean = true, func: ()->Unit) {
+        if (isAvailable && enabled) {
+            val aliasBlockId = BlockAliases.getAliasBlockId.invokeStatic(state)
+            val sVertexBuilder = buffer[BufferBuilder_sVertexBuilder]
+            SVertexBuilder.pushState.invoke(sVertexBuilder, aliasBlockId)
+            func()
+            SVertexBuilder.popState.invoke(sVertexBuilder)
+        } else {
+            func()
+        }
+    }
+
+    /** Quads rendered inside this block will behave as tallgrass blocks in shader programs. */
+    inline fun grass(ctx: RenderCtxBase, enabled: Boolean = true, func: ()->Unit) =
+        ((ctx as? RenderCtxVanilla)?.buffer as? BufferBuilder)?.let { bufferBuilder ->
+            renderAs(bufferBuilder, defaultGrass, MODEL, enabled, func)
+        }
+
+
+    /** Quads rendered inside this block will behave as leaf blocks in shader programs. */
+    inline fun leaves(ctx: RenderCtxBase, enabled: Boolean = true, func: ()->Unit) =
+        ((ctx as? RenderCtxVanilla)?.buffer as? BufferBuilder)?.let { bufferBuilder ->
+            renderAs(bufferBuilder, defaultLeaves, MODEL, enabled, func)
+        }
+}

src/main/kotlin/mods/betterfoliage/loader/BetterFoliageCore.kt

@@ -1,138 +0,0 @@
-package mods.betterfoliage.loader
-
-import mods.octarinecore.metaprog.Transformer
-import mods.octarinecore.metaprog.allAvailable
-import net.minecraftforge.fml.relauncher.FMLLaunchHandler
-import org.objectweb.asm.ClassWriter
-import org.objectweb.asm.ClassWriter.COMPUTE_FRAMES
-import org.objectweb.asm.ClassWriter.COMPUTE_MAXS
-import org.objectweb.asm.Opcodes.*
-
-class BetterFoliageTransformer : Transformer() {
-
-    val isOptifinePresent = allAvailable(Refs.OptifineClassTransformer)
-
-    init {
-        if (FMLLaunchHandler.side().isClient) setupClient()
-    }
-
-    fun setupClient() {
-        // where: WorldClient.showBarrierParticles(), right after invoking Block.randomDisplayTick
-        // what: invoke BF code for every random display tick
-        // why: allows us to catch random display ticks, without touching block code
-        transformMethod(Refs.showBarrierParticles) {
-            find(invokeRef(Refs.randomDisplayTick))?.insertAfter {
-                log.info("[BetterFoliageLoader] Applying random display tick call hook")
-                varinsn(ALOAD, 0)
-                varinsn(ALOAD, 11)
-                varinsn(ALOAD, 7)
-                invokeStatic(Refs.onRandomDisplayTick)
-            } ?: log.warn("[BetterFoliageLoader] Failed to apply random display tick call hook!")
-        }
-
-        // where: BlockStateContainer$StateImplementation.getAmbientOcclusionLightValue()
-        // what: invoke BF code to overrule AO transparency value
-        // why: allows us to have light behave properly on non-solid log blocks
-        transformMethod(Refs.getAmbientOcclusionLightValue) {
-            find(FRETURN)?.insertBefore {
-                log.info("[BetterFoliageLoader] Applying getAmbientOcclusionLightValue() override")
-                varinsn(ALOAD, 0)
-                invokeStatic(Refs.getAmbientOcclusionLightValueOverride)
-            } ?: log.warn("[BetterFoliageLoader] Failed to apply getAmbientOcclusionLightValue() override!")
-        }
-
-        // where: BlockStateContainer$StateImplementation.useNeighborBrightness()
-        // what: invoke BF code to overrule _useNeighborBrightness_
-        // why: allows us to have light behave properly on non-solid log blocks
-        transformMethod(Refs.useNeighborBrightness) {
-            find(IRETURN)?.insertBefore {
-                log.info("[BetterFoliageLoader] Applying useNeighborBrightness() override")
-                varinsn(ALOAD, 0)
-                invokeStatic(Refs.useNeighborBrightnessOverride)
-            } ?: log.warn("[BetterFoliageLoader] Failed to apply useNeighborBrightness() override!")
-        }
-
-        // where: BlockStateContainer$StateImplementation.doesSideBlockRendering()
-        // what: invoke BF code to overrule condition
-        // why: allows us to make log blocks non-solid
-        transformMethod(Refs.doesSideBlockRendering) {
-            find(IRETURN)?.insertBefore {
-                log.info("[BetterFoliageLoader] Applying doesSideBlockRendering() override")
-                varinsn(ALOAD, 1)
-                varinsn(ALOAD, 2)
-                varinsn(ALOAD, 3)
-                invokeStatic(Refs.doesSideBlockRenderingOverride)
-            } ?: log.warn("[BetterFoliageLoader] Failed to apply doesSideBlockRendering() override!")
-        }
-
-        // where: BlockStateContainer$StateImplementation.isOpaqueCube()
-        // what: invoke BF code to overrule condition
-        // why: allows us to make log blocks non-solid
-        transformMethod(Refs.isOpaqueCube) {
-            find(IRETURN)?.insertBefore {
-                log.info("[BetterFoliageLoader] Applying isOpaqueCube() override")
-                varinsn(ALOAD, 0)
-                invokeStatic(Refs.isOpaqueCubeOverride)
-            } ?: log.warn("[BetterFoliageLoader] Failed to apply isOpaqueCube() override!")
-        }
-
-        // where: ModelLoader.setupModelRegistry(), right before the textures are loaded
-        // what: invoke handler code with ModelLoader instance
-        // why: allows us to iterate the unbaked models in ModelLoader in time to register textures
-        transformMethod(Refs.setupModelRegistry) {
-            find(invokeName("addAll"))?.insertAfter {
-                log.info("[BetterFoliageLoader] Applying ModelLoader lifecycle callback")
-                varinsn(ALOAD, 0)
-                invokeStatic(Refs.onAfterLoadModelDefinitions)
-            } ?: log.warn("[BetterFoliageLoader] Failed to apply ModelLoader lifecycle callback!")
-        }
-
-        // where: RenderChunk.rebuildChunk()
-        // what: replace call to BlockRendererDispatcher.renderBlock()
-        // why: allows us to perform additional rendering for each block
-        // what: invoke code to overrule result of Block.canRenderInLayer()
-        // why: allows us to render transparent quads for blocks which are only on the SOLID layer
-        transformMethod(Refs.rebuildChunk) {
-            applyWriterFlags(COMPUTE_FRAMES, COMPUTE_MAXS)
-            find(invokeRef(Refs.renderBlock))?.replace {
-                log.info("[BetterFoliageLoader] Applying RenderChunk block render override")
-                varinsn(ALOAD, if (isOptifinePresent) 22 else 20)
-                invokeStatic(Refs.renderWorldBlock)
-            }
-            if (isOptifinePresent) {
-                find(varinsn(ISTORE, 23))?.insertAfter {
-                    log.info("[BetterFoliageLoader] Applying RenderChunk block layer override (Optifine)")
-                    varinsn(ALOAD, 19)
-                    varinsn(ALOAD, 18)
-                    varinsn(ALOAD, 22)
-                    invokeStatic(Refs.canRenderBlockInLayer)
-                    varinsn(ISTORE, 23)
-                }
-            } else {
-                find(invokeRef(Refs.canRenderInLayer))?.replace {
-                    log.info("[BetterFoliageLoader] Applying RenderChunk block layer override (non-Optifine)")
-                    invokeStatic(Refs.canRenderBlockInLayer)
-                }
-            }
-        }
-
-        // where: net.minecraft.client.renderer.BlockModelRenderer$AmbientOcclusionFace
-        // what: make constructor public
-        // why: use vanilla AO calculation at will without duplicating code
-        transformMethod(Refs.AOF_constructor) {
-            log.info("[BetterFoliageLoader] Setting AmbientOcclusionFace constructor public")
-            makePublic()
-        }
-
-        // where: shadersmod.client.SVertexBuilder.pushEntity()
-        // what: invoke code to overrule block data
-        // why: allows us to change the block ID seen by shader programs
-        transformMethod(Refs.pushEntity_state) {
-            find(invokeRef(Refs.pushEntity_num))?.insertBefore {
-                log.info("[BetterFoliageLoader] Applying SVertexBuilder.pushEntity() block ID override")
-                varinsn(ALOAD, 0)
-                invokeStatic(Refs.getBlockIdOverride)
-            } ?: log.warn("[BetterFoliageLoader] Failed to apply SVertexBuilder.pushEntity() block ID override!")
-        }
-    }
-}

src/main/kotlin/mods/betterfoliage/loader/Refs.kt

@@ -1,117 +0,0 @@
-package mods.betterfoliage.loader
-
-import mods.octarinecore.metaprog.ClassRef
-import mods.octarinecore.metaprog.FieldRef
-import mods.octarinecore.metaprog.MethodRef
-import net.minecraftforge.fml.relauncher.FMLInjectionData
-
-/** Singleton object holding references to foreign code elements. */
-object Refs {
-    val mcVersion = FMLInjectionData.data()[4].toString()
-
-    // Java
-    val String = ClassRef("java.lang.String")
-    val Map = ClassRef("java.util.Map")
-    val List = ClassRef("java.util.List")
-    val Random = ClassRef("java.util.Random")
-
-    // Minecraft
-    val IBlockAccess = ClassRef("net.minecraft.world.IBlockAccess")
-    val IBlockState = ClassRef("net.minecraft.block.state.IBlockState")
-    val BlockStateBase = ClassRef("net.minecraft.block.state.BlockStateBase")
-    val BlockPos = ClassRef("net.minecraft.util.math.BlockPos")
-    val MutableBlockPos = ClassRef("net.minecraft.util.math.BlockPos\$MutableBlockPos")
-    val BlockRenderLayer = ClassRef("net.minecraft.util.BlockRenderLayer")
-    val EnumFacing = ClassRef("net.minecraft.util.EnumFacing")
-
-    val World = ClassRef("net.minecraft.world.World")
-    val WorldClient = ClassRef("net.minecraft.client.multiplayer.WorldClient")
-    val ChunkCache = ClassRef("net.minecraft.world.ChunkCache")
-    val showBarrierParticles = MethodRef(WorldClient, "showBarrierParticles", "func_184153_a", ClassRef.void, ClassRef.int, ClassRef.int, ClassRef.int, ClassRef.int, Random, ClassRef.boolean, MutableBlockPos)
-
-    val Block = ClassRef("net.minecraft.block.Block")
-    val StateImplementation = ClassRef("net.minecraft.block.state.BlockStateContainer\$StateImplementation")
-    val canRenderInLayer = MethodRef(Block, "canRenderInLayer", ClassRef.boolean, IBlockState, BlockRenderLayer)
-    val getAmbientOcclusionLightValue = MethodRef(StateImplementation, "getAmbientOcclusionLightValue", "func_185892_j", ClassRef.float)
-    val useNeighborBrightness = MethodRef(StateImplementation, "useNeighborBrightness", "func_185916_f", ClassRef.boolean)
-    val doesSideBlockRendering = MethodRef(StateImplementation, "doesSideBlockRendering", ClassRef.boolean, IBlockAccess, BlockPos, EnumFacing)
-    val isOpaqueCube = MethodRef(StateImplementation, "isOpaqueCube", "func_185914_p", ClassRef.boolean)
-    val randomDisplayTick = MethodRef(Block, "randomDisplayTick", "func_180655_c", ClassRef.void, IBlockState, World, BlockPos, Random)
-
-    val BlockModelRenderer = ClassRef("net.minecraft.client.renderer.BlockModelRenderer")
-    val AmbientOcclusionFace = ClassRef("net.minecraft.client.renderer.BlockModelRenderer\$AmbientOcclusionFace")
-    val ChunkCompileTaskGenerator = ClassRef("net.minecraft.client.renderer.chunk.ChunkCompileTaskGenerator")
-    val BufferBuilder = ClassRef("net.minecraft.client.renderer.BufferBuilder")
-    val AOF_constructor = MethodRef(AmbientOcclusionFace, "<init>", ClassRef.void, BlockModelRenderer)
-
-    val RenderChunk = ClassRef("net.minecraft.client.renderer.chunk.RenderChunk")
-    val rebuildChunk = MethodRef(RenderChunk, "rebuildChunk", "func_178581_b", ClassRef.void, ClassRef.float, ClassRef.float, ClassRef.float, ChunkCompileTaskGenerator)
-
-    val BlockRendererDispatcher = ClassRef("net.minecraft.client.renderer.BlockRendererDispatcher")
-    val renderBlock = MethodRef(BlockRendererDispatcher, "renderBlock", "func_175018_a", ClassRef.boolean, IBlockState, BlockPos, IBlockAccess, BufferBuilder)
-
-    val TextureAtlasSprite = ClassRef("net.minecraft.client.renderer.texture.TextureAtlasSprite")
-
-    val IRegistry = ClassRef("net.minecraft.util.registry.IRegistry")
-    val ModelLoader = ClassRef("net.minecraftforge.client.model.ModelLoader")
-    val stateModels = FieldRef(ModelLoader, "stateModels", Map)
-    val setupModelRegistry = MethodRef(ModelLoader, "setupModelRegistry", "func_177570_a", IRegistry)
-
-    val IModel = ClassRef("net.minecraftforge.client.model.IModel")
-    val ModelBlock = ClassRef("net.minecraft.client.renderer.block.model.ModelBlock")
-    val ResourceLocation = ClassRef("net.minecraft.util.ResourceLocation")
-    val ModelResourceLocation = ClassRef("net.minecraft.client.renderer.block.model.ModelResourceLocation")
-    val VanillaModelWrapper = ClassRef("net.minecraftforge.client.model.ModelLoader\$VanillaModelWrapper")
-    val model_VMW = FieldRef(VanillaModelWrapper, "model", ModelBlock)
-    val location_VMW = FieldRef(VanillaModelWrapper, "location", ModelBlock)
-    val WeightedRandomModel = ClassRef("net.minecraftforge.client.model.ModelLoader\$WeightedRandomModel")
-    val models_WRM = FieldRef(WeightedRandomModel, "models", List)
-    val MultiModel = ClassRef("net.minecraftforge.client.model.MultiModel")
-    val base_MM = FieldRef(MultiModel, "base", IModel)
-    val MultipartModel = ClassRef("net.minecraftforge.client.model.ModelLoader\$MultipartModel")
-    val partModels_MPM = FieldRef(MultipartModel, "partModels", List)
-
-    val BakedQuad = ClassRef("net.minecraft.client.renderer.block.model.BakedQuad")
-
-    val resetChangedState = MethodRef(ClassRef("net.minecraftforge.common.config.Configuration"), "resetChangedState", ClassRef.void)
-
-
-    // Better Foliage
-    val BetterFoliageHooks = ClassRef("mods.betterfoliage.client.Hooks")
-    val getAmbientOcclusionLightValueOverride = MethodRef(BetterFoliageHooks, "getAmbientOcclusionLightValueOverride", ClassRef.float, ClassRef.float, IBlockState)
-    val useNeighborBrightnessOverride = MethodRef(BetterFoliageHooks, "getUseNeighborBrightnessOverride", ClassRef.boolean, ClassRef.boolean, IBlockState)
-    val doesSideBlockRenderingOverride = MethodRef(BetterFoliageHooks, "doesSideBlockRenderingOverride", ClassRef.boolean, ClassRef.boolean, IBlockAccess, BlockPos, EnumFacing)
-    val isOpaqueCubeOverride = MethodRef(BetterFoliageHooks, "isOpaqueCubeOverride", ClassRef.boolean, ClassRef.boolean, IBlockState)
-    val onRandomDisplayTick = MethodRef(BetterFoliageHooks, "onRandomDisplayTick", ClassRef.void, World, IBlockState, BlockPos)
-    val onAfterLoadModelDefinitions = MethodRef(BetterFoliageHooks, "onAfterLoadModelDefinitions", ClassRef.void, ModelLoader)
-    val onAfterBakeModels = MethodRef(BetterFoliageHooks, "onAfterBakeModels", ClassRef.void, Map)
-    val renderWorldBlock = MethodRef(BetterFoliageHooks, "renderWorldBlock", ClassRef.boolean, BlockRendererDispatcher, IBlockState, BlockPos, IBlockAccess, BufferBuilder, BlockRenderLayer)
-    val canRenderBlockInLayer = MethodRef(BetterFoliageHooks, "canRenderBlockInLayer", ClassRef.boolean, Block, IBlockState, BlockRenderLayer)
-
-    // Optifine
-    val OptifineClassTransformer = ClassRef("optifine.OptiFineClassTransformer")
-    val OptifineChunkCache = ClassRef("net.optifine.override.ChunkCacheOF")
-    val CCOFChunkCache = FieldRef(OptifineChunkCache, "chunkCache", ChunkCache)
-
-    val getBlockId = MethodRef(BlockStateBase, "getBlockId", ClassRef.int);
-    val getMetadata = MethodRef(BlockStateBase, "getMetadata", ClassRef.int);
-
-    // Optifine
-    val RenderEnv = ClassRef("net.optifine.render.RenderEnv")
-    val RenderEnv_reset = MethodRef(RenderEnv, "reset", ClassRef.void, IBlockState, BlockPos)
-    val quadSprite = FieldRef(BufferBuilder, "quadSprite", TextureAtlasSprite)
-
-    // Optifine: custom colors
-    val CustomColors = ClassRef("net.optifine.CustomColors")
-    val getColorMultiplier = MethodRef(CustomColors, "getColorMultiplier", ClassRef.int, BakedQuad, IBlockState, IBlockAccess, BlockPos, RenderEnv)
-
-    // Optifine: shaders
-    val SVertexBuilder = ClassRef("net.optifine.shaders.SVertexBuilder")
-    val sVertexBuilder = FieldRef(BufferBuilder, "sVertexBuilder", SVertexBuilder)
-    val pushEntity_state = MethodRef(SVertexBuilder, "pushEntity", ClassRef.void, IBlockState, BlockPos, IBlockAccess, BufferBuilder)
-    val pushEntity_num = MethodRef(SVertexBuilder, "pushEntity", ClassRef.void, ClassRef.long)
-    val popEntity = MethodRef(SVertexBuilder, "popEntity", ClassRef.void)
-
-    val ShadersModIntegration = ClassRef("mods.betterfoliage.client.integration.ShadersModIntegration")
-    val getBlockIdOverride = MethodRef(ShadersModIntegration, "getBlockIdOverride", ClassRef.long, ClassRef.long, IBlockState)
-}

src/main/kotlin/mods/betterfoliage/model/HalfBaked.kt

@@ -0,0 +1,118 @@
+package mods.betterfoliage.model
+
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelBakingKey
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.HasLogger
+import mods.betterfoliage.util.directionsAndNull
+import mods.betterfoliage.util.mapArray
+import net.minecraft.client.renderer.model.BakedQuad
+import net.minecraft.client.renderer.model.IBakedModel
+import net.minecraft.client.renderer.model.SimpleBakedModel
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats
+import net.minecraft.client.renderer.vertex.VertexFormatElement
+import net.minecraftforge.client.model.pipeline.BakedQuadBuilder
+import java.util.Random
+
+/**
+ * Hybrid baked quad implementation, carrying both baked and unbaked information.
+ * Used to do advanced vertex lighting without unbaking vertex data at lighting time.
+ */
+data class HalfBakedQuad(
+    val raw: Quad,
+    val baked: BakedQuad
+)
+
+open class HalfBakedSimpleModelWrapper(baseModel: SimpleBakedModel): IBakedModel by baseModel, SpecialRenderModel {
+    val baseQuads = baseModel.unbakeQuads()
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        ctx.renderQuads(baseQuads)
+    }
+}
+
+open class HalfBakedSpecialWrapper(val baseModel: SpecialRenderModel): IBakedModel by baseModel, SpecialRenderModel {
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        baseModel.render(ctx, noDecorations)
+    }
+}
+
+abstract class HalfBakedWrapperKey : ModelBakingKey, HasLogger() {
+    override fun bake(ctx: ModelBakingContext): IBakedModel? {
+        val baseModel = super.bake(ctx)
+        val halfBaked = when(baseModel) {
+            is SimpleBakedModel -> HalfBakedSimpleModelWrapper(baseModel)
+            else -> null
+        }
+        return if (halfBaked == null) baseModel else bake(ctx, halfBaked)
+    }
+
+    abstract fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel): SpecialRenderModel
+}
+
+fun List<Quad>.bake(applyDiffuseLighting: Boolean) = map { quad ->
+    if (quad.sprite == null) throw IllegalStateException("Quad must have a texture assigned before baking")
+    val builder = BakedQuadBuilder(quad.sprite)
+    builder.setApplyDiffuseLighting(applyDiffuseLighting)
+    builder.setQuadOrientation(quad.face())
+    builder.setQuadTint(quad.colorIndex)
+    quad.verts.forEach { vertex ->
+        DefaultVertexFormats.BLOCK.elements.forEachIndexed { idx, element ->
+            when {
+                element.usage == VertexFormatElement.Usage.POSITION -> builder.put(idx,
+                    (vertex.xyz.x + 0.5).toFloat(),
+                    (vertex.xyz.y + 0.5).toFloat(),
+                    (vertex.xyz.z + 0.5).toFloat(),
+                    1.0f
+                )
+                // don't fill lightmap UV coords
+                element.usage == VertexFormatElement.Usage.UV && element.type == VertexFormatElement.Type.FLOAT -> builder.put(idx,
+                    quad.sprite.u0 + (quad.sprite.u1 - quad.sprite.u0) * (vertex.uv.u + 0.5).toFloat(),
+                    quad.sprite.v0 + (quad.sprite.v1 - quad.sprite.v0) * (vertex.uv.v + 0.5).toFloat(),
+                    0.0f, 1.0f
+                )
+                element.usage == VertexFormatElement.Usage.COLOR -> builder.put(idx,
+                    (vertex.color.red and 255).toFloat() / 255.0f,
+                    (vertex.color.green and 255).toFloat() / 255.0f,
+                    (vertex.color.blue and 255).toFloat() / 255.0f,
+                    (vertex.color.alpha and 255).toFloat() / 255.0f
+                )
+                element.usage == VertexFormatElement.Usage.NORMAL -> builder.put(idx,
+                    (vertex.normal ?: quad.normal).x.toFloat(),
+                    (vertex.normal ?: quad.normal).y.toFloat(),
+                    (vertex.normal ?: quad.normal).z.toFloat(),
+                    0.0f
+                )
+                else -> builder.put(idx)
+            }
+        }
+    }
+    HalfBakedQuad(quad, builder.build())
+}
+
+fun Array<List<Quad>>.bake(applyDiffuseLighting: Boolean) = mapArray { it.bake(applyDiffuseLighting) }
+
+fun BakedQuad.unbake(): HalfBakedQuad {
+    val size = DefaultVertexFormats.BLOCK.integerSize
+    val verts = Array(4) { vIdx ->
+        val x = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 0])
+        val y = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 1])
+        val z = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 2])
+        val color = vertices[vIdx * size + 3]
+        val u = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 4])
+        val v = java.lang.Float.intBitsToFloat(vertices[vIdx * size + 5])
+        Vertex(Double3(x, y, z), UV(u.toDouble(), v.toDouble()), Color(color))
+    }
+    val unbaked = Quad(
+        verts[0], verts[1], verts[2], verts[3],
+        colorIndex = if (isTinted) tintIndex else -1,
+        face = direction
+    )
+    return HalfBakedQuad(unbaked, this)
+}
+
+fun SimpleBakedModel.unbakeQuads() = directionsAndNull.flatMap { face ->
+    getQuads(null, face, Random()).map { it.unbake() }
+}
+

src/main/kotlin/mods/betterfoliage/model/Quads.kt

@@ -0,0 +1,207 @@
+package mods.betterfoliage.model
+
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.boxFaces
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.minmax
+import mods.betterfoliage.util.nearestAngle
+import mods.betterfoliage.util.rotate
+import mods.betterfoliage.util.times
+import mods.betterfoliage.util.vec
+import net.minecraft.client.renderer.texture.NativeImage
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.Direction
+import java.lang.Math.max
+import java.lang.Math.min
+import java.util.Random
+import kotlin.math.cos
+import kotlin.math.sin
+
+/**
+ * Vertex UV coordinates
+ *
+ * Zero-centered: coordinates fall between (-0.5, 0.5) (inclusive)
+ */
+data class UV(val u: Double, val v: Double) {
+    companion object {
+        val topLeft = UV(-0.5, -0.5)
+        val topRight = UV(0.5, -0.5)
+        val bottomLeft = UV(-0.5, 0.5)
+        val bottomRight = UV(0.5, 0.5)
+    }
+
+    val rotate: UV get() = UV(v, -u)
+
+    fun rotate(n: Int) = when (n % 4) {
+        0 -> copy()
+        1 -> UV(v, -u)
+        2 -> UV(-u, -v)
+        else -> UV(-v, u)
+    }
+
+    fun clamp(minU: Double = -0.5, maxU: Double = 0.5, minV: Double = -0.5, maxV: Double = 0.5) =
+        UV(u.minmax(minU, maxU), v.minmax(minV, maxV))
+
+    fun mirror(mirrorU: Boolean, mirrorV: Boolean) = UV(if (mirrorU) -u else u, if (mirrorV) -v else v)
+}
+
+/**
+ * Model vertex
+ *
+ * @param[xyz] x, y, z coordinates
+ * @param[uv] u, v coordinates
+ * @param[aoShader] [ModelLighter] instance to use with AO rendering
+ * @param[flatShader] [ModelLighter] instance to use with non-AO rendering
+ */
+data class Vertex(
+    val xyz: Double3 = Double3(0.0, 0.0, 0.0),
+    val uv: UV = UV(0.0, 0.0),
+    val color: Color = Color.white,
+    val normal: Double3? = null
+)
+
+data class Color(val alpha: Int, val red: Int, val green: Int, val blue: Int) {
+    constructor(combined: Int) : this(
+        combined shr 24 and 255,
+        combined shr 16 and 255,
+        combined shr 8 and 255,
+        combined and 255
+    )
+
+    val asInt get() = (alpha shl 24) or (red shl 16) or (green shl 8) or blue
+    operator fun times(f: Float) = Color(
+        alpha,
+        (f * red.toFloat()).toInt().coerceIn(0 until 256),
+        (f * green.toFloat()).toInt().coerceIn(0 until 256),
+        (f * blue.toFloat()).toInt().coerceIn(0 until 256)
+    )
+
+    companion object {
+        val white get() = Color(255, 255, 255, 255)
+    }
+}
+
+data class HSB(var hue: Float, var saturation: Float, var brightness: Float) {
+    companion object {
+        /** Red is assumed to be LSB, see [NativeImage.PixelFormat.RGBA] */
+        fun fromColorRGBA(color: Int): HSB {
+            val hsbVals = java.awt.Color.RGBtoHSB(color and 255, (color shr 8) and 255, (color shr 16) and 255, null)
+            return HSB(hsbVals[0], hsbVals[1], hsbVals[2])
+        }
+    }
+    val asColor: Int get() = java.awt.Color.HSBtoRGB(hue, saturation, brightness)
+}
+
+/**
+ * Intermediate representation of model quad
+ * Immutable, double-precision
+ * Zero-centered (both XYZ and UV) coordinates for simpler rotation/mirroring
+ */
+data class Quad(
+    val v1: Vertex, val v2: Vertex, val v3: Vertex, val v4: Vertex,
+    val sprite: TextureAtlasSprite? = null,
+    val colorIndex: Int = -1,
+    val face: Direction? = null
+) {
+    val verts = arrayOf(v1, v2, v3, v4)
+
+    inline fun transformV(trans: (Vertex) -> Vertex): Quad = transformVI { vertex, idx -> trans(vertex) }
+    inline fun transformVI(trans: (Vertex, Int) -> Vertex): Quad = copy(
+        v1 = trans(v1, 0), v2 = trans(v2, 1), v3 = trans(v3, 2), v4 = trans(v4, 3)
+    )
+
+    val normal: Double3 get() = (v2.xyz - v1.xyz).cross(v4.xyz - v1.xyz).normalize
+
+    fun move(trans: Double3) = transformV { it.copy(xyz = it.xyz + trans) }
+    fun move(trans: Pair<Double, Direction>) = move(Double3(trans.second) * trans.first)
+    fun scale(scale: Double) = transformV { it.copy(xyz = it.xyz * scale) }
+    fun scale(scale: Double3) =
+        transformV { it.copy(xyz = Double3(it.xyz.x * scale.x, it.xyz.y * scale.y, it.xyz.z * scale.z)) }
+
+    fun rotate(rot: Rotation) =
+        transformV { it.copy(xyz = it.xyz.rotate(rot), normal = it.normal?.rotate(rot)) }.copy(face = face?.rotate(rot))
+
+    fun rotateZ(angle: Double) = transformV {
+        it.copy(
+            xyz = Double3(
+                it.xyz.x * cos(angle) + it.xyz.z * sin(angle),
+                it.xyz.y,
+                it.xyz.z * cos(angle) - it.xyz.x * sin(angle)
+            ),
+            normal = it.normal?.let { normal ->
+                Double3(
+                    normal.x * cos(angle) + normal.z * sin(angle),
+                    normal.y,
+                    normal.z * cos(angle) - normal.x * sin(angle)
+                )
+            }
+        )
+    }
+
+    fun scaleUV(scale: Double) = transformV { it.copy(uv = UV(it.uv.u * scale, it.uv.v * scale)) }
+    fun rotateUV(n: Int) = transformV { it.copy(uv = it.uv.rotate(n)) }
+    fun clampUV(minU: Double = -0.5, maxU: Double = 0.5, minV: Double = -0.5, maxV: Double = 0.5) =
+        transformV { it.copy(uv = it.uv.clamp(minU, maxU, minV, maxV)) }
+    fun mirrorUV(mirrorU: Boolean, mirrorV: Boolean) = transformV { it.copy(uv = it.uv.mirror(mirrorU, mirrorV)) }
+    fun scrambleUV(random: Random, canFlipU: Boolean, canFlipV: Boolean, canRotate: Boolean) = this
+        .mirrorUV(canFlipU && random.nextBoolean(), canFlipV && random.nextBoolean())
+        .let { if (canRotate) it.rotateUV(random.nextInt(4)) else it }
+
+    fun sprite(sprite: TextureAtlasSprite) = copy(sprite = sprite)
+    fun color(color: Color) = transformV { it.copy(color = color) }
+    fun color(color: Int) = transformV { it.copy(color = Color(color)) }
+    fun colorIndex(colorIndex: Int) = copy(colorIndex = colorIndex)
+    fun colorAndIndex(color: Color?) = color(color ?: Color.white).colorIndex(if (color == null) 0 else -1)
+
+    fun face() = face ?: nearestAngle(normal, Direction.values().toList()) { it.vec }.first
+
+    val flipped: Quad get() = Quad(v4, v3, v2, v1, sprite, colorIndex)
+    fun cycleVertices(n: Int) = when (n % 4) {
+        1 -> Quad(v2, v3, v4, v1)
+        2 -> Quad(v3, v4, v1, v2)
+        3 -> Quad(v4, v1, v2, v3)
+        else -> this.copy()
+    }
+
+    companion object {
+        fun mix(first: Quad, second: Quad, vertexFactory: (Vertex, Vertex) -> Vertex) = Quad(
+            v1 = vertexFactory(first.v1, second.v1),
+            v2 = vertexFactory(first.v2, second.v2),
+            v3 = vertexFactory(first.v3, second.v3),
+            v4 = vertexFactory(first.v4, second.v4)
+        )
+
+        fun verticalRectangle(x1: Double, z1: Double, x2: Double, z2: Double, yBottom: Double, yTop: Double) = Quad(
+            Vertex(Double3(x1, yBottom, z1), UV.bottomLeft),
+            Vertex(Double3(x2, yBottom, z2), UV.bottomRight),
+            Vertex(Double3(x2, yTop, z2), UV.topRight),
+            Vertex(Double3(x1, yTop, z1), UV.topLeft)
+        )
+
+        fun horizontalRectangle(x1: Double, z1: Double, x2: Double, z2: Double, y: Double): Quad {
+            val xMin = min(x1, x2);
+            val xMax = max(x1, x2)
+            val zMin = min(z1, z2);
+            val zMax = max(z1, z2)
+            return Quad(
+                Vertex(Double3(xMin, y, zMin), UV.topLeft),
+                Vertex(Double3(xMin, y, zMax), UV.bottomLeft),
+                Vertex(Double3(xMax, y, zMax), UV.bottomRight),
+                Vertex(Double3(xMax, y, zMin), UV.topRight)
+            )
+        }
+
+        fun faceQuad(face: Direction): Quad {
+            val base = face.vec * 0.5
+            val top = boxFaces[face].top * 0.5
+            val left = boxFaces[face].left * 0.5
+            return Quad(
+                Vertex(base + top + left, UV.topLeft),
+                Vertex(base - top + left, UV.bottomLeft),
+                Vertex(base - top - left, UV.bottomRight),
+                Vertex(base + top - left, UV.topRight)
+            )
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/model/SpecialRenderModels.kt

@@ -0,0 +1,26 @@
+package mods.betterfoliage.model
+
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import net.minecraft.client.renderer.model.IBakedModel
+import net.minecraft.util.WeightedRandom
+import java.util.Random
+
+/**
+ * Model that makes use of advanced rendering features.
+ */
+interface SpecialRenderModel : IBakedModel {
+    fun render(ctx: RenderCtxBase, noDecorations: Boolean = false)
+}
+
+class WeightedModelWrapper(
+    val models: List<WeightedModel>, baseModel: SpecialRenderModel
+): IBakedModel by baseModel, SpecialRenderModel {
+    class WeightedModel(val model: SpecialRenderModel, weight: Int) : WeightedRandom.Item(weight)
+    val totalWeight = models.sumBy { it.weight }
+
+    fun getModel(random: Random) = WeightedRandom.getWeightedItem(models, random.nextInt(totalWeight))
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        getModel(ctx.random).model.render(ctx, noDecorations)
+    }
+}

src/main/kotlin/mods/betterfoliage/model/SpriteSets.kt

@@ -0,0 +1,83 @@
+package mods.betterfoliage.model
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.resourceManager
+import net.minecraft.client.renderer.texture.MissingTextureSprite
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.event.TextureStitchEvent
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+interface SpriteSet {
+    val num: Int
+    operator fun get(idx: Int): TextureAtlasSprite
+}
+
+class FixedSpriteSet(val sprites: List<TextureAtlasSprite>) : SpriteSet {
+    override val num = sprites.size
+    override fun get(idx: Int) = sprites[idx % num]
+}
+
+class SpriteDelegate(val atlas: Atlas, val idFunc: () -> ResourceLocation) : ReadOnlyProperty<Any, TextureAtlasSprite> {
+    private lateinit var id: ResourceLocation
+    private var value: TextureAtlasSprite? = null
+
+    init {
+        BetterFoliageMod.bus.register(this)
+    }
+
+    @SubscribeEvent
+    fun handlePreStitch(event: TextureStitchEvent.Pre) {
+        id = idFunc(); value = null
+        event.addSprite(id)
+    }
+
+    override fun getValue(thisRef: Any, property: KProperty<*>): TextureAtlasSprite {
+        value?.let { return it }
+        synchronized(this) {
+            value?.let { return it }
+            atlas[id].let { value = it; return it }
+        }
+    }
+
+}
+
+class SpriteSetDelegate(
+    val atlas: Atlas,
+    val idRegister: (ResourceLocation) -> ResourceLocation = { it },
+    val idFunc: (Int) -> ResourceLocation
+) : ReadOnlyProperty<Any, SpriteSet> {
+    private var idList: List<ResourceLocation> = emptyList()
+    private var spriteSet: SpriteSet? = null
+
+    init {
+        BetterFoliageMod.bus.register(this)
+    }
+
+    @SubscribeEvent
+    fun handlePreStitch(event: TextureStitchEvent.Pre) {
+        if (event.map.location() != Atlas.BLOCKS.resourceId) return
+        spriteSet = null
+        idList = (0 until 16)
+            .map(idFunc)
+            .filter { resourceManager.hasResource(atlas.file(it)) }
+            .map(idRegister)
+        idList.forEach { event.addSprite(it) }
+    }
+
+    override fun getValue(thisRef: Any, property: KProperty<*>): SpriteSet {
+        spriteSet?.let { return it }
+        synchronized(this) {
+            spriteSet?.let { return it }
+            spriteSet = FixedSpriteSet(
+                idList
+                    .ifEmpty { listOf(MissingTextureSprite.getLocation()) }
+                    .map { atlas[it] }
+            )
+            return spriteSet!!
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/model/TuftMeshes.kt

@@ -0,0 +1,108 @@
+package mods.betterfoliage.model
+
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.PI2
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.random
+import mods.betterfoliage.util.randomB
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.randomI
+import mods.betterfoliage.util.rot
+import mods.betterfoliage.util.vec
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
+import kotlin.math.cos
+import kotlin.math.sin
+
+fun xzDisk(modelIdx: Int) = (PI2 * modelIdx.toDouble() / 64.0).let { Double3(cos(it), 0.0, sin(it)) }
+
+
+data class TuftShapeKey(
+    val size: Double,
+    val height: Double,
+    val offset: Double3,
+    val flipU1: Boolean,
+    val flipU2: Boolean
+)
+
+fun tuftShapeSet(size: Double, heightMin: Double, heightMax: Double, hOffset: Double): Array<TuftShapeKey> {
+    return Array(64) { idx ->
+        TuftShapeKey(
+            size,
+            randomD(heightMin, heightMax),
+            xzDisk(idx) * randomD(hOffset / 2.0, hOffset),
+            randomB(),
+            randomB()
+        )
+    }
+}
+
+fun tuftQuadSingle(size: Double, height: Double, flipU: Boolean) =
+    Quad.verticalRectangle(
+        x1 = -0.5 * size,
+        z1 = 0.5 * size,
+        x2 = 0.5 * size,
+        z2 = -0.5 * size,
+        yBottom = 0.5,
+        yTop = 0.5 + height
+    )
+        .mirrorUV(flipU, false)
+
+fun tuftModelSet(shapes: Array<TuftShapeKey>, tintIndex: Int, spriteGetter: (Int) -> TextureAtlasSprite) =
+    shapes.mapIndexed { idx, shape ->
+        listOf(
+            tuftQuadSingle(shape.size, shape.height, shape.flipU1),
+            tuftQuadSingle(shape.size, shape.height, shape.flipU2).rotate(rot(UP))
+        ).map { it.move(shape.offset) }
+            .map { it.colorIndex(tintIndex) }
+            .map { it.sprite(spriteGetter(idx)) }
+    }
+
+fun fullCubeTextured(
+    spriteLocation: ResourceLocation,
+    tintIndex: Int,
+    scrambleUV: Boolean = true
+): List<HalfBakedQuad> {
+    val sprite = Atlas.BLOCKS[spriteLocation]
+    return allDirections.map { Quad.faceQuad(it) }
+        .map { if (!scrambleUV) it else it.rotateUV(randomI(max = 4)) }
+        .map { it.sprite(sprite) }
+        .map { it.colorIndex(tintIndex) }
+        .bake(true)
+}
+
+fun crossModelsRaw(num: Int, size: Double, hOffset: Double, vOffset: Double): List<List<Quad>> {
+    return (0 until num).map { idx ->
+        listOf(
+            Quad.verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -0.5 * 1.41, yTop = 0.5 * 1.41),
+            Quad.verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -0.5 * 1.41, yTop = 0.5 * 1.41)
+                .rotate(rot(UP))
+        ).map { it.scale(size) }
+            .map { it.move(xzDisk(idx) * hOffset) }
+            .map { it.move(UP.vec * randomD(-1.0, 1.0) * vOffset) }
+    }
+}
+
+fun crossModelSingle(base: List<Quad>, sprite: TextureAtlasSprite, tintIndex: Int,scrambleUV: Boolean) =
+    base.map { if (scrambleUV) it.scrambleUV(random, canFlipU = true, canFlipV = true, canRotate = true) else it }
+        .map { it.colorIndex(tintIndex) }
+        .mapIndexed { idx, quad -> quad.sprite(sprite) }
+        .withOpposites()
+        .bake(false)
+
+fun crossModelsTextured(
+    leafBase: Iterable<List<Quad>>,
+    tintIndex: Int,
+    scrambleUV: Boolean,
+    spriteGetter: (Int) -> ResourceLocation
+) = leafBase.mapIndexed { idx, leaf ->
+    crossModelSingle(leaf, Atlas.BLOCKS[spriteGetter(idx)], tintIndex, scrambleUV)
+}.toTypedArray()
+
+fun Iterable<Quad>.withOpposites() = flatMap { listOf(it, it.flipped) }
+fun Iterable<List<Quad>>.buildTufts(applyDiffuseLighting: Boolean = false) =
+    map { it.withOpposites().bake(applyDiffuseLighting) }.toTypedArray()
+
+fun Iterable<List<Quad>>.transform(trans: Quad.(Int)-> Quad) = mapIndexed { idx, qList -> qList.map { it.trans(idx) } }

src/main/kotlin/mods/betterfoliage/render/block/vanilla/Cactus.kt

@@ -0,0 +1,90 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.config.CACTUS_BLOCKS
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.crossModelsRaw
+import mods.betterfoliage.model.crossModelsTextured
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.LightingPreferredFace
+import mods.betterfoliage.render.lighting.RoundLeafLighting
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.horizontalDirections
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.randomI
+import net.minecraft.block.Blocks
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.ResourceLocation
+
+object StandardCactusDiscovery : AbstractModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        val model = ctx.getUnbaked()
+        if (model is BlockModel && ctx.blockState.block in CACTUS_BLOCKS) {
+            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardCactusKey)
+            ctx.sprites.add(StandardCactusModel.cactusCrossSprite)
+        }
+        super.processModel(ctx)
+    }
+}
+
+object StandardCactusKey : HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardCactusModel(wrapped)
+}
+
+class StandardCactusModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+
+    val armLighting = horizontalDirections.map { LightingPreferredFace(it) }.toTypedArray()
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        ctx.checkSides = false
+        super.render(ctx, noDecorations)
+        if (!Config.enabled || !Config.cactus.enabled) return
+
+        val armSide = ctx.random.nextInt() and 3
+        ctx.vertexLighter = armLighting[armSide]
+        ctx.renderQuads(cactusArmModels[armSide][ctx.random])
+        ctx.vertexLighter = RoundLeafLighting
+        ctx.renderQuads(cactusCrossModels[ctx.random])
+    }
+
+    companion object {
+        val cactusCrossSprite = ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_cactus")
+        val cactusArmSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_cactus_arm_$idx")
+        }
+        val cactusArmModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.cactus.let { tuftShapeSet(0.8, 0.8, 0.8, 0.2) }
+            val models = tuftModelSet(shapes, -1) { cactusArmSprites[randomI()] }
+            horizontalDirections.map { side ->
+                models.transform { move(0.0625 to DOWN).rotate(Rotation.fromUp[side.ordinal]) }.buildTufts()
+            }.toTypedArray()
+        }
+        val cactusCrossModels by LazyInvalidatable(BakeWrapperManager) {
+            val models = Config.cactus.let { config ->
+                crossModelsRaw(64, config.size, 0.0, 0.0)
+                    .transform { rotateZ(randomD(-config.sizeVariation, config.sizeVariation)) }
+            }
+            crossModelsTextured(models, -1, true) { cactusCrossSprite }
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt

@@ -0,0 +1,120 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.DIRT_BLOCKS
+import mods.betterfoliage.config.SALTWATER_BIOMES
+import mods.betterfoliage.config.isSnow
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.LightingPreferredFace
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.generated.CenteredSprite
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.offset
+import mods.betterfoliage.util.randomI
+import net.minecraft.block.material.Material
+import net.minecraft.client.renderer.RenderType
+import net.minecraft.client.renderer.RenderTypeLookup
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
+
+object StandardDirtDiscovery : AbstractModelDiscovery() {
+    fun canRenderInLayer(layer: RenderType) = when {
+        !Config.enabled -> layer == RenderType.solid()
+        !Config.connectedGrass.enabled && !Config.algae.enabled && !Config.reed.enabled -> layer == RenderType.solid()
+        else -> layer == RenderType.cutoutMipped()
+    }
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in DIRT_BLOCKS) {
+            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardDirtKey)
+            RenderTypeLookup.setRenderLayer(ctx.blockState.block, ::canRenderInLayer)
+        }
+        super.processModel(ctx)
+    }
+}
+
+object StandardDirtKey : HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardDirtModel(wrapped)
+}
+
+class StandardDirtModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+    val vanillaTuftLighting = LightingPreferredFace(UP)
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        if (!Config.enabled || noDecorations) return super.render(ctx, noDecorations)
+
+        val stateUp = ctx.state(UP)
+        val state2Up = ctx.state(Int3(0, 2, 0))
+        val isConnectedGrass = Config.connectedGrass.enabled &&
+                stateUp in BetterFoliage.blockTypes.grass &&
+                (Config.connectedGrass.snowEnabled || !state2Up.isSnow)
+
+        if (isConnectedGrass) {
+            (ctx.blockModelShapes.getBlockModel(stateUp) as? SpecialRenderModel)?.let { grassModel ->
+                ctx.renderMasquerade(UP.offset) {
+                    grassModel.render(ctx, true)
+                }
+                return
+            }
+            return super.render(ctx, false)
+        }
+
+        super.render(ctx, false)
+
+        val isWater = stateUp.material == Material.WATER
+        val isDeepWater = isWater && state2Up.material == Material.WATER
+        val isShallowWater = isWater && state2Up.isAir
+        val isSaltWater = isWater && ctx.biome?.biomeCategory in SALTWATER_BIOMES
+
+        if (Config.algae.enabled(ctx.random) && isDeepWater) {
+            ctx.vertexLighter = vanillaTuftLighting
+            ShadersModIntegration.grass(ctx, Config.algae.shaderWind) {
+                ctx.renderQuads(algaeModels[ctx.random])
+            }
+        } else if (Config.reed.enabled(ctx.random) && isShallowWater && !isSaltWater) {
+            ctx.vertexLighter = vanillaTuftLighting
+            ShadersModIntegration.grass(ctx, Config.reed.shaderWind) {
+                ctx.renderQuads(reedModels[ctx.random])
+            }
+        }
+    }
+
+    companion object {
+        val algaeSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_algae_$idx")
+        }
+        val reedSprites by SpriteSetDelegate(
+            Atlas.BLOCKS,
+            idFunc = { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_reed_$idx") },
+            idRegister = { id -> CenteredSprite(id, aspectHeight = 2).register(BetterFoliage.generatedPack) }
+        )
+        val algaeModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.algae.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
+            tuftModelSet(shapes, -1) { algaeSprites[randomI()] }.buildTufts()
+        }
+        val reedModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.reed.let { tuftShapeSet(2.0, it.heightMin, it.heightMax, it.hOffset) }
+            tuftModelSet(shapes, -1) { reedSprites[randomI()] }.buildTufts()
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt

@@ -0,0 +1,118 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.isSnow
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.fullCubeTextured
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.LightingPreferredFace
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ConfigurableBlockMatcher
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ModelTextureList
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.LazyMapInvalidatable
+import mods.betterfoliage.util.averageColor
+import mods.betterfoliage.util.colorOverride
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.logColorOverride
+import mods.betterfoliage.util.randomI
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
+
+object StandardGrassDiscovery : ConfigurableModelDiscovery() {
+    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.grassBlocks
+    override val modelTextures: List<ModelTextureList> get() = BlockConfig.grassModels.modelList
+
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
+        ctx.addReplacement(StandardGrassKey(textureMatch[0], null))
+        BetterFoliage.blockTypes.grass.add(ctx.blockState)
+    }
+}
+
+data class StandardGrassKey(
+    val grassLocation: ResourceLocation,
+    val overrideColor: Color?
+) : HalfBakedWrapperKey() {
+    val tintIndex: Int get() = if (overrideColor == null) 0 else -1
+
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel): SpecialRenderModel {
+        val grassSpriteColor = Atlas.BLOCKS[grassLocation].averageColor.let { hsb ->
+            logColorOverride(BetterFoliageMod.detailLogger(this), Config.shortGrass.saturationThreshold, hsb)
+            hsb.colorOverride(Config.shortGrass.saturationThreshold)
+        }
+        return StandardGrassModel(wrapped, this.copy(overrideColor = grassSpriteColor))
+    }
+}
+
+class StandardGrassModel(
+    wrapped: SpecialRenderModel,
+    key: StandardGrassKey
+) : HalfBakedSpecialWrapper(wrapped) {
+
+    val tuftNormal by grassTuftMeshesNormal.delegate(key)
+    val tuftSnowed by grassTuftMeshesSnowed.delegate(key)
+    val fullBlock by grassFullBlockMeshes.delegate(key)
+    val tuftLighting = LightingPreferredFace(UP)
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        if (!Config.enabled || noDecorations) return super.render(ctx, noDecorations)
+
+        val stateBelow = ctx.state(DOWN)
+        val stateAbove = ctx.state(UP)
+        val isAir = ctx.isAir(UP)
+        val isSnowed = stateAbove.isSnow
+        val connected = Config.connectedGrass.enabled &&
+                (!isSnowed || Config.connectedGrass.snowEnabled) &&
+                BetterFoliage.blockTypes.run { stateBelow in grass || stateBelow in dirt }
+
+        if (connected) {
+            ctx.renderQuads(if (isSnowed) snowFullBlockMeshes[ctx.random] else fullBlock[ctx.random])
+        } else {
+            super.render(ctx, noDecorations)
+        }
+
+        if (Config.shortGrass.enabled(ctx.random) && (isAir || isSnowed)) {
+            ctx.vertexLighter = tuftLighting
+            ShadersModIntegration.grass(ctx, Config.shortGrass.shaderWind) {
+                ctx.renderQuads(if (isSnowed) tuftSnowed[ctx.random] else tuftNormal[ctx.random])
+            }
+        }
+    }
+
+    companion object {
+        val grassTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_grass_long_$idx")
+        }
+        val grassTuftShapes by LazyInvalidatable(BakeWrapperManager) {
+            Config.shortGrass.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
+        }
+        val grassTuftMeshesNormal = LazyMapInvalidatable(BakeWrapperManager) { key: StandardGrassKey ->
+            tuftModelSet(grassTuftShapes, key.tintIndex) { idx -> grassTuftSprites[randomI()] }.buildTufts()
+        }
+        val grassTuftMeshesSnowed = LazyMapInvalidatable(BakeWrapperManager) { key: StandardGrassKey ->
+            tuftModelSet(grassTuftShapes, -1) { idx -> grassTuftSprites[randomI()] }.buildTufts()
+        }
+        val grassFullBlockMeshes = LazyMapInvalidatable(BakeWrapperManager) { key: StandardGrassKey ->
+            Array(64) { fullCubeTextured(key.grassLocation, key.tintIndex) }
+        }
+        val snowFullBlockMeshes by LazyInvalidatable(BakeWrapperManager) {
+            Array(64) { fullCubeTextured(ResourceLocation("block/snow"), -1) }
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/block/vanilla/Leaf.kt

@@ -0,0 +1,101 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.isSnow
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.crossModelsRaw
+import mods.betterfoliage.model.crossModelsTextured
+import mods.betterfoliage.render.lighting.RoundLeafLightingPreferUp
+import mods.betterfoliage.render.particle.LeafBlockModel
+import mods.betterfoliage.render.particle.LeafParticleKey
+import mods.betterfoliage.render.particle.LeafParticleRegistry
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ConfigurableBlockMatcher
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ModelTextureList
+import mods.betterfoliage.resource.generated.GeneratedLeafSprite
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyMapInvalidatable
+import mods.betterfoliage.util.averageColor
+import mods.betterfoliage.util.colorOverride
+import mods.betterfoliage.util.logColorOverride
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
+import org.apache.logging.log4j.Level.INFO
+
+object StandardLeafDiscovery : ConfigurableModelDiscovery() {
+    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.leafBlocks
+    override val modelTextures: List<ModelTextureList> get() = BlockConfig.leafModels.modelList
+
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
+        val leafType = LeafParticleRegistry.typeMappings.getType(textureMatch[0]) ?: "default"
+        val generated = GeneratedLeafSprite(textureMatch[0], leafType)
+            .register(BetterFoliage.generatedPack)
+            .apply { ctx.sprites.add(this) }
+
+        detailLogger.log(INFO, "     particle $leafType")
+        ctx.addReplacement(StandardLeafKey(generated, leafType, null))
+    }
+}
+
+data class StandardLeafKey(
+    val roundLeafTexture: ResourceLocation,
+    override val leafType: String,
+    override val overrideColor: Color?
+) : HalfBakedWrapperKey(), LeafParticleKey {
+    val tintIndex: Int get() = if (overrideColor == null) 0 else -1
+
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel): SpecialRenderModel {
+        val leafSpriteColor = Atlas.BLOCKS[roundLeafTexture].averageColor.let { hsb ->
+            logColorOverride(BetterFoliageMod.detailLogger(this), Config.leaves.saturationThreshold, hsb)
+            hsb.colorOverride(Config.leaves.saturationThreshold)
+        }
+        return StandardLeafModel(wrapped, this.copy(overrideColor = leafSpriteColor))
+    }
+}
+
+class StandardLeafModel(
+    model: SpecialRenderModel,
+    override val key: StandardLeafKey
+) : HalfBakedSpecialWrapper(model), LeafBlockModel {
+    val leafNormal by leafModelsNormal.delegate(key)
+    val leafSnowed by leafModelsSnowed.delegate(key)
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        ShadersModIntegration.leaves(ctx, true) {
+            super.render(ctx, noDecorations)
+            if (!Config.enabled || !Config.leaves.enabled || noDecorations) return
+
+            ctx.vertexLighter = RoundLeafLightingPreferUp
+            val leafIdx = ctx.random.nextInt(64)
+            ctx.renderQuads(leafNormal[leafIdx])
+            if (ctx.state(UP).isSnow) ctx.renderQuads(leafSnowed[leafIdx])
+        }
+    }
+
+    companion object {
+        val leafSpritesSnowed by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_leaves_snowed_$idx")
+        }
+        val leafModelsBase = LazyMapInvalidatable(BakeWrapperManager) { key: StandardLeafKey ->
+            Config.leaves.let { crossModelsRaw(64, it.size, it.hOffset, it.vOffset) }
+        }
+        val leafModelsNormal = LazyMapInvalidatable(BakeWrapperManager) { key: StandardLeafKey ->
+            crossModelsTextured(leafModelsBase[key], key.tintIndex, true) { key.roundLeafTexture }
+        }
+        val leafModelsSnowed = LazyMapInvalidatable(BakeWrapperManager) { key: StandardLeafKey ->
+            crossModelsTextured(leafModelsBase[key], -1, false) { leafSpritesSnowed[it].name }
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/block/vanilla/Lilypad.kt

@@ -0,0 +1,78 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.LILYPAD_BLOCKS
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelBakingKey
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.get
+import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.client.renderer.model.ModelBakery
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.ResourceLocation
+
+object StandardLilypadDiscovery : AbstractModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in LILYPAD_BLOCKS) {
+            ctx.addReplacement(StandardLilypadKey)
+        }
+        super.processModel(ctx)
+    }
+}
+
+object StandardLilypadKey : HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardLilypadModel(wrapped)
+}
+
+class StandardLilypadModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        ctx.checkSides = false
+        super.render(ctx, noDecorations)
+        if (!Config.enabled || !Config.lilypad.enabled) return
+
+        ShadersModIntegration.grass(ctx, Config.lilypad.shaderWind) {
+            ctx.renderQuads(lilypadRootModels[ctx.random])
+        }
+        if (Config.lilypad.enabled(ctx.random)) ctx.renderQuads(lilypadFlowerModels[ctx.random])
+    }
+
+    companion object {
+        val lilypadRootSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_lilypad_roots_$idx")
+        }
+        val lilypadFlowerSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_lilypad_flower_$idx")
+        }
+        val lilypadRootModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = tuftShapeSet(1.0, 1.0, 1.0, Config.lilypad.hOffset)
+            tuftModelSet(shapes, -1) { lilypadRootSprites[it] }
+                .transform { move(2.0 to DOWN) }
+                .buildTufts()
+        }
+        val lilypadFlowerModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = tuftShapeSet(0.5, 0.5, 0.5, Config.lilypad.hOffset)
+            tuftModelSet(shapes, -1) { lilypadFlowerSprites[it] }
+                .transform { move(1.0 to DOWN) }
+                .buildTufts()
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt

@@ -0,0 +1,72 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.MYCELIUM_BLOCKS
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.LightingPreferredFace
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.randomI
+import net.minecraft.block.Blocks
+import net.minecraft.client.renderer.RenderType
+import net.minecraft.client.renderer.RenderTypeLookup
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.util.Direction
+import net.minecraft.util.ResourceLocation
+
+object StandardMyceliumDiscovery : AbstractModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in MYCELIUM_BLOCKS) {
+            ctx.addReplacement(StandardMyceliumKey)
+            RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.cutout())
+        }
+        super.processModel(ctx)
+    }
+}
+
+object StandardMyceliumKey : HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardMyceliumModel(wrapped)
+}
+
+class StandardMyceliumModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+
+    val tuftLighting = LightingPreferredFace(Direction.UP)
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        super.render(ctx, noDecorations)
+
+        if (Config.shortGrass.enabled &&
+            Config.shortGrass.myceliumEnabled &&
+            Config.shortGrass.enabled(ctx.random) &&
+            ctx.state(Direction.UP).isAir(ctx.world, ctx.pos)
+        ) {
+            ctx.vertexLighter = tuftLighting
+            ctx.renderQuads(myceliumTuftModels[ctx.random])
+        }
+    }
+
+    companion object {
+        val myceliumTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_mycel_$idx")
+        }
+        val myceliumTuftModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.shortGrass.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
+            tuftModelSet(shapes, -1) { idx -> myceliumTuftSprites[randomI()] }.buildTufts()
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt

@@ -0,0 +1,81 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.NETHERRACK_BLOCKS
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.LightingPreferredFace
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.randomI
+import net.minecraft.block.Blocks
+import net.minecraft.client.renderer.RenderType
+import net.minecraft.client.renderer.RenderTypeLookup
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.ResourceLocation
+
+object StandardNetherrackDiscovery : AbstractModelDiscovery() {
+    fun canRenderInLayer(layer: RenderType) = when {
+        !Config.enabled -> layer == RenderType.solid()
+        !Config.netherrack.enabled -> layer == RenderType.solid()
+        else -> layer == RenderType.cutoutMipped()
+    }
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in NETHERRACK_BLOCKS) {
+            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardNetherrackKey)
+            RenderTypeLookup.setRenderLayer(ctx.blockState.block, ::canRenderInLayer)
+        }
+        super.processModel(ctx)
+    }
+}
+
+object StandardNetherrackKey : HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardNetherrackModel(wrapped)
+}
+
+class StandardNetherrackModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+
+    val tuftLighting = LightingPreferredFace(DOWN)
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        super.render(ctx, noDecorations)
+        if (!Config.enabled || !Config.netherrack.enabled) return
+
+        if (ctx.isAir(DOWN)) {
+            ctx.vertexLighter = tuftLighting
+            ctx.renderQuads(netherrackTuftModels[ctx.random])
+        }
+    }
+
+    companion object {
+        val netherrackTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_netherrack_$idx")
+        }
+        val netherrackTuftModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.netherrack.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
+            tuftModelSet(shapes, -1) { netherrackTuftSprites[randomI()] }
+                .transform { rotate(Rotation.fromUp[DOWN.ordinal]).rotateUV(2) }
+                .buildTufts()
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt

@@ -0,0 +1,98 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.config.ACCEPTED_ROUND_LOG_MATERIALS
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.render.column.ColumnBlockKey
+import mods.betterfoliage.render.column.ColumnMeshSet
+import mods.betterfoliage.render.column.ColumnModelBase
+import mods.betterfoliage.render.column.ColumnRenderLayer
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ConfigurableBlockMatcher
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelBakingKey
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ModelTextureList
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyMapInvalidatable
+import mods.betterfoliage.util.tryDefault
+import net.minecraft.block.BlockState
+import net.minecraft.block.RotatedPillarBlock
+import net.minecraft.util.Direction.Axis
+import net.minecraft.util.ResourceLocation
+import org.apache.logging.log4j.Level.INFO
+
+interface RoundLogKey : ColumnBlockKey, ModelBakingKey {
+    val barkSprite: ResourceLocation
+    val endSprite: ResourceLocation
+}
+
+object RoundLogOverlayLayer : ColumnRenderLayer() {
+    override fun getColumnKey(state: BlockState) = BetterFoliage.blockTypes.getTypedOrNull<ColumnBlockKey>(state)
+    override val connectSolids: Boolean get() = Config.roundLogs.connectSolids
+    override val lenientConnect: Boolean get() = Config.roundLogs.lenientConnect
+    override val defaultToY: Boolean get() = Config.roundLogs.defaultY
+}
+
+object StandardRoundLogDiscovery : ConfigurableModelDiscovery() {
+    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.logBlocks
+    override val modelTextures: List<ModelTextureList> get() = BlockConfig.logModels.modelList
+
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
+        val axis = getAxis(ctx.blockState)
+
+        detailLogger.log(INFO, "       axis $axis, material ${ctx.blockState.material}")
+        if (!Config.roundLogs.plantsOnly || ctx.blockState.material in ACCEPTED_ROUND_LOG_MATERIALS)
+            ctx.addReplacement(StandardRoundLogKey(axis, textureMatch[0], textureMatch[1]))
+    }
+
+    fun getAxis(state: BlockState): Axis? {
+        val axis = tryDefault(null) { state.getValue(RotatedPillarBlock.AXIS).toString() } ?:
+        state.values.entries.find { it.key.name.toLowerCase() == "axis" }?.value?.toString()
+        return when (axis) {
+            "x" -> Axis.X
+            "y" -> Axis.Y
+            "z" -> Axis.Z
+            else -> null
+        }
+    }
+}
+
+data class StandardRoundLogKey(
+    override val axis: Axis?,
+    override val barkSprite: ResourceLocation,
+    override val endSprite: ResourceLocation
+) : RoundLogKey, HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardRoundLogModel(this, wrapped)
+}
+
+class StandardRoundLogModel(
+    val key: StandardRoundLogKey,
+    wrapped: SpecialRenderModel
+) : ColumnModelBase(wrapped) {
+    override val enabled: Boolean get() = Config.enabled && Config.roundLogs.enabled
+    override val overlayLayer: ColumnRenderLayer get() = RoundLogOverlayLayer
+    override val connectPerpendicular: Boolean get() = Config.roundLogs.connectPerpendicular
+
+    val modelSet by modelSets.delegate(key)
+    override fun getMeshSet(axis: Axis, quadrant: Int) = modelSet
+
+    companion object {
+        val modelSets = LazyMapInvalidatable(BakeWrapperManager) { key: StandardRoundLogKey ->
+            val barkSprite = Atlas.BLOCKS[key.barkSprite]
+            val endSprite = Atlas.BLOCKS[key.endSprite]
+            Config.roundLogs.let { config ->
+                ColumnMeshSet(
+                    config.radiusSmall, config.radiusLarge, config.zProtection,
+                    key.axis ?: Axis.Y,
+                    barkSprite, barkSprite,
+                    endSprite, endSprite
+                )
+            }
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt

@@ -0,0 +1,107 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.SALTWATER_BIOMES
+import mods.betterfoliage.config.SAND_BLOCKS
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.Quad
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.bake
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.LightingPreferredFace
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.mapArray
+import mods.betterfoliage.util.randomB
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.randomI
+import net.minecraft.block.material.Material
+import net.minecraft.client.renderer.RenderType
+import net.minecraft.client.renderer.RenderTypeLookup
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
+
+object StandardSandDiscovery : AbstractModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in SAND_BLOCKS) {
+            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardSandKey)
+            RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.cutoutMipped())
+        }
+        super.processModel(ctx)
+    }
+}
+
+object StandardSandKey : HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardSandModel(wrapped)
+}
+
+class StandardSandModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+    val coralLighting = Direction.values().mapArray { LightingPreferredFace(it) }
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        super.render(ctx, noDecorations)
+        if (noDecorations || !Config.enabled || !Config.coral.enabled(ctx.random)) return
+        if (ctx.biome?.biomeCategory !in SALTWATER_BIOMES) return
+
+        allDirections.filter { ctx.random.nextInt(64) < Config.coral.chance }.forEach { face ->
+            val isWater = ctx.state(face).material == Material.WATER
+            val isDeepWater = isWater && ctx.offset(face).state(UP).material == Material.WATER
+            if (isDeepWater) {
+                ctx.vertexLighter = coralLighting[face]
+                ctx.renderQuads(coralCrustModels[face][ctx.random])
+                ctx.renderQuads(coralTuftModels[face][ctx.random])
+            }
+        }
+    }
+
+    companion object {
+        val coralTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_coral_$idx")
+        }
+        val coralCrustSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_crust_$idx")
+        }
+        val coralTuftModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.coral.let { tuftShapeSet(it.size, 1.0, 1.0, it.hOffset) }
+            allDirections.mapArray { face ->
+                tuftModelSet(shapes, -1) { coralTuftSprites[randomI()] }
+                    .transform { rotate(Rotation.fromUp[face]) }
+                    .buildTufts()
+            }
+        }
+        val coralCrustModels by LazyInvalidatable(BakeWrapperManager) {
+            allDirections.map { face ->
+                Array(64) { idx ->
+                    listOf(
+                        Quad.horizontalRectangle(x1 = -0.5, x2 = 0.5, z1 = -0.5, z2 = 0.5, y = 0.0)
+                            .scale(Config.coral.crustSize)
+                            .move(0.5 + randomD(0.01, Config.coral.vOffset) to UP)
+                            .rotate(Rotation.fromUp[face])
+                            .mirrorUV(randomB(), randomB()).rotateUV(randomI(max = 4))
+                            .sprite(coralCrustSprites[idx]).colorAndIndex(null)
+                    ).bake(applyDiffuseLighting = false)
+                }
+            }.toTypedArray()
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/column/ColumnMeshSet.kt

@@ -0,0 +1,166 @@
+package mods.betterfoliage.render.column
+
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.Quad
+import mods.betterfoliage.model.UV
+import mods.betterfoliage.model.Vertex
+import mods.betterfoliage.model.bake
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.INVISIBLE
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.LARGE_RADIUS
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SMALL_RADIUS
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SQUARE
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Rotation
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.Direction.Axis
+import net.minecraft.util.Direction.EAST
+import net.minecraft.util.Direction.SOUTH
+import net.minecraft.util.Direction.UP
+
+/**
+ * Collection of dynamically generated meshes used to render rounded columns.
+ */
+class ColumnMeshSet(
+    radiusSmall: Double,
+    radiusLarge: Double,
+    zProtection: Double,
+    val axis: Axis,
+    val spriteLeft: TextureAtlasSprite,
+    val spriteRight: TextureAtlasSprite,
+    val spriteTop: TextureAtlasSprite,
+    val spriteBottom: TextureAtlasSprite
+) {
+    protected fun sideRounded(radius: Double, yBottom: Double, yTop: Double): List<Quad> {
+        val halfRadius = radius * 0.5
+        return listOf(
+            // left side of the diagonal
+            Quad.verticalRectangle(0.0, 0.5, 0.5 - radius, 0.5, yBottom, yTop).clampUV(minU = 0.0, maxU = 0.5 - radius),
+            Quad.verticalRectangle(0.5 - radius, 0.5, 0.5 - halfRadius, 0.5 - halfRadius, yBottom, yTop).clampUV(minU = 0.5 - radius),
+            // right side of the diagonal
+            Quad.verticalRectangle(0.5 - halfRadius, 0.5 - halfRadius, 0.5, 0.5 - radius, yBottom, yTop).clampUV(maxU = radius - 0.5),
+            Quad.verticalRectangle(0.5, 0.5 - radius, 0.5, 0.0, yBottom, yTop).clampUV(minU = radius - 0.5, maxU = 0.0)
+        )
+    }
+
+    protected fun sideRoundedTransition(radiusBottom: Double, radiusTop: Double, yBottom: Double, yTop: Double): List<Quad> {
+        val ySplit = 0.5 * (yBottom + yTop)
+        val modelTop = sideRounded(radiusTop, yBottom, yTop)
+        val modelBottom = sideRounded(radiusBottom, yBottom, yTop)
+        return (modelBottom zip modelTop).map { (quadBottom, quadTop) ->
+            Quad.mix(quadBottom, quadTop) { vBottom, vTop -> if (vBottom.xyz.y < ySplit) vBottom.copy() else vTop.copy() }
+        }
+    }
+
+    protected fun sideSquare(yBottom: Double, yTop: Double) = listOf(
+        Quad.verticalRectangle(0.0, 0.5, 0.5, 0.5, yBottom, yTop).clampUV(minU = 0.0),
+        Quad.verticalRectangle(0.5, 0.5, 0.5, 0.0, yBottom, yTop).clampUV(maxU = 0.0)
+    )
+
+    protected fun lidRounded(radius: Double, y: Double, isBottom: Boolean) = Array(4) { quadrant ->
+        val rotation = baseRotation(axis) + quadrantRotations[quadrant]
+        val v1 = Vertex(Double3(0.0, y, 0.0), UV(0.0, 0.0))
+        val v2 = Vertex(Double3(0.0, y, 0.5), UV(0.0, 0.5))
+        val v3 = Vertex(Double3(0.5 - radius, y, 0.5), UV(0.5 - radius, 0.5))
+        val v4 = Vertex(Double3(0.5 - radius * 0.5, y, 0.5 - radius * 0.5), UV(0.5, 0.5))
+        val v5 = Vertex(Double3(0.5, y, 0.5 - radius), UV(0.5, 0.5 - radius))
+        val v6 = Vertex(Double3(0.5, y, 0.0), UV(0.5, 0.0))
+        listOf(Quad(v1, v2, v3, v4), Quad(v1, v4, v5, v6))
+            .map { it.cycleVertices(if (isBottom xor Config.nVidia) 0 else 1) }
+            .map { it.rotate(rotation).rotateUV(quadrant) }
+            .map { it.sprite(if (isBottom) spriteBottom else spriteTop) }
+            .map { if (isBottom) it.flipped else it }
+    }
+
+    protected fun lidSquare(y: Double, isBottom: Boolean) = Array(4) { quadrant ->
+        val rotation = baseRotation(axis) + quadrantRotations[quadrant]
+        listOf(
+            Quad.horizontalRectangle(x1 = 0.0, x2 = 0.5, z1 = 0.0, z2 = 0.5, y = y).clampUV(minU = 0.0, minV = 0.0)
+                .rotate(rotation).rotateUV(quadrant)
+                .sprite(if (isBottom) spriteBottom else spriteTop)
+                .let { if (isBottom) it.flipped else it }
+        )
+    }
+
+    protected val zProtectionScale = zProtection.let { Double3(it, 1.0, it) }
+
+    protected fun List<Quad>.extendTop(size: Double) = map { q -> q.clampUV(minV = 0.5 - size).transformV { v ->
+        if (v.xyz.y > 0.501) v.copy(xyz = v.xyz * zProtectionScale) else v }
+    }
+    protected fun List<Quad>.extendBottom(size: Double) = map { q -> q.clampUV(maxV = -0.5 + size).transformV { v ->
+        if (v.xyz.y < -0.501) v.copy(xyz = v.xyz * zProtectionScale) else v }
+    }
+    protected fun List<Quad>.buildSides(quadsPerSprite: Int) = Array(4) { quadrant ->
+        val rotation = baseRotation(axis) + quadrantRotations[quadrant]
+        this.map { it.rotate(rotation) }
+            .mapIndexed { idx, q -> if (idx % (2 * quadsPerSprite) >= quadsPerSprite) q.sprite(spriteRight) else q.sprite(spriteLeft) }
+            .bake(false)
+    }
+
+    companion object {
+        fun baseRotation(axis: Axis) = when(axis) {
+            Axis.X -> Rotation.fromUp[EAST.ordinal]
+            Axis.Y -> Rotation.fromUp[UP.ordinal]
+            Axis.Z -> Rotation.fromUp[SOUTH.ordinal]
+        }
+        val quadrantRotations = Array(4) { Rotation.rot90[UP.ordinal] * it }
+    }
+
+    //
+    // Mesh definitions
+    // 4-element arrays hold prebuild meshes for each of the rotations around the axis
+    //
+    val sideSquare = sideSquare(-0.5, 0.5).buildSides(quadsPerSprite = 1)
+    val sideRoundSmall = sideRounded(radiusSmall, -0.5, 0.5).buildSides(quadsPerSprite = 2)
+    val sideRoundLarge = sideRounded(radiusLarge, -0.5, 0.5).buildSides(quadsPerSprite = 2)
+
+    val sideExtendTopSquare = sideSquare(0.5, 0.5 + radiusLarge).extendTop(radiusLarge).buildSides(quadsPerSprite = 1)
+    val sideExtendTopRoundSmall = sideRounded(radiusSmall, 0.5, 0.5 + radiusLarge).extendTop(radiusLarge).buildSides(quadsPerSprite = 2)
+    val sideExtendTopRoundLarge = sideRounded(radiusLarge, 0.5, 0.5 + radiusLarge).extendTop(radiusLarge).buildSides(quadsPerSprite = 2)
+
+    val sideExtendBottomSquare = sideSquare(-0.5 - radiusLarge, -0.5).extendBottom(radiusLarge).buildSides(quadsPerSprite = 1)
+    val sideExtendBottomRoundSmall = sideRounded(radiusSmall, -0.5 - radiusLarge, -0.5).extendBottom(radiusLarge).buildSides(quadsPerSprite = 2)
+    val sideExtendBottomRoundLarge = sideRounded(radiusLarge, -0.5 - radiusLarge, -0.5).extendBottom(radiusLarge).buildSides(quadsPerSprite = 2)
+
+    val lidTopSquare = lidSquare(0.5, false).bake(false)
+    val lidTopRoundSmall = lidRounded(radiusSmall, 0.5, false).bake(false)
+    val lidTopRoundLarge = lidRounded(radiusLarge, 0.5, false).bake(false)
+
+    val lidBottomSquare = lidSquare(-0.5, true).bake(false)
+    val lidBottomRoundSmall = lidRounded(radiusSmall, -0.5, true).bake(false)
+    val lidBottomRoundLarge = lidRounded(radiusLarge, -0.5, true).bake(false)
+
+    val transitionTop = sideRoundedTransition(radiusLarge, radiusSmall, -0.5, 0.5).buildSides(quadsPerSprite = 2)
+    val transitionBottom = sideRoundedTransition(radiusSmall, radiusLarge, -0.5, 0.5).buildSides(quadsPerSprite = 2)
+
+    //
+    // Helper fuctions for lids (block ends)
+    //
+    fun flatTop(quadrantTypes: Array<QuadrantType>, quadrant: Int) = when(quadrantTypes[quadrant]) {
+        SMALL_RADIUS -> lidTopRoundSmall[quadrant]
+        LARGE_RADIUS -> lidTopRoundLarge[quadrant]
+        SQUARE -> lidTopSquare[quadrant]
+        INVISIBLE -> lidTopSquare[quadrant]
+    }
+
+    fun flatBottom(quadrantTypes: Array<QuadrantType>, quadrant: Int) = when(quadrantTypes[quadrant]) {
+        SMALL_RADIUS -> lidBottomRoundSmall[quadrant]
+        LARGE_RADIUS -> lidBottomRoundLarge[quadrant]
+        SQUARE -> lidBottomSquare[quadrant]
+        INVISIBLE -> lidBottomSquare[quadrant]
+    }
+
+    fun extendTop(quadrantTypes: Array<QuadrantType>, quadrant: Int) = when(quadrantTypes[quadrant]) {
+        SMALL_RADIUS -> sideExtendTopRoundSmall[quadrant]
+        LARGE_RADIUS -> sideExtendTopRoundLarge[quadrant]
+        SQUARE -> sideExtendTopSquare[quadrant]
+        INVISIBLE -> sideExtendTopSquare[quadrant]
+    }
+
+    fun extendBottom(quadrantTypes: Array<QuadrantType>, quadrant: Int) = when(quadrantTypes[quadrant]) {
+        SMALL_RADIUS -> sideExtendBottomRoundSmall[quadrant]
+        LARGE_RADIUS -> sideExtendBottomRoundLarge[quadrant]
+        SQUARE -> sideExtendBottomSquare[quadrant]
+        INVISIBLE -> sideExtendBottomSquare[quadrant]
+    }
+}

src/main/kotlin/mods/betterfoliage/render/column/ColumnModel.kt

@@ -0,0 +1,113 @@
+package mods.betterfoliage.render.column
+
+import mods.betterfoliage.chunk.ChunkOverlayManager
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.render.column.ColumnLayerData.NormalRender
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.NONSOLID
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.PARALLEL
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.PERPENDICULAR
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.INVISIBLE
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.LARGE_RADIUS
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SMALL_RADIUS
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SQUARE
+import mods.betterfoliage.render.lighting.ColumnLighting
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+import net.minecraft.util.Direction.Axis
+
+abstract class ColumnModelBase(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+
+    abstract val enabled: Boolean
+    abstract val overlayLayer: ColumnRenderLayer
+    abstract val connectPerpendicular: Boolean
+    abstract fun getMeshSet(axis: Axis, quadrant: Int): ColumnMeshSet
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        if (!enabled) return super.render(ctx, noDecorations)
+        
+        val roundLog = ChunkOverlayManager.get(overlayLayer, ctx)
+        when(roundLog) {
+            ColumnLayerData.SkipRender -> return
+            NormalRender -> return super.render(ctx, noDecorations)
+            ColumnLayerData.ResolveError, null -> {
+                return super.render(ctx, noDecorations)
+            }
+        }
+
+        // if log axis is not defined and "Default to vertical" config option is not set, render normally
+        if ((roundLog as ColumnLayerData.SpecialRender).column.axis == null && !overlayLayer.defaultToY) {
+            return super.render(ctx, noDecorations)
+        }
+
+        ctx.vertexLighter = ColumnLighting
+
+        val axis = roundLog.column.axis ?: Axis.Y
+        val baseRotation = ColumnMeshSet.baseRotation(axis)
+        ColumnMeshSet.quadrantRotations.forEachIndexed { idx, quadrantRotation ->
+            // set rotation for the current quadrant
+            val rotation = baseRotation + quadrantRotation
+            val meshSet = getMeshSet(axis, idx)
+
+            // disallow sharp discontinuities in the chamfer radius, or tapering-in where inappropriate
+            if (roundLog.quadrants[idx] == LARGE_RADIUS &&
+                roundLog.upType == PARALLEL && roundLog.quadrantsTop[idx] != LARGE_RADIUS &&
+                roundLog.downType == PARALLEL && roundLog.quadrantsBottom[idx] != LARGE_RADIUS) {
+                roundLog.quadrants[idx] = SMALL_RADIUS
+            }
+
+            // select meshes for current quadrant based on connectivity rules
+            val sideMesh = when (roundLog.quadrants[idx]) {
+                SMALL_RADIUS -> meshSet.sideRoundSmall[idx]
+                LARGE_RADIUS -> if (roundLog.upType == PARALLEL && roundLog.quadrantsTop[idx] == SMALL_RADIUS) meshSet.transitionTop[idx]
+                else if (roundLog.downType == PARALLEL && roundLog.quadrantsBottom[idx] == SMALL_RADIUS) meshSet.transitionBottom[idx]
+                else meshSet.sideRoundLarge[idx]
+                SQUARE -> meshSet.sideSquare[idx]
+                else -> null
+            }
+
+            val upMesh = when(roundLog.upType) {
+                NONSOLID -> meshSet.flatTop(roundLog.quadrants, idx)
+                PERPENDICULAR -> {
+                    if (!connectPerpendicular) {
+                        meshSet.flatTop(roundLog.quadrants, idx)
+                    } else {
+                        meshSet.extendTop(roundLog.quadrants, idx)
+                    }
+                }
+                PARALLEL -> {
+                    if (roundLog.quadrants[idx] discontinuousWith roundLog.quadrantsTop[idx] &&
+                        roundLog.quadrants[idx].let { it == SQUARE || it == INVISIBLE } )
+                        meshSet.flatTop(roundLog.quadrants, idx)
+                    else null
+                }
+                else -> null
+            }
+
+            val downMesh = when(roundLog.downType) {
+                NONSOLID -> meshSet.flatBottom(roundLog.quadrants, idx)
+                PERPENDICULAR -> {
+                    if (!connectPerpendicular) {
+                        meshSet.flatBottom(roundLog.quadrants, idx)
+                    } else {
+                        meshSet.extendBottom(roundLog.quadrants, idx)
+                    }
+                }
+                PARALLEL -> {
+                    if (roundLog.quadrants[idx] discontinuousWith roundLog.quadrantsBottom[idx] &&
+                        roundLog.quadrants[idx].let { it == SQUARE || it == INVISIBLE } )
+                        meshSet.flatBottom(roundLog.quadrants, idx)
+                    else null
+                }
+                else -> null
+            }
+
+            // render
+            sideMesh?.let { ctx.renderQuads(it) }
+            upMesh?.let { ctx.renderQuads(it) }
+            downMesh?.let { ctx.renderQuads(it) }
+        }
+
+    }
+}

src/main/kotlin/mods/betterfoliage/render/column/ColumnOverlayLayer.kt

@@ -1,24 +1,29 @@
-package mods.betterfoliage.client.render.column
+package mods.betterfoliage.render.column
 
-import mods.betterfoliage.client.chunk.ChunkOverlayLayer
+import mods.betterfoliage.chunk.BlockCtx
-import mods.betterfoliage.client.chunk.ChunkOverlayManager
+import mods.betterfoliage.chunk.ChunkOverlayLayer
-import mods.betterfoliage.client.config.Config
+import mods.betterfoliage.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.BlockType.*
+import mods.betterfoliage.chunk.dimType
-import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.QuadrantType
+import mods.betterfoliage.config.Config
-import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.QuadrantType.*
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.NONSOLID
-import mods.betterfoliage.client.render.rotationFromUp
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.PARALLEL
-import mods.octarinecore.client.render.BlockContext
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.PERPENDICULAR
-import mods.octarinecore.client.resource.ModelRenderRegistry
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.SOLID
-import mods.octarinecore.common.Int3
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType
-import mods.octarinecore.common.Rotation
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.INVISIBLE
-import mods.octarinecore.common.face
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.LARGE_RADIUS
-import mods.octarinecore.common.plus
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SMALL_RADIUS
-import net.minecraft.block.state.IBlockState
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SQUARE
-import net.minecraft.util.EnumFacing
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.face
+import mods.betterfoliage.util.plus
+import net.minecraft.block.BlockState
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.Axis
 import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
+import net.minecraft.world.IBlockDisplayReader
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
 
 /** Index of SOUTH-EAST quadrant. */
 const val SE = 0
@@ -29,18 +34,20 @@ const val NW = 2
 /** Index of SOUTH-WEST quadrant. */
 const val SW = 3
 
+interface ColumnBlockKey {
+    val axis: Axis?
+}
+
 /**
  * Sealed class hierarchy for all possible render outcomes
  */
-@SideOnly(Side.CLIENT)
 sealed class ColumnLayerData {
     /**
      * Data structure to cache texture and world neighborhood data relevant to column rendering
      */
     @Suppress("ArrayInDataClass") // not used in comparisons anywhere
-    @SideOnly(Side.CLIENT)
     data class SpecialRender(
-        val column: ColumnTextureInfo,
+        val column: ColumnBlockKey,
         val upType: BlockType,
         val downType: BlockType,
         val quadrants: Array<QuadrantType>,
@@ -48,50 +55,48 @@ sealed class ColumnLayerData {
         val quadrantsBottom: Array<QuadrantType>
     ) : ColumnLayerData() {
         enum class BlockType { SOLID, NONSOLID, PARALLEL, PERPENDICULAR }
-        enum class QuadrantType { SMALL_RADIUS, LARGE_RADIUS, SQUARE, INVISIBLE }
+        enum class QuadrantType {
+            SMALL_RADIUS, LARGE_RADIUS, SQUARE, INVISIBLE;
+            infix fun continuousWith(other: QuadrantType) =
+                this == other || ((this == SQUARE || this == INVISIBLE) && (other == SQUARE || other == INVISIBLE))
+            infix fun discontinuousWith(other: QuadrantType) = !continuousWith(other)
+        }
     }
 
     /** Column block should not be rendered at all */
-    @SideOnly(Side.CLIENT)
     object SkipRender : ColumnLayerData()
 
     /** Column block must be rendered normally */
-    @SideOnly(Side.CLIENT)
     object NormalRender : ColumnLayerData()
 
     /** Error while resolving render data, column block must be rendered normally */
-    @SideOnly(Side.CLIENT)
     object ResolveError : ColumnLayerData()
 }
 
-
 abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {
 
-    abstract val registry: ModelRenderRegistry<ColumnTextureInfo>
-    abstract val blockPredicate: (IBlockState)->Boolean
-    abstract val surroundPredicate: (IBlockState) -> Boolean
     abstract val connectSolids: Boolean
     abstract val lenientConnect: Boolean
     abstract val defaultToY: Boolean
 
+    abstract fun getColumnKey(state: BlockState): ColumnBlockKey?
+
     val allNeighborOffsets = (-1..1).flatMap { offsetX -> (-1..1).flatMap { offsetY -> (-1..1).map { offsetZ -> Int3(offsetX, offsetY, offsetZ) }}}
 
-    override fun onBlockUpdate(world: IBlockAccess, pos: BlockPos) {
+    override fun onBlockUpdate(world: IBlockDisplayReader, pos: BlockPos) {
-        allNeighborOffsets.forEach { offset -> ChunkOverlayManager.clear(this, pos + offset) }
+        allNeighborOffsets.forEach { offset -> ChunkOverlayManager.clear(world.dimType, this, pos + offset) }
     }
 
-    override fun calculate(world: IBlockAccess, pos: BlockPos) = calculate(BlockContext(world, pos))
+    override fun calculate(ctx: BlockCtx): ColumnLayerData {
-
+        // TODO detect round logs
-    fun calculate(ctx: BlockContext): ColumnLayerData {
+        if (allDirections.all { dir -> ctx.offset(dir).let { it.isFullBlock } }) return ColumnLayerData.SkipRender
-        if (ctx.isSurroundedBy(surroundPredicate)) return ColumnLayerData.SkipRender
+        val columnTextures = getColumnKey(ctx.state) ?: return ColumnLayerData.ResolveError
-        val columnTextures = registry[ctx] ?: return ColumnLayerData.ResolveError
 
         // if log axis is not defined and "Default to vertical" config option is not set, render normally
-        val logAxis = columnTextures.axis ?: if (defaultToY) EnumFacing.Axis.Y else return ColumnLayerData.NormalRender
+        val logAxis = columnTextures.axis ?: if (defaultToY) Axis.Y else return ColumnLayerData.NormalRender
 
         // check log neighborhood
-        val baseRotation = rotationFromUp[(logAxis to EnumFacing.AxisDirection.POSITIVE).face.ordinal]
+        val baseRotation = Rotation.fromUp[(logAxis to Direction.AxisDirection.POSITIVE).face.ordinal]
-
         val upType = ctx.blockType(baseRotation, logAxis, Int3(0, 1, 0))
         val downType = ctx.blockType(baseRotation, logAxis, Int3(0, -1, 0))
 
@@ -109,7 +114,7 @@ abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {
     }
 
     /** Fill the array of [QuadrantType]s based on the blocks to the sides of this one. */
-    fun Array<QuadrantType>.checkNeighbors(ctx: BlockContext, rotation: Rotation, logAxis: EnumFacing.Axis, yOff: Int): Array<QuadrantType> {
+    fun Array<QuadrantType>.checkNeighbors(ctx: BlockCtx, rotation: Rotation, logAxis: Axis, yOff: Int): Array<QuadrantType> {
         val blkS = ctx.blockType(rotation, logAxis, Int3(0, yOff, 1))
         val blkE = ctx.blockType(rotation, logAxis, Int3(1, yOff, 0))
         val blkN = ctx.blockType(rotation, logAxis, Int3(0, yOff, -1))
@@ -176,13 +181,13 @@ abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {
     /**
      * Get the type of the block at the given offset in a rotated reference frame.
      */
-    fun BlockContext.blockType(rotation: Rotation, axis: EnumFacing.Axis, offset: Int3): ColumnLayerData.SpecialRender.BlockType {
+    fun BlockCtx.blockType(rotation: Rotation, axis: Axis, offset: Int3): ColumnLayerData.SpecialRender.BlockType {
         val offsetRot = offset.rotate(rotation)
-        val state = blockState(offsetRot)
+        val key = getColumnKey(state(offsetRot))
-        return if (!blockPredicate(state)) {
+        return if (key == null) {
-            if (state.isOpaqueCube) SOLID else NONSOLID
+            if (offset(offsetRot).isFullBlock) SOLID else NONSOLID
         } else {
-            (registry[state, world!!, pos + offsetRot]?.axis ?: if (Config.roundLogs.defaultY) EnumFacing.Axis.Y else null)?.let {
+            (key.axis ?: if (Config.roundLogs.defaultY) Axis.Y else null)?.let {
                 if (it == axis) PARALLEL else PERPENDICULAR
             } ?: SOLID
         }

src/main/kotlin/mods/betterfoliage/render/lighting/AoSideHelper.kt

@@ -0,0 +1,138 @@
+package mods.betterfoliage.render.lighting
+
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.mapArray
+import mods.betterfoliage.util.perpendiculars
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.*
+
+typealias BoxCorner = Triple<Direction, Direction, Direction>
+fun BoxCorner.equalsUnordered(other: BoxCorner) = contains(other.first) && contains(other.second) && contains(other.third)
+
+fun BoxCorner.contains(dir: Direction) = first == dir || second == dir || third == dir
+
+fun Array<BoxCorner>.findIdx(corner: BoxCorner): Int? {
+    forEachIndexed { idx, test -> if (test.contains(corner.first) && test.contains(corner.second) && test.contains(corner.third)) return idx }
+    return null
+}
+fun Array<BoxCorner>.findIdx(predicate: (BoxCorner)->Boolean): Int? {
+    forEachIndexed { idx, test -> if (predicate(test)) return idx }
+    return null
+}
+
+class AoSideHelper private constructor(face: Direction) {
+    val sides = faceSides[face]
+    val cornerSideDirections = faceCorners[face]
+    val aoIndex = faceCornersIdx.mapArray { corner ->
+        boxCornersDirIdx[face][sides[corner.first]][sides[corner.second]]!!
+    }
+
+    companion object {
+        /**
+         * Indexing for undirected box corners (component order does not matter).
+         * Array contains [Direction] triplets fully defining the corner.
+         */
+        @JvmField
+        val boxCornersUndir = Array(8) { idx -> Triple(
+            if (idx and 1 != 0) EAST else WEST,
+            if (idx and 2 != 0) UP else DOWN,
+            if (idx and 4 != 0) SOUTH else NORTH
+        ) }
+
+        /**
+         * Reverse lookup for [boxCornersUndir]. Index 3 times with the corner's cardinal directions.
+         *  A null value indicates an invalid corner (multiple indexing along the same axis)
+         */
+        @JvmField
+        val boxCornersUndirIdx = Array(6) { idx1 -> Array(6) { idx2 -> Array(6) { idx3 ->
+            boxCornersUndir.findIdx(BoxCorner(
+                Direction.values()[idx1],
+                Direction.values()[idx2],
+                Direction.values()[idx3]
+            ))
+        } } }
+
+        /**
+         * Indexing for directed face sides
+         * First index is the face, second is index of side on face
+         */
+        @JvmField
+        val faceSides = Array(6) { faceIdx -> Array(4) { sideIdx ->
+            Direction.values()[faceIdx].perpendiculars[sideIdx]
+        } }
+
+        /**
+         * Pairs of [faceSides] side indexes that form a valid pair describing a corner
+         */
+        @JvmField
+        val faceCornersIdx = arrayOf(0 to 2, 0 to 3, 1 to 2, 1 to 3)
+
+        /**
+         * Indexing for directed face corners
+         * First index is the face, second is index of corner on face
+         */
+        @JvmField
+        val faceCorners = Array(6) { faceIdx -> Array(4) { cornerIdx ->
+            faceCornersIdx[cornerIdx].let { faceSides[faceIdx][it.first] to faceSides[faceIdx][it.second] }
+        } }
+
+        /**
+         * Indexing scheme for directed box corners.
+         * The first direction - the face - matters, the other two are unordered.
+         * 1:1 correspondence with possible AO values.
+         * Array contains triplets defining the corner fully.
+         */
+        @JvmField
+        val boxCornersDir = Array(24) { idx ->
+            val faceIdx = idx / 4; val face = Direction.values()[faceIdx]
+            val cornerIdx = idx % 4; val corner = faceCorners[faceIdx][cornerIdx]
+            BoxCorner(face, corner.first, corner.second)
+        }
+
+        /**
+         * Reverse lookup for [boxCornersDir]. Index 3 times with the corner's cardinal directions.
+         * The first direction - the face - matters, the other two are unordered.
+         *  A null value indicates an invalid corner (multiple indexing along the same axis)
+         */
+        @JvmField
+        val boxCornersDirIdx = Array(6) { face -> Array(6) { side1 -> Array(6) { side2 ->
+            boxCornersDir.findIdx { boxCorner ->
+                boxCorner.first.ordinal == face && boxCorner.equalsUnordered(BoxCorner(
+                    Direction.values()[face],
+                    Direction.values()[side1],
+                    Direction.values()[side2]
+                ))
+            }
+        } } }
+
+        /**
+         * Reverse lookup for [cornersDir].
+         *   1st index: primary face
+         *   2nd index: undirected corner index.
+         *   value: directed corner index
+         *   A null value indicates an invalid corner (primary face not shared by corner).
+         */
+        @JvmField
+        val boxCornersDirFromUndir = Array(6) { faceIdx -> Array(8) { undirIdx ->
+            val face = Direction.values()[faceIdx]
+            val corner = boxCornersUndir[undirIdx]
+            if (!corner.contains(face)) null
+            else boxCornersDir.findIdx { it.first == face && it.equalsUnordered(corner) }
+        } }
+
+        @JvmField
+        val forSide = Direction.values().mapArray { AoSideHelper(it) }
+
+        /**
+         * Get corner index for vertex coordinates
+         */
+        @JvmStatic
+        fun getCornerUndir(x: Double, y: Double, z: Double): Int {
+            var result = 0
+            if (x > 0.0) result += 1
+            if (y > 0.0) result += 2
+            if (z > 0.0) result += 4
+            return result
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/lighting/ForgeVertexLighter.kt

@@ -0,0 +1,10 @@
+package mods.betterfoliage.render.lighting
+
+interface ForgeVertexLighterAccess {
+    var vertexLighter: ForgeVertexLighter
+}
+
+interface ForgeVertexLighter {
+    fun updateVertexLightmap(normal: FloatArray, lightmap: FloatArray, x: Float, y: Float, z: Float)
+    fun updateVertexColor(normal: FloatArray, color: FloatArray, x: Float, y: Float, z: Float, tint: Float, multiplier: Int)
+}

src/main/kotlin/mods/betterfoliage/render/lighting/VanillaAoCalculation.kt

@@ -0,0 +1,147 @@
+package mods.betterfoliage.render.lighting
+
+import mods.betterfoliage.chunk.BlockCtx
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.BlockModelRenderer
+import net.minecraft.util.Direction
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockDisplayReader
+
+data class LightingData(
+    @JvmField var packedLight: Int = 0,
+    @JvmField var colorMultiplier: Float = 1.0f
+) {
+    fun mixFrom(corner: LightingData, side1: LightingData, side2: LightingData, center: LightingData) {
+        colorMultiplier =
+            (center.colorMultiplier + side1.colorMultiplier + side2.colorMultiplier + corner.colorMultiplier) * 0.25f
+        packedLight = (
+                center.packedLight +
+                (side1.packedLight.takeUnless { it == 0 } ?: center.packedLight) +
+                (side2.packedLight.takeUnless { it == 0 } ?: center.packedLight) +
+                (corner.packedLight.takeUnless { it == 0 } ?: center.packedLight)
+            ).let { sum -> (sum shr 2) and 0xFF00FF }
+    }
+}
+
+/**
+ * Replacement for [BlockModelRenderer.AmbientOcclusionFace]
+ * This gets called on a LOT, so object instantiation is avoided.
+ * Not thread-safe, always use a [ThreadLocal] instance
+ */
+class VanillaAoCalculator {
+    lateinit var world: IBlockDisplayReader
+
+    /** [blockPos] is used to get block-related information (i.e. tint, opacity, etc.)
+     *  [lightPos] is used to get light-related information
+     *  this facilitates masquerade rendering of blocks */
+    lateinit var blockPos: BlockPos
+    lateinit var lightPos: BlockPos
+
+    private val probe = LightProbe(BlockModelRenderer.CACHE.get())
+
+    val isValid = BooleanArray(6)
+    val aoData = Array(24) { LightingData() }
+
+    // scratchpad values used during calculation
+    private val centerAo = LightingData()
+    private val sideAo = Array(4) { LightingData() }
+    private val cornerAo = Array(4) { LightingData() }
+    private val isOccluded = BooleanArray(4)
+
+    fun reset(ctx: BlockCtx) {
+        world = ctx.world; blockPos = ctx.pos; lightPos = ctx.pos
+        (0 until 6).forEach { isValid[it] = false }
+    }
+
+    fun fillLightData(lightFace: Direction, isOpaque: Boolean? = null) {
+        if (!isValid[lightFace.ordinal]) calculate(lightFace, isOpaque)
+    }
+
+    /**
+     * Replicate [BlockModelRenderer.AmbientOcclusionFace.updateVertexBrightness]
+     * Does not handle interpolation for non-cubic models, that should be
+     * done in a [VanillaVertexLighter]
+     * @param lightFace face of the block to calculate
+     * @param forceFull force full-block status for lighting calculation, null for auto
+     */
+    private fun calculate(lightFace: Direction, forceFull: Boolean?) {
+        if (isValid[lightFace.ordinal]) return
+        val sideHelper = AoSideHelper.forSide[lightFace.ordinal]
+
+        // Bit 0 of the bitset in vanilla calculations
+        // true if the block model is planar with the block boundary
+        val isFullBlock = forceFull ?: world.getBlockState(blockPos).isCollisionShapeFullBlock(world, blockPos)
+
+        val lightOrigin = if (isFullBlock) lightPos.relative(lightFace) else lightPos
+
+        // AO calculation for the face center
+        probe.position { set(lightOrigin) }.writeTo(centerAo)
+        if (!isFullBlock && !probe.position { move(lightFace) }.state.isSolidRender(world, probe.pos)) {
+            // if the neighboring block in the lightface direction is
+            // transparent (non-opaque), use its packed light instead of our own
+            // (if our block is a full block, we are already using this value)
+            centerAo.packedLight = probe.packedLight
+        }
+
+        // AO calculation for the 4 sides
+        sideHelper.sides.forEachIndexed { sideIdx, sideDir ->
+            // record light data in the block 1 step to the side
+            probe.position { set(lightOrigin).move(sideDir) }.writeTo(sideAo[sideIdx])
+            // side is considered occluded if the block 1 step to that side and
+            // 1 step forward (in the lightface direction) is not fully transparent
+            isOccluded[sideIdx] = probe.position { move(lightFace) }.isNonTransparent
+        }
+
+        // AO Calculation for the 4 corners
+        AoSideHelper.faceCornersIdx.forEachIndexed { cornerIdx, sideIndices ->
+            val bothOccluded = isOccluded[sideIndices.first] && isOccluded[sideIndices.second]
+            if (bothOccluded) cornerAo[cornerIdx].apply {
+                // if both sides are occluded, just use the packed light for one of the sides instead
+                val copyFrom = sideAo[sideIndices.first]
+                packedLight = copyFrom.packedLight; colorMultiplier = copyFrom.colorMultiplier
+            }
+            else {
+                // lookup actual packed light from the cornering block in the world
+                probe.position {
+                    set(lightOrigin)
+                        .move(sideHelper.sides[sideIndices.first])
+                        .move(sideHelper.sides[sideIndices.second])
+                }.writeTo(cornerAo[cornerIdx])
+            }
+        }
+
+        // Calculate and store final interpolated value for each corner
+        AoSideHelper.faceCornersIdx.forEachIndexed { cornerIdx, sideIndices ->
+            val aoIdx = sideHelper.aoIndex[cornerIdx]
+            aoData[aoIdx].mixFrom(
+                cornerAo[cornerIdx],
+                sideAo[sideIndices.first],
+                sideAo[sideIndices.second],
+                centerAo
+            )
+        }
+        isValid[lightFace.ordinal] = true
+    }
+
+    inner class LightProbe(
+        val cache: BlockModelRenderer.Cache
+    ) {
+        lateinit var state: BlockState
+        val pos = BlockPos.Mutable()
+
+        val packedLight: Int get() = cache.getLightColor(state, world, pos)
+        val colorMultiplier: Float get() = cache.getShadeBrightness(state, world, pos)
+        val isNonTransparent: Boolean get() = state.getLightBlock(world, pos) > 0
+
+        fun writeTo(data: LightingData) {
+            data.packedLight = packedLight
+            data.colorMultiplier = colorMultiplier
+        }
+
+        inline fun position(func: BlockPos.Mutable.() -> Unit): LightProbe {
+            pos.func()
+            state = world.getBlockState(pos)
+            return this
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/lighting/VanillaVertexLighter.kt

@@ -0,0 +1,210 @@
+package mods.betterfoliage.render.lighting
+
+import mods.betterfoliage.model.HalfBakedQuad
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.EPSILON_ONE
+import mods.betterfoliage.util.EPSILON_ZERO
+import mods.betterfoliage.util.minBy
+import net.minecraft.client.renderer.color.BlockColors
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.*
+import net.minecraft.util.Direction.Axis
+import net.minecraftforge.client.model.pipeline.LightUtil
+import kotlin.math.abs
+
+class VanillaQuadLighting {
+    val packedLight = IntArray(4)
+    val colorMultiplier = FloatArray(4)
+    val tint = FloatArray(3)
+
+    val calc = VanillaAoCalculator()
+    lateinit var blockColors: BlockColors
+
+    fun updateBlockTint(tintIndex: Int) {
+        if (tintIndex == -1) {
+            tint[0] = 1.0f; tint[1] = 1.0f; tint[2] = 1.0f
+        } else {
+            val state = calc.world.getBlockState(calc.blockPos)
+            blockColors.getColor(state, calc.world, calc.blockPos, tintIndex).let { blockTint ->
+                tint[0] = (blockTint shr 16 and 255).toFloat() / 255.0f
+                tint[1] = (blockTint shr 8 and 255).toFloat() / 255.0f
+                tint[2] = (blockTint and 255).toFloat() / 255.0f
+            }
+        }
+    }
+
+    fun applyDiffuseLighting(face: Direction) {
+        val factor = LightUtil.diffuseLight(face)
+        tint[0] *= factor; tint[1] *= factor; tint[2] *= factor
+    }
+}
+
+abstract class VanillaVertexLighter {
+    abstract fun updateLightmapAndColor(quad: HalfBakedQuad, lighting: VanillaQuadLighting)
+
+    /**
+     * Update lighting for each vertex with AO values from one of the corners.
+     * Does not calculate missing AO values!
+     * @param quad the quad to shade
+     * @param func selector function from vertex position to directed corner index of desired AO values
+     */
+    inline fun VanillaQuadLighting.updateWithCornerAo(quad: HalfBakedQuad, func: (Double3)->Int?) {
+        quad.raw.verts.forEachIndexed { idx, vertex ->
+            func(vertex.xyz)?.let {
+                packedLight[idx] = calc.aoData[it].packedLight
+                colorMultiplier[idx] = calc.aoData[it].colorMultiplier
+            }
+        }
+    }
+}
+
+/**
+ * Replicates vanilla shading for full blocks. Interpolation for non-full blocks
+ * is not implemented.
+ */
+object VanillaFullBlockLighting : VanillaVertexLighter() {
+    override fun updateLightmapAndColor(quad: HalfBakedQuad, lighting: VanillaQuadLighting) {
+        // TODO bounds checking & interpolation
+        val face = quad.raw.face()
+        lighting.calc.fillLightData(face, true)
+        lighting.updateWithCornerAo(quad) { nearestCornerOnFace(it, face) }
+        lighting.updateBlockTint(quad.baked.tintIndex)
+        if (quad.baked.isShade) lighting.applyDiffuseLighting(face)
+    }
+}
+
+object RoundLeafLightingPreferUp : VanillaVertexLighter() {
+    override fun updateLightmapAndColor(quad: HalfBakedQuad, lighting: VanillaQuadLighting) {
+        val angles = getAngles45(quad)?.let { normalFaces ->
+            lighting.calc.fillLightData(normalFaces.first)
+            lighting.calc.fillLightData(normalFaces.second)
+            if (normalFaces.first != UP && normalFaces.second != UP) lighting.calc.fillLightData(UP)
+            lighting.updateWithCornerAo(quad) { vertex ->
+                val isUp = vertex.y > 0.5f
+                val cornerUndir = AoSideHelper.getCornerUndir(vertex.x, vertex.y, vertex.z)
+                val preferredFace = if (isUp) UP else normalFaces.minBy { faceDistance(it, vertex) }
+                AoSideHelper.boxCornersDirFromUndir[preferredFace.ordinal][cornerUndir]
+            }
+            lighting.updateBlockTint(quad.baked.tintIndex)
+        }
+    }
+}
+
+/**
+ * Lights vertices with the AO values from the nearest corner on either of
+ * the 2 faces the quad normal points towards.
+ */
+object RoundLeafLighting : VanillaVertexLighter() {
+    override fun updateLightmapAndColor(quad: HalfBakedQuad, lighting: VanillaQuadLighting) {
+        val angles = getAngles45(quad)?.let { normalFaces ->
+            lighting.calc.fillLightData(normalFaces.first)
+            lighting.calc.fillLightData(normalFaces.second)
+            lighting.updateWithCornerAo(quad) { vertex ->
+                val cornerUndir = AoSideHelper.getCornerUndir(vertex.x, vertex.y, vertex.z)
+                val preferredFace = normalFaces.minBy { faceDistance(it, vertex) }
+                AoSideHelper.boxCornersDirFromUndir[preferredFace.ordinal][cornerUndir]
+            }
+            lighting.updateBlockTint(quad.baked.tintIndex)
+        }
+    }
+}
+
+/**
+ * Lights vertices with the AO values from the nearest corner on the preferred face.
+ */
+class LightingPreferredFace(val face: Direction) : VanillaVertexLighter() {
+    override fun updateLightmapAndColor(quad: HalfBakedQuad, lighting: VanillaQuadLighting) {
+        lighting.calc.fillLightData(face)
+        lighting.updateWithCornerAo(quad) { nearestCornerOnFace(it, face) }
+        lighting.updateBlockTint(quad.baked.tintIndex)
+    }
+}
+
+object ColumnLighting : VanillaVertexLighter() {
+    override fun updateLightmapAndColor(quad: HalfBakedQuad, lighting: VanillaQuadLighting) {
+        // faces pointing in cardinal directions
+        getNormalFace(quad)?.let { face ->
+            lighting.calc.fillLightData(face)
+            lighting.updateWithCornerAo(quad) { nearestCornerOnFace(it, face) }
+            lighting.updateBlockTint(quad.baked.tintIndex)
+            return
+        }
+        // faces pointing at 45deg angles
+        getAngles45(quad)?.let { (face1, face2) ->
+            lighting.calc.fillLightData(face1)
+            lighting.calc.fillLightData(face2)
+            quad.raw.verts.forEachIndexed { idx, vertex ->
+                val cornerUndir = AoSideHelper.getCornerUndir(vertex.xyz.x, vertex.xyz.y, vertex.xyz.z)
+                val cornerDir1 = AoSideHelper.boxCornersDirFromUndir[face1.ordinal][cornerUndir]
+                val cornerDir2 = AoSideHelper.boxCornersDirFromUndir[face2.ordinal][cornerUndir]
+                if (cornerDir1 == null || cornerDir2 == null) return@let
+                val ao1 = lighting.calc.aoData[cornerDir1]
+                val ao2 = lighting.calc.aoData[cornerDir2]
+                lighting.packedLight[idx] = ((ao1.packedLight + ao2.packedLight) shr 1) and 0xFF00FF
+                lighting.colorMultiplier[idx] = (ao1.colorMultiplier + ao2.colorMultiplier) * 0.5f
+            }
+            lighting.updateBlockTint(quad.baked.tintIndex)
+            return
+        }
+        // something is wrong...
+        lighting.updateWithCornerAo(quad) { nearestCornerOnFace(it, quad.raw.face()) }
+        lighting.updateBlockTint(quad.baked.tintIndex)
+    }
+}
+
+/**
+ * Return the directed box corner index for the corner nearest the given vertex,
+ * which is on the given face. May return null if the vertex is closest to
+ * one of the opposite 4 corners
+ */
+fun nearestCornerOnFace(pos: Double3, face: Direction): Int? {
+    val cornerUndir = AoSideHelper.getCornerUndir(pos.x, pos.y, pos.z)
+    return AoSideHelper.boxCornersDirFromUndir[face.ordinal][cornerUndir]
+}
+
+/**
+ * If the quad normal approximately bisects 2 axes at a 45 degree angle,
+ * and is approximately perpendicular to the third, returns the 2 directions
+ * the quad normal points towards.
+ * Returns null otherwise.
+ */
+fun getAngles45(quad: HalfBakedQuad): Pair<Direction, Direction>? {
+    val normal = quad.raw.normal
+    // one of the components must be close to zero
+    val zeroAxis = when {
+        abs(normal.x) < EPSILON_ZERO -> Axis.X
+        abs(normal.y) < EPSILON_ZERO -> Axis.Y
+        abs(normal.z) < EPSILON_ZERO -> Axis.Z
+        else -> return null
+    }
+    // the other two must be of similar magnitude
+    val diff = when(zeroAxis) {
+        Axis.X -> abs(abs(normal.y) - abs(normal.z))
+        Axis.Y -> abs(abs(normal.x) - abs(normal.z))
+        Axis.Z -> abs(abs(normal.x) - abs(normal.y))
+    }
+    if (diff > EPSILON_ZERO) return null
+    return when(zeroAxis) {
+        Axis.X -> Pair(if (normal.y > 0.0f) UP else DOWN, if (normal.z > 0.0f) SOUTH else NORTH)
+        Axis.Y -> Pair(if (normal.x > 0.0f) EAST else WEST, if (normal.z > 0.0f) SOUTH else NORTH)
+        Axis.Z -> Pair(if (normal.x > 0.0f) EAST else WEST, if (normal.y > 0.0f) UP else DOWN)
+    }
+}
+
+fun getNormalFace(quad: HalfBakedQuad) = quad.raw.normal.let { normal ->
+    when {
+        normal.x > EPSILON_ONE -> EAST
+        normal.x < -EPSILON_ONE -> WEST
+        normal.y > EPSILON_ONE -> UP
+        normal.y < -EPSILON_ONE -> DOWN
+        normal.z > EPSILON_ONE -> SOUTH
+        normal.z < -EPSILON_ONE -> NORTH
+        else -> null
+    }
+}
+
+fun faceDistance(face: Direction, pos: Double3) = when(face) {
+    WEST -> pos.x; EAST -> 1.0 - pos.x
+    DOWN -> pos.y; UP -> 1.0 - pos.y
+    NORTH -> pos.z; SOUTH -> 1.0 - pos.z
+}

src/main/kotlin/mods/betterfoliage/render/particle/AbstractParticle.kt

@@ -0,0 +1,101 @@
+package mods.betterfoliage.render.particle
+
+import com.mojang.blaze3d.vertex.IVertexBuilder
+import mods.betterfoliage.util.Double3
+import net.minecraft.client.Minecraft
+import net.minecraft.client.particle.SpriteTexturedParticle
+import net.minecraft.client.renderer.ActiveRenderInfo
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.client.world.ClientWorld
+import net.minecraft.util.math.MathHelper
+import net.minecraft.util.math.vector.Vector3f
+
+abstract class AbstractParticle(world: ClientWorld, x: Double, y: Double, z: Double) : SpriteTexturedParticle(world, x, y, z) {
+
+    companion object {
+//        @JvmStatic val sin = Array(64) { idx -> Math.sin(PI2 / 64.0 * idx) }
+//        @JvmStatic val cos = Array(64) { idx -> Math.cos(PI2 / 64.0 * idx) }
+    }
+
+    val billboardRot = Pair(Double3.zero, Double3.zero)
+    val currentPos = Double3.zero
+    val prevPos = Double3.zero
+    val velocity = Double3.zero
+
+    override fun tick() {
+        super.tick()
+        currentPos.setTo(x, y, z)
+        prevPos.setTo(xo, yo, zo)
+        velocity.setTo(xd, yd, zd)
+        update()
+        x = currentPos.x; y = currentPos.y; z = currentPos.z;
+        xd = velocity.x; yd = velocity.y; zd = velocity.z;
+    }
+
+    /** Update particle on world tick. */
+    abstract fun update()
+
+    /** True if the particle is renderable. */
+    abstract val isValid: Boolean
+
+    /** Add the particle to the effect renderer if it is valid. */
+    fun addIfValid() { if (isValid) Minecraft.getInstance().particleEngine.add(this) }
+
+    override fun render(vertexBuilder: IVertexBuilder, camera: ActiveRenderInfo, tickDelta: Float) {
+        super.render(vertexBuilder, camera, tickDelta)
+    }
+
+    /**
+     * Render a particle quad.
+     *
+     * @param[tessellator] the [Tessellator] instance to use
+     * @param[tickDelta] partial tick time
+     * @param[currentPos] render position
+     * @param[prevPos] previous tick position for interpolation
+     * @param[size] particle size
+     * @param[currentAngle] viewpoint-dependent particle rotation (64 steps)
+     * @param[sprite] particle texture
+     * @param[isMirrored] mirror particle texture along V-axis
+     * @param[alpha] aplha blending
+     */
+    fun renderParticleQuad(vertexConsumer: IVertexBuilder,
+                           camera: ActiveRenderInfo,
+                           tickDelta: Float,
+                           currentPos: Double3 = this.currentPos,
+                           prevPos: Double3 = this.prevPos,
+                           size: Double = quadSize.toDouble(),
+                           currentAngle: Float = this.roll,
+                           prevAngle: Float = this.oRoll,
+                           sprite: TextureAtlasSprite = this.sprite,
+                           alpha: Float = this.alpha) {
+
+        val center = Double3.lerp(tickDelta.toDouble(), prevPos, currentPos)
+        val angle = MathHelper.lerp(tickDelta, prevAngle, currentAngle)
+        val rotation = camera.rotation().copy().apply { mul(Vector3f.ZP.rotation(angle)) }
+        val lightmapCoord = getLightColor(tickDelta)
+
+        val coords = arrayOf(
+            Double3(-1.0, -1.0, 0.0),
+            Double3(-1.0, 1.0, 0.0),
+            Double3(1.0, 1.0, 0.0),
+            Double3(1.0, -1.0, 0.0)
+        ).map { it.rotate(rotation).mul(size).add(center).sub(camera.position.x, camera.position.y, camera.position.z) }
+
+        fun renderVertex(vertex: Double3, u: Float, v: Float) = vertexConsumer
+            .vertex(vertex.x, vertex.y, vertex.z).uv(u, v)
+            .color(rCol, gCol, bCol, alpha).uv2(lightmapCoord)
+            .endVertex()
+
+        renderVertex(coords[0], sprite.u1, sprite.v1)
+        renderVertex(coords[1], sprite.u1, sprite.v0)
+        renderVertex(coords[2], sprite.u0, sprite.v0)
+        renderVertex(coords[3], sprite.u0, sprite.v1)
+    }
+
+    fun setColor(color: Int) {
+        bCol = (color and 255) / 256.0f
+        gCol = ((color shr 8) and 255) / 256.0f
+        rCol = ((color shr 16) and 255) / 256.0f
+    }
+}
+

src/main/kotlin/mods/betterfoliage/render/particle/FallingLeaves.kt

@@ -0,0 +1,112 @@
+package mods.betterfoliage.render.particle
+
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.PI2
+import mods.betterfoliage.util.minmax
+import mods.betterfoliage.util.randomB
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.randomF
+import mods.betterfoliage.util.randomI
+import net.minecraft.client.particle.IParticleRenderType
+import net.minecraft.client.world.ClientWorld
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.MathHelper
+import net.minecraft.world.World
+import net.minecraftforge.common.MinecraftForge
+import net.minecraftforge.event.TickEvent
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import net.minecraftforge.fml.LogicalSide
+import java.util.Random
+import kotlin.math.abs
+import kotlin.math.cos
+import kotlin.math.sin
+
+class FallingLeafParticle(
+    world: ClientWorld, pos: BlockPos, leaf: LeafParticleKey, blockColor: Int, random: Random
+) : AbstractParticle(
+    world, pos.x.toDouble() + 0.5, pos.y.toDouble(), pos.z.toDouble() + 0.5
+) {
+
+    companion object {
+        @JvmStatic val biomeBrightnessMultiplier = 0.5f
+    }
+
+    var rotationSpeed = random.randomF(min = PI2 / 80.0, max = PI2 / 50.0)
+    val isMirrored = randomB()
+    var wasCollided = false
+
+    init {
+        roll = random.randomF(max = PI2)
+        oRoll = roll - rotationSpeed
+
+        lifetime = MathHelper.floor(randomD(0.6, 1.0) * Config.fallingLeaves.lifetime * 20.0)
+        yd = -Config.fallingLeaves.speed
+
+        quadSize = Config.fallingLeaves.size.toFloat() * 0.1f
+        setColor(leaf.overrideColor?.asInt ?: blockColor)
+        sprite = LeafParticleRegistry[leaf.leafType][randomI(max = 1024)]
+    }
+
+    override val isValid: Boolean get() = (sprite != null)
+
+
+    override fun update() {
+        if (random.nextFloat() > 0.95f) rotationSpeed *= -1.0f
+        if (age > lifetime - 20) alpha = 0.05f * (lifetime - age)
+
+        if (onGround || wasCollided) {
+            velocity.setTo(0.0, 0.0, 0.0)
+            if (!wasCollided) {
+                age = age.coerceAtLeast(lifetime - 20)
+                wasCollided = true
+            }
+        } else {
+            val cosRotation = cos(roll).toDouble(); val sinRotation = sin(roll).toDouble()
+            velocity.setTo(cosRotation, 0.0, sinRotation).mul(Config.fallingLeaves.perturb)
+                .add(LeafWindTracker.current).add(0.0, -1.0, 0.0).mul(Config.fallingLeaves.speed)
+            oRoll = roll
+            roll += rotationSpeed
+        }
+    }
+
+    override fun getRenderType(): IParticleRenderType = IParticleRenderType.PARTICLE_SHEET_TRANSLUCENT
+}
+
+object LeafWindTracker {
+    var random = Random()
+    val target = Double3.zero
+    val current = Double3.zero
+    var nextChange: Long = 0
+
+    init {
+        MinecraftForge.EVENT_BUS.register(this)
+    }
+
+    fun changeWind(world: World) {
+        nextChange = world.gameTime + 120 + random.nextInt(80)
+        val direction = PI2 * random.nextDouble()
+        val speed = abs(random.nextGaussian()) * Config.fallingLeaves.windStrength +
+                (if (!world.isRaining) 0.0 else abs(random.nextGaussian()) * Config.fallingLeaves.stormStrength)
+        target.setTo(cos(direction) * speed, 0.0, sin(direction) * speed)
+    }
+
+    @SubscribeEvent
+    fun handleWorldTick(event: TickEvent.WorldTickEvent) {
+        if (event.phase == TickEvent.Phase.START && event.side == LogicalSide.CLIENT) event.world.let { world ->
+            // change target wind speed
+            if (world.dayTime >= nextChange) changeWind(world)
+
+            // change current wind speed
+            val changeRate = if (world.isRaining) 0.015 else 0.005
+            current.add(
+                (target.x - current.x).minmax(-changeRate, changeRate),
+                0.0,
+                (target.z - current.z).minmax(-changeRate, changeRate)
+            )
+        }
+    }
+
+//    @SubscribeEvent
+//    fun handleWorldLoad(event: WorldEvent.Load) { if (event.world.isClientSide) changeWind(event.world) }
+}

src/main/kotlin/mods/betterfoliage/render/particle/LeafParticleRegistry.kt

@@ -0,0 +1,104 @@
+package mods.betterfoliage.render.particle
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.FixedSpriteSet
+import mods.betterfoliage.model.SpriteSet
+import mods.betterfoliage.resource.VeryEarlyReloadListener
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.HasLogger
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.getLines
+import mods.betterfoliage.util.resourceManager
+import mods.betterfoliage.util.stripStart
+import net.minecraft.client.renderer.texture.MissingTextureSprite
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.event.TextureStitchEvent
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import org.apache.logging.log4j.Level.INFO
+
+interface LeafBlockModel {
+    val key: LeafParticleKey
+}
+
+interface LeafParticleKey {
+    val leafType: String
+    val overrideColor: Color?
+}
+
+object LeafParticleRegistry : HasLogger(), VeryEarlyReloadListener {
+    val typeMappings = TextureMatcher()
+    val allTypes get() = (typeMappings.mappings.map { it.type } + "default").distinct()
+
+    val particles = hashMapOf<String, SpriteSet>()
+
+    operator fun get(type: String) = particles[type] ?: particles["default"]!!
+
+    override fun onReloadStarted() {
+        typeMappings.loadMappings(ResourceLocation(BetterFoliageMod.MOD_ID, "leaf_texture_mappings.cfg"))
+        detailLogger.log(INFO, "Loaded leaf particle mappings, types = [${allTypes.joinToString(", ")}]")
+    }
+
+    @SubscribeEvent
+    fun handlePreStitch(event: TextureStitchEvent.Pre) {
+        if (event.map.location() == Atlas.PARTICLES.resourceId) {
+            allTypes.forEach { leafType ->
+                val locations = (0 until 16).map { idx ->
+                    ResourceLocation(BetterFoliageMod.MOD_ID, "particle/falling_leaf_${leafType}_$idx")
+                }.filter { resourceManager.hasResource(Atlas.PARTICLES.file(it)) }
+
+                detailLogger.log(INFO, "Registering sprites for leaf particle type [$leafType], ${locations.size} sprites found")
+                locations.forEach { event.addSprite(it) }
+            }
+        }
+    }
+
+    @SubscribeEvent
+    fun handlePostStitch(event: TextureStitchEvent.Post) {
+        if (event.map.location() == Atlas.PARTICLES.resourceId) {
+            (typeMappings.mappings.map { it.type } + "default").distinct().forEach { leafType ->
+                val sprites = (0 until 16).map { idx ->
+                    ResourceLocation(BetterFoliageMod.MOD_ID, "particle/falling_leaf_${leafType}_$idx")
+                }
+                    .map { event.map.getSprite(it) }
+                    .filter { it !is MissingTextureSprite }
+                detailLogger.log(INFO, "Leaf particle type [$leafType], ${sprites.size} sprites in atlas")
+                particles[leafType] = FixedSpriteSet(sprites)
+            }
+        }
+    }
+}
+
+class TextureMatcher {
+
+    data class Mapping(val domain: String?, val path: String, val type: String) {
+        fun matches(iconLocation: ResourceLocation): Boolean {
+            return (domain == null || domain == iconLocation.namespace) &&
+                    iconLocation.path.stripStart("blocks/").contains(path, ignoreCase = true)
+        }
+    }
+
+    val mappings: MutableList<Mapping> = mutableListOf()
+
+    fun getType(resource: ResourceLocation) = mappings.filter { it.matches(resource) }.map { it.type }.firstOrNull()
+
+    fun loadMappings(mappingLocation: ResourceLocation) {
+        mappings.clear()
+        resourceManager[mappingLocation]?.getLines()?.let { lines ->
+            lines.filter { !it.startsWith("//") }.filter { !it.isEmpty() }.forEach { line ->
+                val line2 = line.trim().split('=')
+                if (line2.size == 2) {
+                    val mapping = line2[0].trim().split(':')
+                    if (mapping.size == 1) mappings.add(Mapping(null, mapping[0].trim(), line2[1].trim()))
+                    else if (mapping.size == 2) mappings.add(
+                        Mapping(
+                            mapping[0].trim(),
+                            mapping[1].trim(),
+                            line2[1].trim()
+                        )
+                    )
+                }
+            }
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/particle/RisingSouls.kt

@@ -0,0 +1,90 @@
+package mods.betterfoliage.render.particle
+
+import com.mojang.blaze3d.vertex.IVertexBuilder
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.SpriteDelegate
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.PI2
+import mods.betterfoliage.util.forEachPairIndexed
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.randomI
+import net.minecraft.client.particle.IParticleRenderType
+import net.minecraft.client.renderer.ActiveRenderInfo
+import net.minecraft.client.world.ClientWorld
+import net.minecraft.util.ResourceLocation
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.MathHelper
+import net.minecraft.world.World
+import java.util.Deque
+import java.util.LinkedList
+import kotlin.math.cos
+import kotlin.math.sin
+
+class RisingSoulParticle(
+    world: ClientWorld, pos: BlockPos
+) : AbstractParticle(
+    world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.toDouble() + 0.5
+) {
+
+    val particleTrail: Deque<Double3> = LinkedList<Double3>()
+    val initialPhase = randomD(max = PI2)
+
+    init {
+        yd = 0.1
+        gravity = 0.0f
+        sprite = headIcons[randomI(max = 1024)]
+        lifetime = MathHelper.floor((0.6 + 0.4 * randomD()) * Config.risingSoul.lifetime * 20.0)
+    }
+
+    override val isValid: Boolean get() = true
+
+    override fun update() {
+        val phase = initialPhase + (age.toDouble() * PI2 / 64.0)
+        val cosPhase = cos(phase);
+        val sinPhase = sin(phase)
+        velocity.setTo(Config.risingSoul.perturb.let { Double3(cosPhase * it, 0.1, sinPhase * it) })
+
+        particleTrail.addFirst(currentPos.copy())
+        while (particleTrail.size > Config.risingSoul.trailLength) particleTrail.removeLast()
+
+        if (!Config.enabled) remove()
+    }
+
+    override fun render(vertexBuilder: IVertexBuilder, camera: ActiveRenderInfo, tickDelta: Float) {
+        var alpha = Config.risingSoul.opacity.toFloat()
+        if (age > lifetime - 40) alpha *= (lifetime - age) / 40.0f
+
+        renderParticleQuad(
+            vertexBuilder, camera, tickDelta,
+            size = Config.risingSoul.headSize * 0.25,
+            alpha = alpha
+        )
+
+        var scale = Config.risingSoul.trailSize * 0.25
+        particleTrail.forEachPairIndexed { idx, current, previous ->
+            scale *= Config.risingSoul.sizeDecay
+            alpha *= Config.risingSoul.opacityDecay.toFloat()
+            if (idx % Config.risingSoul.trailDensity == 0)
+                renderParticleQuad(
+                    vertexBuilder, camera, tickDelta,
+                    currentPos = current,
+                    prevPos = previous,
+                    size = scale,
+                    alpha = alpha,
+                    sprite = trackIcon
+                )
+        }
+    }
+
+    override fun getRenderType(): IParticleRenderType = IParticleRenderType.PARTICLE_SHEET_TRANSLUCENT
+
+    companion object {
+        val headIcons by SpriteSetDelegate(Atlas.PARTICLES) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "particle/rising_soul_$idx")
+        }
+        val trackIcon by SpriteDelegate(Atlas.PARTICLES) { ResourceLocation(BetterFoliageMod.MOD_ID, "particle/soul_track") }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxBase.kt

@@ -0,0 +1,66 @@
+package mods.betterfoliage.render.pipeline
+
+import com.mojang.blaze3d.matrix.MatrixStack
+import mods.betterfoliage.chunk.BasicBlockCtx
+import mods.betterfoliage.chunk.BlockCtx
+import mods.betterfoliage.model.HalfBakedQuad
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.render.lighting.VanillaFullBlockLighting
+import mods.betterfoliage.render.lighting.VanillaQuadLighting
+import mods.betterfoliage.render.lighting.VanillaVertexLighter
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.plus
+import net.minecraft.block.Block
+import net.minecraft.client.Minecraft
+import net.minecraft.util.Direction
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockDisplayReader
+import net.minecraftforge.client.model.data.IModelData
+import java.util.Random
+
+/**
+ * Rendering context for drawing [SpecialRenderModel] models.
+ *
+ * This class (and others in its constellation) basically form a replacement, highly customizable,
+ * push-based partial rendering pipeline for [SpecialRenderModel] instances.
+ */
+abstract class RenderCtxBase(
+    world: IBlockDisplayReader,
+    pos: BlockPos,
+    val matrixStack: MatrixStack,
+    var checkSides: Boolean,
+    val random: Random,
+    val modelData: IModelData
+) : BlockCtx by BasicBlockCtx(world, pos) {
+
+    abstract fun renderQuad(quad: HalfBakedQuad)
+
+    var hasRendered = false
+    val blockModelShapes = Minecraft.getInstance().blockRenderer.blockModelShaper
+    var vertexLighter: VanillaVertexLighter = VanillaFullBlockLighting
+    protected val lightingData = RenderCtxBase.lightingData.get().apply {
+        calc.reset(this@RenderCtxBase)
+        blockColors = Minecraft.getInstance().blockColors
+    }
+
+    inline fun Direction?.shouldRender() = this == null || !checkSides || Block.shouldRenderFace(state, world, pos, this)
+
+    fun renderQuads(quads: Iterable<HalfBakedQuad>) {
+        quads.forEach { quad ->
+            if (quad.raw.face.shouldRender()) {
+                renderQuad(quad)
+                hasRendered = true
+            }
+        }
+    }
+
+    fun renderMasquerade(offset: Int3, func: () -> Unit) {
+        lightingData.calc.blockPos += offset
+        func()
+        lightingData.calc.blockPos = pos
+    }
+
+    companion object {
+        val lightingData = ThreadLocal.withInitial { VanillaQuadLighting() }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxForge.kt

@@ -0,0 +1,74 @@
+package mods.betterfoliage.render.pipeline
+
+import com.mojang.blaze3d.matrix.MatrixStack
+import mods.betterfoliage.model.HalfBakedQuad
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.render.lighting.ForgeVertexLighter
+import mods.betterfoliage.render.lighting.ForgeVertexLighterAccess
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.LightTexture
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockDisplayReader
+import net.minecraftforge.client.model.data.IModelData
+import net.minecraftforge.client.model.pipeline.VertexLighterFlat
+import java.util.Random
+
+class RenderCtxForge(
+    world: IBlockDisplayReader,
+    pos: BlockPos,
+    val lighter: VertexLighterFlat,
+    matrixStack: MatrixStack,
+    checkSides: Boolean,
+    random: Random,
+    modelData: IModelData
+): RenderCtxBase(world, pos, matrixStack, checkSides, random, modelData), ForgeVertexLighter {
+
+    override fun renderQuad(quad: HalfBakedQuad) {
+        // set Forge lighter AO calculator to us
+        vertexLighter.updateLightmapAndColor(quad, lightingData)
+        quad.baked.pipe(lighter)
+    }
+
+    // somewhat ugly hack to pipe lighting values into the Forge pipeline
+    var vIdx = 0
+    override fun updateVertexLightmap(normal: FloatArray, lightmap: FloatArray, x: Float, y: Float, z: Float) {
+        lightingData.packedLight[vIdx].let { packedLight ->
+            lightmap[0] = LightTexture.block(packedLight) / 0xF.toFloat()
+            lightmap[1] = LightTexture.sky(packedLight) / 0xF.toFloat()
+        }
+    }
+
+    override fun updateVertexColor(normal: FloatArray, color: FloatArray, x: Float, y: Float, z: Float, tint: Float, multiplier: Int) {
+        color[0] = lightingData.tint[0] * lightingData.colorMultiplier[vIdx]
+        color[1] = lightingData.tint[1] * lightingData.colorMultiplier[vIdx]
+        color[2] = lightingData.tint[2] * lightingData.colorMultiplier[vIdx]
+        vIdx++
+    }
+
+    companion object {
+        @JvmStatic
+        fun render(
+            lighter: VertexLighterFlat,
+            world: IBlockDisplayReader,
+            model: SpecialRenderModel,
+            state: BlockState,
+            pos: BlockPos,
+            matrixStack: MatrixStack,
+            checkSides: Boolean,
+            rand: Random, seed: Long,
+            modelData: IModelData
+        ): Boolean {
+            lighter.setWorld(world)
+            lighter.setState(state)
+            lighter.setBlockPos(pos)
+            rand.setSeed(seed)
+            lighter.updateBlockInfo()
+            return RenderCtxForge(world, pos, lighter, matrixStack, checkSides, rand, modelData).let {
+                (lighter as ForgeVertexLighterAccess).vertexLighter = it
+                model.render(it, false)
+                lighter.resetBlockInfo()
+                it.hasRendered
+            }
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxVanilla.kt

@@ -0,0 +1,66 @@
+package mods.betterfoliage.render.pipeline
+
+import com.mojang.blaze3d.matrix.MatrixStack
+import com.mojang.blaze3d.vertex.IVertexBuilder
+import mods.betterfoliage.model.HalfBakedQuad
+import mods.betterfoliage.model.SpecialRenderModel
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.BlockModelRenderer
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockDisplayReader
+import net.minecraftforge.client.model.data.IModelData
+import java.util.Random
+
+class RenderCtxVanilla(
+    val renderer: BlockModelRenderer,
+    world: IBlockDisplayReader,
+    pos: BlockPos,
+    val buffer: IVertexBuilder,
+    val combinedOverlay: Int,
+    matrixStack: MatrixStack,
+    checkSides: Boolean,
+    random: Random,
+    val seed: Long,
+    modelData: IModelData,
+    val useAO: Boolean
+): RenderCtxBase(world, pos, matrixStack, checkSides, random, modelData) {
+
+    override fun renderQuad(quad: HalfBakedQuad) {
+        vertexLighter.updateLightmapAndColor(quad, lightingData)
+        buffer.putBulkData(
+            matrixStack.last(), quad.baked,
+            lightingData.colorMultiplier,
+            lightingData.tint[0], lightingData.tint[1], lightingData.tint[2],
+            lightingData.packedLight, combinedOverlay, true
+        )
+    }
+
+    companion object {
+        @JvmStatic
+        fun render(
+            renderer: BlockModelRenderer,
+            world: IBlockDisplayReader,
+            model: SpecialRenderModel,
+            state: BlockState,
+            pos: BlockPos,
+            matrixStack: MatrixStack,
+            buffer: IVertexBuilder,
+            checkSides: Boolean,
+            random: Random,
+            rand: Long,
+            combinedOverlay: Int,
+            modelData: IModelData,
+            smooth: Boolean
+        ): Boolean {
+            random.setSeed(rand)
+            val ctx = RenderCtxVanilla(renderer, world, pos, buffer, combinedOverlay, matrixStack, checkSides, random, rand, modelData, smooth)
+            lightingData.apply {
+
+            }
+            model.render(ctx, false)
+            return ctx.hasRendered
+        }
+
+
+    }
+}

src/main/kotlin/mods/betterfoliage/resource/VeryEarlyReloadListener.kt

@@ -0,0 +1,27 @@
+package mods.betterfoliage.resource
+
+import net.minecraft.profiler.IProfiler
+import net.minecraft.resources.IFutureReloadListener
+import net.minecraft.resources.IResourceManager
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Executor
+
+/**
+ * Catch resource reload extremely early, before any of the reloaders
+ * have started working.
+ */
+interface VeryEarlyReloadListener : IFutureReloadListener {
+    override fun reload(
+        stage: IFutureReloadListener.IStage,
+        resourceManager: IResourceManager,
+        preparationsProfiler: IProfiler,
+        reloadProfiler: IProfiler,
+        backgroundExecutor: Executor,
+        gameExecutor: Executor
+    ): CompletableFuture<Void> {
+        onReloadStarted()
+        return stage.wait(null)
+    }
+
+    fun onReloadStarted() {}
+}

src/main/kotlin/mods/betterfoliage/resource/discovery/BakingLifecycle.kt

@@ -0,0 +1,129 @@
+package mods.betterfoliage.resource.discovery
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.HasLogger
+import mods.betterfoliage.util.Invalidator
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.model.IBakedModel
+import net.minecraft.client.renderer.model.IModelTransform
+import net.minecraft.client.renderer.model.IUnbakedModel
+import net.minecraft.client.renderer.model.ModelBakery
+import net.minecraft.client.renderer.model.RenderMaterial
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.event.ModelBakeEvent
+import net.minecraftforge.client.event.TextureStitchEvent
+import net.minecraftforge.eventbus.api.Event
+import net.minecraftforge.eventbus.api.EventPriority
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import net.minecraftforge.fml.loading.progress.StartupMessageManager
+import org.apache.logging.log4j.Level.INFO
+import org.apache.logging.log4j.Level.WARN
+import org.apache.logging.log4j.Logger
+import java.lang.ref.WeakReference
+import java.util.function.Function
+
+data class ModelDefinitionsLoadedEvent(
+    val bakery: ModelBakery
+) : Event()
+
+interface ModelBakingKey {
+    fun bake(ctx: ModelBakingContext): IBakedModel? =
+        ctx.getUnbaked().bake(ctx.bakery, ctx.spriteGetter, ctx.transform, ctx.location)
+}
+
+interface ModelDiscovery {
+    fun onModelsLoaded(
+        bakery: ModelBakery,
+        sprites: MutableSet<ResourceLocation>,
+        replacements: MutableMap<ResourceLocation, ModelBakingKey>
+    )
+}
+
+data class ModelDiscoveryContext(
+    val bakery: ModelBakery,
+    val blockState: BlockState,
+    val modelLocation: ResourceLocation,
+    val sprites: MutableSet<ResourceLocation>,
+    val replacements: MutableMap<ResourceLocation, ModelBakingKey>,
+    val logger: Logger
+) {
+    fun getUnbaked(location: ResourceLocation = modelLocation) = bakery.getModel(location)
+    fun addReplacement(key: ModelBakingKey, addToStateKeys: Boolean = true) {
+        replacements[modelLocation] = key
+        if (addToStateKeys) BetterFoliage.blockTypes.stateKeys[blockState] = key
+        logger.log(INFO, "Adding model replacement $modelLocation -> $key")
+    }
+}
+
+data class ModelBakingContext(
+    val bakery: ModelBakery,
+    val spriteGetter: Function<RenderMaterial, TextureAtlasSprite>,
+    val location: ResourceLocation,
+    val transform: IModelTransform,
+    val logger: Logger
+) {
+    fun getUnbaked() = bakery.getModel(location)
+    fun getBaked() = bakery.getBakedModel(location, transform, spriteGetter)
+}
+
+object BakeWrapperManager : Invalidator, HasLogger() {
+    val discoverers = mutableListOf<ModelDiscovery>()
+    override val callbacks = mutableListOf<WeakReference<()->Unit>>()
+
+    private val replacements = mutableMapOf<ResourceLocation, ModelBakingKey>()
+    private val sprites = mutableSetOf<ResourceLocation>()
+
+    @SubscribeEvent(priority = EventPriority.LOWEST)
+    fun handleModelLoad(event: ModelDefinitionsLoadedEvent) {
+        val startTime = System.currentTimeMillis()
+        invalidate()
+        BetterFoliage.blockTypes = BlockTypeCache()
+
+        StartupMessageManager.addModMessage("BetterFoliage: discovering models")
+        logger.log(INFO, "starting model discovery (${discoverers.size} listeners)")
+        discoverers.forEach { listener ->
+            val replacementsLocal = mutableMapOf<ResourceLocation, ModelBakingKey>()
+            listener.onModelsLoaded(event.bakery, sprites, replacements)
+        }
+
+        val elapsed = System.currentTimeMillis() - startTime
+        logger.log(INFO, "finished model discovery in $elapsed ms, ${replacements.size} top-level replacements")
+    }
+
+    @SubscribeEvent
+    fun handleStitch(event: TextureStitchEvent.Pre) {
+        if (event.map.location() == Atlas.BLOCKS.resourceId) {
+            logger.log(INFO, "Adding ${sprites.size} sprites to block atlas")
+            sprites.forEach { event.addSprite(it) }
+            sprites.clear()
+        }
+    }
+
+    @SubscribeEvent
+    fun handleModelBake(event: ModelBakeEvent) {
+        replacements.clear()
+    }
+
+    fun onBake(
+        unbaked: IUnbakedModel,
+        bakery: ModelBakery,
+        spriteGetter: Function<RenderMaterial, TextureAtlasSprite>,
+        transform: IModelTransform,
+        location: ResourceLocation
+    ): IBakedModel? {
+        val ctx = ModelBakingContext(bakery, spriteGetter, location, transform, detailLogger)
+        // bake replacement if available
+        replacements[location]?.let { replacement ->
+            detailLogger.log(INFO, "Baking replacement for [${unbaked::class.java.simpleName}] $location -> $replacement")
+            try {
+                return replacement.bake(ctx)
+            } catch (e: Exception) {
+                detailLogger.log(WARN, "Error while baking $replacement", e)
+                logger.log(WARN, "Error while baking $replacement", e)
+            }
+        }
+        return unbaked.bake(bakery, spriteGetter, transform, location)
+    }
+}

src/main/kotlin/mods/betterfoliage/resource/discovery/BlockTypeCache.kt

@@ -0,0 +1,14 @@
+package mods.betterfoliage.resource.discovery
+
+import net.minecraft.block.BlockState
+
+class BlockTypeCache {
+    val leaf = mutableSetOf<BlockState>()
+    val grass = mutableSetOf<BlockState>()
+    val dirt = mutableSetOf<BlockState>()
+
+    val stateKeys = mutableMapOf<BlockState, ModelBakingKey>()
+
+    inline fun <reified T> getTypedOrNull(state: BlockState) = stateKeys[state] as? T
+    inline fun <reified T> hasTyped(state: BlockState) = stateKeys[state] is T
+}

src/main/kotlin/mods/betterfoliage/resource/discovery/Matchers.kt

@@ -0,0 +1,73 @@
+package mods.betterfoliage.resource.discovery
+
+import mods.betterfoliage.util.HasLogger
+import mods.betterfoliage.util.getJavaClass
+import mods.betterfoliage.util.getLines
+import mods.betterfoliage.util.resourceManager
+import net.minecraft.block.Block
+import net.minecraft.util.ResourceLocation
+import org.apache.logging.log4j.Level.INFO
+
+interface IBlockMatcher {
+    fun matchesClass(block: Block): Boolean
+    fun matchingClass(block: Block): Class<*>?
+}
+
+class SimpleBlockMatcher(vararg val classes: Class<*>) : IBlockMatcher {
+    override fun matchesClass(block: Block) = matchingClass(block) != null
+
+    override fun matchingClass(block: Block): Class<*>? {
+        val blockClass = block.javaClass
+        classes.forEach { if (it.isAssignableFrom(blockClass)) return it }
+        return null
+    }
+}
+
+class ConfigurableBlockMatcher(val location: ResourceLocation) : HasLogger(), IBlockMatcher {
+    val blackList = mutableListOf<Class<*>>()
+    val whiteList = mutableListOf<Class<*>>()
+
+    override fun matchesClass(block: Block): Boolean {
+        val blockClass = block.javaClass
+        blackList.forEach { if (it.isAssignableFrom(blockClass)) return false }
+        whiteList.forEach { if (it.isAssignableFrom(blockClass)) return true }
+        return false
+    }
+
+    override fun matchingClass(block: Block): Class<*>? {
+        val blockClass = block.javaClass
+        blackList.forEach { if (it.isAssignableFrom(blockClass)) return null }
+        whiteList.forEach { if (it.isAssignableFrom(blockClass)) return it }
+        return null
+    }
+
+    fun readDefaults() {
+        blackList.clear()
+        whiteList.clear()
+        resourceManager.getResources(location).forEach { resource ->
+            detailLogger.log(INFO, "Reading block class configuration $location from pack ${resource.sourceName}")
+            resource.getLines().map{ it.trim() }.filter { !it.startsWith("//") && it.isNotEmpty() }.forEach { line ->
+                if (line.startsWith("-")) getJavaClass(line.substring(1))?.let { blackList.add(it) }
+                else getJavaClass(line)?.let { whiteList.add(it) }
+
+            }
+        }
+    }
+}
+
+data class ModelTextureList(val modelLocation: ResourceLocation, val textureNames: List<String>) {
+    constructor(vararg args: String) : this(ResourceLocation(args[0]), listOf(*args).drop(1))
+}
+
+class ModelTextureListConfiguration(val location: ResourceLocation) : HasLogger() {
+    val modelList = mutableListOf<ModelTextureList>()
+    fun readDefaults() {
+        resourceManager.getResources(location).forEach { resource ->
+            detailLogger.log(INFO, "Reading model/texture configuration $location from pack ${resource.sourceName}")
+            resource.getLines().map{ it.trim() }.filter { !it.startsWith("//") && it.isNotEmpty() }.forEach { line ->
+                val elements = line.split(",")
+                modelList.add(ModelTextureList(ResourceLocation(elements.first()), elements.drop(1)))
+            }
+        }
+    }
+}