added beach to default coral biomes

bump version

.classpath

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry kind="src" path="src/main/resources"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.springsource.ide.eclipse.gradle.classpathcontainer"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.gitignore

@@ -1,10 +1,5 @@
-.idea/
-*.iml
-*.ipr
-*.iws
-run/
 .gradle/
+.settings/
+bin/
 build/
-classes/
-temp/
-logs
+libs/

.project

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>BetterFoliage</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.springsource.ide.eclipse.gradle.core.nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

README.md

@@ -1,4 +1,9 @@
 BetterFoliage
 =============
-
 Minecraft mod that alters the appearance of leaves & grass
+
+More info: http://www.minecraftforum.net/topic/2776217-better-foliage/
+
+Latest Download
+========
+[BetterFoliage 0.9.10-beta] (http://goo.gl/oaSfCY) (MC 1.7.2 & 1.7.10)

build.gradle

@@ -0,0 +1,45 @@
+buildscript {
+	repositories {
+		mavenCentral()
+		maven {
+			name = "forge"
+			url = "http://files.minecraftforge.net/maven"
+		}
+		maven {
+			name = "sonatype"
+			url = "https://oss.sonatype.org/content/repositories/snapshots/"
+		}
+	}
+	dependencies {
+		classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT'
+	}
+}
+apply plugin: 'forge'
+
+minecraft {
+	version = '1.7.2-10.12.2.1147'
+}
+
+jar.baseName = 'BetterFoliage'
+group = 'com.github.octarine-noise'
+version='0.9.11b'
+
+processResources {
+	inputs.property "version", project.version
+	inputs.property "mcversion", project.minecraft.version
+	
+	from(sourceSets.main.resources.srcDirs) {
+		include 'mcmod.info'
+		expand 'version':project.version, 'mcversion':project.minecraft.version
+	}
+
+	from(sourceSets.main.resources.srcDirs) {
+		exclude 'mcmod.info'
+	}
+}
+
+jar {
+	manifest {
+		attributes("FMLCorePlugin": "mods.betterfoliage.loader.BetterFoliageLoader", "FMLCorePluginContainsFMLMod": "mods.betterfoliage.BetterFoliage")
+	}
+}

build.gradle.kts

@@ -1,67 +0,0 @@
-plugins {
-    kotlin("jvm").version("1.3.61")
-    id("net.minecraftforge.gradle").version("3.0.194")
-    id("org.spongepowered.mixin").version("0.7-SNAPSHOT")
-}
-apply(plugin = "org.spongepowered.mixin")
-
-repositories {
-    maven("http://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")
-}
-
-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"("kottle:Kottle:${properties["kottleVersion"]}")
-//    "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,14 +0,0 @@
-org.gradle.jvmargs=-Xmx2G
-org.gradle.daemon=false
-
-group = com.github.octarine-noise
-jarName = BetterFoliage-Forge
-
-version = 2.6.3
-
-mcVersion = 1.15.2
-forgeVersion = 31.2.44
-mappingsChannel = snapshot
-mappingsVersion = 20200514-1.15.1
-
-kottleVersion = 1.4.0

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -1,172 +0,0 @@
-#!/usr/bin/env sh
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-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=""
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-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
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-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
-if $cygwin ; 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
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-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,84 +0,0 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@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=
-
-@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
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-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%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

settings.gradle.kts

@@ -1,13 +0,0 @@
-pluginManagement {
-    repositories {
-        maven("http://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/BetterFoliage.java

@@ -0,0 +1,52 @@
+package mods.betterfoliage;
+
+import java.io.File;
+import java.util.Map;
+
+import mods.betterfoliage.client.BetterFoliageClient;
+import mods.betterfoliage.common.config.Config;
+
+import org.apache.logging.log4j.Logger;
+
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.network.NetworkCheckHandler;
+import cpw.mods.fml.relauncher.Side;
+
+@Mod(name=BetterFoliage.MOD_NAME, modid=BetterFoliage.MOD_ID, acceptedMinecraftVersions=BetterFoliage.MC_VERSIONS, guiFactory=BetterFoliage.GUI_FACTORY)
+public class BetterFoliage {
+
+	public static final String MOD_ID = "BetterFoliage";
+	public static final String MOD_NAME = "Better Foliage";
+	public static final String MC_VERSIONS = "[1.7.2,1.7.10]";
+	public static final String GUI_FACTORY = "mods.betterfoliage.client.gui.ConfigGuiFactory";
+	
+	@Mod.Instance
+	public static BetterFoliage instance;
+	
+	public static Logger log;
+	
+	public static File configDir;
+	
+	@Mod.EventHandler
+	public void preInit(FMLPreInitializationEvent event)  {
+		log = event.getModLog();
+		configDir = new File(event.getModConfigurationDirectory(), MOD_ID);
+		configDir.mkdir();
+	}
+	
+	@Mod.EventHandler
+	public void posInit(FMLPostInitializationEvent event)  {
+	    if (event.getSide() == Side.CLIENT) {
+	        Config.getDefaultBiomes();
+            Config.readConfig(new File(configDir, "betterfoliage.cfg"));
+            BetterFoliageClient.postInit();
+        }
+	}
+	
+	@NetworkCheckHandler
+	public boolean checkVersion(Map<String, String> mods, Side side) {
+		return true;
+	}
+}

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

@@ -1,18 +0,0 @@
-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/client/BetterFoliageClient.java

@@ -0,0 +1,113 @@
+package mods.betterfoliage.client;
+
+import java.util.Map;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.client.render.impl.EntityFXFallingLeaves;
+import mods.betterfoliage.client.render.impl.RenderBlockBetterAlgae;
+import mods.betterfoliage.client.render.impl.RenderBlockBetterCactus;
+import mods.betterfoliage.client.render.impl.RenderBlockBetterCoral;
+import mods.betterfoliage.client.render.impl.RenderBlockBetterGrass;
+import mods.betterfoliage.client.render.impl.RenderBlockBetterLeaves;
+import mods.betterfoliage.client.render.impl.RenderBlockBetterLilypad;
+import mods.betterfoliage.client.render.impl.RenderBlockBetterMycelium;
+import mods.betterfoliage.client.render.impl.RenderBlockBetterReed;
+import mods.betterfoliage.client.render.impl.RenderBlocksBetterGrassSide;
+import mods.betterfoliage.client.resource.LeafGenerator;
+import mods.betterfoliage.client.resource.LeafParticleTextures;
+import mods.betterfoliage.client.resource.LeafTextureEnumerator;
+import mods.betterfoliage.client.resource.ReedGenerator;
+import mods.betterfoliage.client.resource.ShortGrassGenerator;
+import mods.betterfoliage.common.config.Config;
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+
+import com.google.common.collect.Maps;
+
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import cpw.mods.fml.common.FMLCommonHandler;
+
+public class BetterFoliageClient {
+
+	public static ResourceLocation missingTexture = new ResourceLocation("betterfoliage", "textures/blocks/missing_leaf.png");
+	
+	public static Map<Integer, IRenderBlockDecorator> decorators = Maps.newHashMap();
+	public static LeafGenerator leafGenerator = new LeafGenerator();
+	public static LeafParticleTextures leafParticles = new LeafParticleTextures(0);
+	public static WindTracker wind = new WindTracker();
+	
+	public static void postInit() {
+		FMLCommonHandler.instance().bus().register(new KeyHandler());
+		FMLCommonHandler.instance().bus().register(new Config());
+		
+		BetterFoliage.log.info("Registering renderers");
+		registerRenderer(new RenderBlockBetterCactus());
+		registerRenderer(new RenderBlockBetterLilypad());
+		registerRenderer(new RenderBlockBetterMycelium());
+		registerRenderer(new RenderBlockBetterLeaves());
+		registerRenderer(new RenderBlockBetterGrass());
+		registerRenderer(new RenderBlockBetterReed());
+		registerRenderer(new RenderBlockBetterAlgae());
+		registerRenderer(new RenderBlockBetterCoral());
+		registerRenderer(new RenderBlocksBetterGrassSide());
+
+		MinecraftForge.EVENT_BUS.register(wind);
+		FMLCommonHandler.instance().bus().register(wind);
+		
+		MinecraftForge.EVENT_BUS.register(Config.leaves);
+		MinecraftForge.EVENT_BUS.register(Config.crops);
+		MinecraftForge.EVENT_BUS.register(Config.dirt);
+		MinecraftForge.EVENT_BUS.register(Config.grass);
+		
+		BetterFoliage.log.info("Registering texture generators");
+		MinecraftForge.EVENT_BUS.register(leafGenerator);
+		MinecraftForge.EVENT_BUS.register(leafParticles);
+		MinecraftForge.EVENT_BUS.register(new LeafTextureEnumerator());
+		
+		MinecraftForge.EVENT_BUS.register(new ReedGenerator("bf_reed_bottom", missingTexture, true));
+		MinecraftForge.EVENT_BUS.register(new ReedGenerator("bf_reed_top", missingTexture, false));
+		MinecraftForge.EVENT_BUS.register(new ShortGrassGenerator("bf_shortgrass", missingTexture, false));
+		MinecraftForge.EVENT_BUS.register(new ShortGrassGenerator("bf_shortgrass_snow", missingTexture, true));
+		
+		ShadersModIntegration.init();
+	}
+
+	public static boolean isLeafTexture(TextureAtlasSprite icon) {
+		String resourceLocation = icon.getIconName();
+		if (resourceLocation.startsWith("forestry:leaves/")) return true;
+		return false;
+	}
+	
+	public static int getRenderTypeOverride(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		// universal sign for DON'T RENDER ME!
+		if (original == -1) return original;
+		
+		for (Map.Entry<Integer, IRenderBlockDecorator> entry : decorators.entrySet())
+			if (entry.getValue().isBlockAccepted(blockAccess, x, y, z, block, original))
+				return entry.getKey();
+		
+		return original;
+	}
+	
+	public static void onRandomDisplayTick(Block block, World world, int x, int y, int z) {
+		if (!Config.leafFXEnabled) return;
+		if (!Config.leaves.matchesID(block) || !world.isAirBlock(x, y - 1, z)) return;
+		if (Math.random() > Config.leafFXChance) return;
+		Minecraft.getMinecraft().effectRenderer.addEffect(new EntityFXFallingLeaves(world, x, y, z));
+	}
+	
+	public static void registerRenderer(IRenderBlockDecorator decorator) {
+		int renderId = RenderingRegistry.getNextAvailableRenderId();
+		decorators.put(renderId, decorator);
+		RenderingRegistry.registerBlockHandler(renderId, decorator);
+		MinecraftForge.EVENT_BUS.register(decorator);
+		decorator.init();
+	}
+
+}

src/main/java/mods/betterfoliage/client/BlockMatcher.java

@@ -0,0 +1,93 @@
+package mods.betterfoliage.client;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+
+import mods.betterfoliage.BetterFoliage;
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.event.world.WorldEvent;
+
+import com.google.common.base.Charsets;
+import com.google.common.collect.Sets;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+public class BlockMatcher {
+
+	public Set<Class<?>> whiteList = Sets.newHashSet();
+	public Set<Class<?>> blackList = Sets.newHashSet();
+	public Set<Integer> blockIDs = Sets.newHashSet();
+
+	public boolean matchesClass(Block block) {
+		for (Class<?> clazz : blackList) if (clazz.isAssignableFrom(block.getClass())) return false;
+		for (Class<?> clazz : whiteList) if (clazz.isAssignableFrom(block.getClass())) return true;
+		return false;
+	}
+	
+	public boolean matchesID(int blockId) {
+		return blockIDs.contains(blockId);
+	}
+	
+	public boolean matchesID(Block block) {
+		return blockIDs.contains(Block.blockRegistry.getIDForObject(block));
+	}
+	
+	public void updateClassLists(String[] newWhitelist, String[] newBlacklist) {
+	    whiteList.clear();
+	    for(String className : newWhitelist) try {
+	        whiteList.add(Class.forName(className));
+	    } catch(ClassNotFoundException e) {}
+	    
+	    blackList.clear();
+        for(String className : newBlacklist) try {
+            blackList.add(Class.forName(className));
+        } catch(ClassNotFoundException e) {}
+        
+        updateBlockIDs();
+	}
+	
+	@SuppressWarnings("unchecked")
+    public void updateBlockIDs() {
+	    blockIDs.clear();
+        Iterator<Block> iter = Block.blockRegistry.iterator();
+        while (iter.hasNext()) {
+            Block block = iter.next();
+            if (matchesClass(block)) blockIDs.add(Block.blockRegistry.getIDForObject(block));
+        }
+	}
+	
+	public static void loadDefaultLists(ResourceLocation defaults, Collection<String> blacklist, Collection<String> whitelist) {
+	    BufferedReader reader = null;
+        try {
+            reader = new BufferedReader(new InputStreamReader(Minecraft.getMinecraft().getResourceManager().getResource(defaults).getInputStream(), Charsets.UTF_8));
+            String line = reader.readLine();
+            while(line != null) {
+                line = line.trim();
+                if (!line.isEmpty() && !line.startsWith("//")) {
+                    if (line.startsWith("-"))
+                        blacklist.add(line.substring(1));
+                    else
+                        whitelist.add(line);
+                }
+                line = reader.readLine();
+            }
+            reader.close();
+        } catch (Exception e) {
+            BetterFoliage.log.warn(String.format("Error reading configuration %s", defaults.toString()));
+        }
+	}
+	
+	/** Caches block IDs on world load for fast lookup
+	 * @param event
+	 */
+	@SubscribeEvent
+	public void handleWorldLoad(WorldEvent.Load event) {
+		if (event.world instanceof WorldClient) updateBlockIDs();
+	}
+}

src/main/java/mods/betterfoliage/client/KeyHandler.java

@@ -0,0 +1,27 @@
+package mods.betterfoliage.client;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.gui.ConfigGuiFactory;
+import net.minecraft.client.settings.KeyBinding;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.InputEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class KeyHandler {
+	
+	public static KeyBinding guiBinding;
+	
+	public KeyHandler() {
+		guiBinding = new KeyBinding("key.betterfoliage.gui", 66, BetterFoliage.MOD_NAME);
+		ClientRegistry.registerKeyBinding(guiBinding);
+	}
+	
+	@SubscribeEvent
+	public void handleKeyPress(InputEvent.KeyInputEvent event) {
+		if (guiBinding.isPressed()) FMLClientHandler.instance().showGuiScreen(new ConfigGuiFactory.ConfigGuiBetterFoliage(null));
+	}
+}

src/main/java/mods/betterfoliage/client/ShadersModIntegration.java

@@ -0,0 +1,86 @@
+package mods.betterfoliage.client;
+
+import java.lang.reflect.Field;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import mods.betterfoliage.common.config.Config;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.ResourceLocation;
+
+/** Call hooks and helper methods for dealing with Shaders Mod.
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public class ShadersModIntegration {
+
+	private static boolean hasShadersMod = false;
+	private static int tallGrassEntityData;
+	private static int leavesEntityData;
+	private static Field shadersEntityData;
+	private static Field shadersEntityDataIndex;
+	
+	/** Hide constructor */
+	private ShadersModIntegration() {}
+	
+	public static void init() {
+		tallGrassEntityData = Block.blockRegistry.getIDForObject(Blocks.tallgrass) & 0xFFFF | Blocks.tallgrass.getRenderType() << 16;
+		leavesEntityData = Block.blockRegistry.getIDForObject(Blocks.leaves) & 0xFFFF | Blocks.leaves.getRenderType() << 16;
+		
+		try {
+			Class<?> classShaders = Class.forName("shadersmodcore.client.Shaders");
+			shadersEntityData = classShaders.getDeclaredField("entityData");
+			shadersEntityDataIndex = classShaders.getDeclaredField("entityDataIndex");
+			hasShadersMod = true;
+		} catch(Exception e) {
+		}
+	}
+	
+	/** Signal start of grass-type quads
+	 */
+	public static void startGrassQuads() {
+		if (!hasShadersMod) return;
+		setShadersEntityData(tallGrassEntityData);
+	}
+
+	/** Signal start of leaf-type quads
+	 */
+	public static void startLeavesQuads() {
+		if (!hasShadersMod) return;
+		setShadersEntityData(leavesEntityData);
+	}
+	
+	/** Change the entity data (containing block ID) for the currently rendered block.
+	 *  Quads drawn afterwards will have the altered data.
+	 * @param data
+	 */
+	private static void setShadersEntityData(int data) {
+		try {
+			int[] entityData = (int[]) shadersEntityData.get(null);
+			int entityDataIndex = shadersEntityDataIndex.getInt(null);
+			entityData[(entityDataIndex * 2)] = data;
+		} catch (Exception e) {
+		}
+	}
+	
+	/** Call hook from transformed ShadersMod class
+	 * @param original entity data of currently rendered block
+	 * @param block the block
+	 * @return entity data to use
+	 */
+	public static int getBlockIdOverride(int original, Block block) {
+		if (Config.leaves.matchesID(original & 0xFFFF)) return leavesEntityData;
+		if (Config.crops.matchesID(original & 0xFFFF)) return tallGrassEntityData;
+		return original;
+	}
+	
+	/**
+	 * @param resource texture resource
+	 * @return true if texture is a normal or specular map
+	 */
+	public static boolean isSpecialTexture(ResourceLocation resource) {
+		return resource.getResourcePath().toLowerCase().endsWith("_n.png") || resource.getResourcePath().toLowerCase().endsWith("_s.png");
+	}
+}

src/main/java/mods/betterfoliage/client/WindTracker.java

@@ -0,0 +1,64 @@
+package mods.betterfoliage.client;
+
+import java.util.Random;
+
+import mods.betterfoliage.common.config.Config;
+import net.minecraft.client.Minecraft;
+import net.minecraft.world.World;
+import net.minecraftforge.event.world.WorldEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
+import cpw.mods.fml.common.gameevent.TickEvent.ClientTickEvent;
+
+public class WindTracker {
+
+	public Random random = new Random();
+	
+	public double targetX;
+	public double targetZ;
+
+	public double currentX;
+	public double currentZ;
+	
+	public long nextChange = 0;
+	
+	public void changeWind(World world) {
+		long changeTime = 120;
+		nextChange = world.getWorldInfo().getWorldTime() + changeTime;
+		
+		double direction = 2.0 * Math.PI * random.nextDouble();
+		double speed = Math.abs(random.nextGaussian()) * Config.leafFXWindStrength;
+		if (world.isRaining()) speed += Math.abs(random.nextGaussian()) * Config.leafFXStormStrength;
+		
+		targetX = Math.cos(direction) * speed;
+		targetZ = Math.sin(direction) * speed;
+	}
+	
+	@SubscribeEvent
+	public void handleWorldTick(ClientTickEvent event) {
+		if (event.phase != TickEvent.Phase.START) return;
+		World world = Minecraft.getMinecraft().theWorld;
+		if (world == null) return;
+		
+		// change target wind speed
+		if (world.getWorldInfo().getWorldTime() >= nextChange) changeWind(world);
+		
+		// change current wind speed
+		double changeRate = world.isRaining() ? 0.015 : 0.005;
+		
+		double deltaX = targetX - currentX;
+		if (deltaX < -changeRate) deltaX = -changeRate;
+		if (deltaX > changeRate) deltaX = changeRate;
+		double deltaZ = targetZ - currentZ;
+		if (deltaZ < -changeRate) deltaZ = -changeRate;
+		if (deltaZ > changeRate) deltaZ = changeRate;
+		
+		currentX += deltaX;
+		currentZ += deltaZ;
+	}
+	
+	@SubscribeEvent
+	public void handleWorldLoad(WorldEvent.Load event) {
+		if (event.world.isRemote) changeWind(event.world);
+	}
+}

src/main/java/mods/betterfoliage/client/gui/AlternateTextBooleanEntry.java

@@ -0,0 +1,91 @@
+package mods.betterfoliage.client.gui;
+
+import net.minecraft.client.resources.I18n;
+import cpw.mods.fml.client.config.GuiConfig;
+import cpw.mods.fml.client.config.GuiConfigEntries;
+import cpw.mods.fml.client.config.IConfigElement;
+
+
+public class AlternateTextBooleanEntry extends GuiConfigEntries.ButtonEntry {
+
+    protected final boolean beforeValue;
+    protected boolean       currentValue;
+    
+    public AlternateTextBooleanEntry(GuiConfig owningScreen, GuiConfigEntries owningEntryList, IConfigElement<Boolean> configElement)
+    {
+        super(owningScreen, owningEntryList, configElement);
+        this.beforeValue = Boolean.valueOf(configElement.get().toString());
+        this.currentValue = beforeValue;
+        this.btnValue.enabled = enabled();
+        updateValueButtonText();
+    }
+    
+    @Override
+    public void updateValueButtonText()
+    {
+        this.btnValue.displayString = I18n.format(configElement.getLanguageKey() + "." + String.valueOf(currentValue));
+    }
+
+    @Override
+    public void valueButtonPressed(int slotIndex)
+    {
+        if (enabled())
+            currentValue = !currentValue;
+    }
+
+    @Override
+    public boolean isDefault()
+    {
+        return currentValue == Boolean.valueOf(configElement.getDefault().toString());
+    }
+
+    @Override
+    public void setToDefault()
+    {
+        if (enabled())
+        {
+            currentValue = Boolean.valueOf(configElement.getDefault().toString());
+            updateValueButtonText();
+        }
+    }
+
+    @Override
+    public boolean isChanged()
+    {
+        return currentValue != beforeValue;
+    }
+
+    @Override
+    public void undoChanges()
+    {
+        if (enabled())
+        {
+            currentValue = beforeValue;
+            updateValueButtonText();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean saveConfigElement()
+    {
+        if (enabled() && isChanged())
+        {
+            configElement.set(currentValue);
+            return configElement.requiresMcRestart();
+        }
+        return false;
+    }
+
+    @Override
+    public Boolean getCurrentValue()
+    {
+        return currentValue;
+    }
+
+    @Override
+    public Boolean[] getCurrentValues()
+    {
+        return new Boolean[] { getCurrentValue() };
+    }
+}

src/main/java/mods/betterfoliage/client/gui/BiomeListConfigEntry.java

@@ -0,0 +1,68 @@
+package mods.betterfoliage.client.gui;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import net.minecraft.world.biome.BiomeGenBase;
+
+import com.google.common.base.Predicates;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+
+import cpw.mods.fml.client.config.GuiConfig;
+import cpw.mods.fml.client.config.GuiConfigEntries;
+import cpw.mods.fml.client.config.IConfigElement;
+
+
+public class BiomeListConfigEntry extends SelectListConfigEntry<BiomeGenBase> {
+
+    public static List<BiomeGenBase> reedBiomeList = Lists.newArrayList();
+    public static List<BiomeGenBase> algaeBiomeList = Lists.newArrayList();
+    public static List<BiomeGenBase> coralBiomeList = Lists.newArrayList();
+    
+    public BiomeListConfigEntry(GuiConfig owningScreen, GuiConfigEntries owningEntryList, IConfigElement<?> configElement) {
+        super(owningScreen, owningEntryList, configElement);
+    }
+
+    @Override
+    protected List<BiomeGenBase> getBaseSet(String qualifiedName) {
+        List<BiomeGenBase> biomes = Lists.newArrayList(Collections2.filter(Arrays.asList(BiomeGenBase.getBiomeGenArray()), Predicates.notNull()));
+        Collections.sort(biomes, new Comparator<BiomeGenBase>() {
+            @Override
+            public int compare(BiomeGenBase o1, BiomeGenBase o2) {
+                return o1.biomeName.compareTo(o2.biomeName);
+            }
+        });
+        return biomes;
+    }
+
+    @Override
+    protected List<BiomeGenBase> getDefaultSelected(String name) {
+        if (name.equals("reedBiomeList")) return reedBiomeList;
+        if (name.equals("algaeBiomeList")) return algaeBiomeList;
+        if (name.equals("coralBiomeList")) return coralBiomeList;
+        return ImmutableList.<BiomeGenBase>of();
+    }
+
+    @Override
+    protected int getItemId(BiomeGenBase item) {
+        return item.biomeID;
+    }
+
+    @Override
+    protected String getItemName(BiomeGenBase item) {
+        return item.biomeName;
+    }
+
+    @Override
+    protected String getTooltipLangKey(String name) {
+        if (name.equals("reedBiomeList")) return "betterfoliage.reeds.biomeSelectTooltip";
+        if (name.equals("algaeBiomeList")) return "betterfoliage.algae.biomeSelectTooltip";
+        if (name.equals("coralBiomeList")) return "betterfoliage.coral.biomeSelectTooltip";
+        return "";
+    }
+
+}

src/main/java/mods/betterfoliage/client/gui/ConfigGuiFactory.java

@@ -0,0 +1,41 @@
+package mods.betterfoliage.client.gui;
+
+import java.util.Set;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.common.config.Config;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+
+import com.google.common.collect.ImmutableSet;
+
+import cpw.mods.fml.client.IModGuiFactory;
+import cpw.mods.fml.client.config.GuiConfig;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class ConfigGuiFactory implements IModGuiFactory {
+
+	public void initialize(Minecraft minecraftInstance) {
+		
+	}
+
+	public Class<? extends GuiScreen> mainConfigGuiClass() {
+		return ConfigGuiBetterFoliage.class;
+	}
+
+	public Set<RuntimeOptionCategoryElement> runtimeGuiCategories() {
+		return ImmutableSet.<RuntimeOptionCategoryElement>of();
+	}
+
+	public RuntimeOptionGuiHandler getHandlerFor(RuntimeOptionCategoryElement element) {
+		return null;
+	}
+
+	public static class ConfigGuiBetterFoliage extends GuiConfig {
+		public ConfigGuiBetterFoliage(GuiScreen parentScreen) {
+			super(parentScreen, Config.getConfigRootElements(), BetterFoliage.MOD_ID, null, false, false, BetterFoliage.MOD_NAME);
+		}
+	}
+}

src/main/java/mods/betterfoliage/client/gui/NonVerboseArrayEntry.java

@@ -0,0 +1,27 @@
+package mods.betterfoliage.client.gui;
+
+import mods.betterfoliage.common.util.Utils;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.util.EnumChatFormatting;
+import cpw.mods.fml.client.config.GuiConfig;
+import cpw.mods.fml.client.config.GuiConfigEntries;
+import cpw.mods.fml.client.config.IConfigElement;
+
+
+public class NonVerboseArrayEntry extends GuiConfigEntries.ArrayEntry {
+
+    @SuppressWarnings("unchecked")
+    public NonVerboseArrayEntry(GuiConfig owningScreen, GuiConfigEntries owningEntryList, IConfigElement<?> configElement) {
+        super(owningScreen, owningEntryList, configElement);
+        
+        Utils.stripTooltipDefaultText(toolTip);
+        String shortDefaults = I18n.format("betterfoliage.arrayEntryDisplay", configElement.getDefaults().length);
+        toolTip.addAll(this.mc.fontRenderer.listFormattedStringToWidth(EnumChatFormatting.AQUA + I18n.format("fml.configgui.tooltip.default", shortDefaults),300));
+    }
+
+    @Override
+    public void updateValueButtonText() {
+        this.btnValue.displayString = I18n.format("betterfoliage.arrayEntryDisplay", currentValues.length);
+    }
+
+}

src/main/java/mods/betterfoliage/client/gui/SelectListConfigEntry.java

@@ -0,0 +1,114 @@
+package mods.betterfoliage.client.gui;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import mods.betterfoliage.common.util.Utils;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.util.EnumChatFormatting;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+
+import cpw.mods.fml.client.config.ConfigGuiType;
+import cpw.mods.fml.client.config.DummyConfigElement;
+import cpw.mods.fml.client.config.GuiConfig;
+import cpw.mods.fml.client.config.GuiConfigEntries;
+import cpw.mods.fml.client.config.GuiConfigEntries.CategoryEntry;
+import cpw.mods.fml.client.config.IConfigElement;
+
+
+public abstract class SelectListConfigEntry<T> extends CategoryEntry {
+
+    List<ItemWrapperElement> children;
+    List<Integer> notFoundIdList;
+    
+    @SuppressWarnings("unchecked")
+    public SelectListConfigEntry(GuiConfig owningScreen, GuiConfigEntries owningEntryList, IConfigElement<?> configElement) {
+        super(owningScreen, owningEntryList, configElement);
+        Utils.stripTooltipDefaultText(toolTip);
+    }
+
+    @Override
+    protected GuiScreen buildChildScreen()
+    {
+        return new GuiConfig(this.owningScreen, createChildElements(), this.owningScreen.modID, 
+                owningScreen.allRequireWorldRestart || this.configElement.requiresWorldRestart(), 
+                owningScreen.allRequireMcRestart || this.configElement.requiresMcRestart(), this.owningScreen.title, 
+                ((this.owningScreen.titleLine2 == null ? "" : this.owningScreen.titleLine2) + " > " + this.name));
+    }
+    
+    protected abstract List<T> getBaseSet(String qualifiedName);
+    protected abstract List<T> getDefaultSelected(String qualifiedName);
+    protected abstract int getItemId(T item);
+    protected abstract String getItemName(T item);
+    protected abstract String getTooltipLangKey(String qualifiedName);
+    
+    @SuppressWarnings("rawtypes")
+    protected List<IConfigElement> createChildElements() {
+        children = Lists.newArrayList();
+        
+        List<Integer> idList = Lists.newArrayList();
+        for (Object id : configElement.getList()) idList.add((Integer) id);
+        
+        List<T> defaults = getDefaultSelected(configElement.getName());
+        for(T item : getBaseSet(configElement.getQualifiedName())) {
+            children.add(new ItemWrapperElement(item, defaults.contains(item), idList.contains(getItemId(item))));
+            idList.remove(new Integer(getItemId(item)));
+        }
+        
+        notFoundIdList = idList;
+        List<IConfigElement> result = Lists.newArrayList();
+        result.addAll(children);
+        return result;
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean saveConfigElement() {
+        boolean requiresRestart = ((GuiConfig) childScreen).entryList.saveConfigElements();
+        
+        Set<Integer> idSet = Sets.newHashSet();
+        for (ItemWrapperElement child : children)
+            if (Boolean.TRUE.equals(child.getCurrentValue()))
+                idSet.add(getItemId(child.item));
+        
+        idSet.addAll(notFoundIdList);
+        List<Integer> result = Lists.newArrayList(idSet);
+        Collections.sort(result);
+        configElement.set(result.toArray());
+        
+        return requiresRestart;
+    }
+
+    public class ItemWrapperElement extends DummyConfigElement<Boolean> implements IConfigElement<Boolean> {
+
+        public T item;
+        
+        public ItemWrapperElement(T item, boolean defaultValue, boolean currentValue) {
+            super(getItemName(item), defaultValue, ConfigGuiType.BOOLEAN, getItemName(item));
+            set(currentValue);
+            this.item = item;
+        }
+
+        @Override
+        public String getComment() {
+            return I18n.format(getTooltipLangKey(configElement.getQualifiedName()), EnumChatFormatting.GOLD + getItemName(item) + EnumChatFormatting.YELLOW);
+        }
+        
+        public Boolean getCurrentValue() {
+            return (Boolean) value;
+        }
+
+        @Override
+        public void set(Boolean value) {
+            this.value = value;
+        }
+        
+        public void setDefault(Boolean value) {
+            this.defaultValue = value;
+        }
+    }
+}

src/main/java/mods/betterfoliage/client/render/FakeRenderBlockAOBase.java

@@ -0,0 +1,62 @@
+package mods.betterfoliage.client.render;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.util.IIcon;
+
+/** Same as {@link RenderBlockAOBase}, but does not actually render anything.
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public class FakeRenderBlockAOBase extends RenderBlockAOBase {
+
+	@Override
+	public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon) {
+		saveShadingTopLeft(aoZNXYPP);
+		saveShadingTopRight(aoZNXYNP);
+		saveShadingBottomLeft(aoZNXYPN);
+		saveShadingBottomRight(aoZNXYNN);
+	}
+
+	@Override
+	public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon) {
+		saveShadingTopLeft(aoZPXYNP);
+		saveShadingTopRight(aoZPXYPP);
+		saveShadingBottomLeft(aoZPXYNN);
+		saveShadingBottomRight(aoZPXYPN);
+	}
+
+	@Override
+	public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon) {
+		saveShadingTopLeft(aoXNYZPN);
+		saveShadingTopRight(aoXNYZPP);
+		saveShadingBottomLeft(aoXNYZNN);
+		saveShadingBottomRight(aoXNYZNP);
+	}
+
+	@Override
+	public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon) {
+		saveShadingTopLeft(aoXPYZPP);
+		saveShadingTopRight(aoXPYZPN);
+		saveShadingBottomLeft(aoXPYZNP);
+		saveShadingBottomRight(aoXPYZNN);
+	}
+
+	@Override
+	public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon) {
+		saveShadingTopLeft(aoYNXZNP);
+		saveShadingTopRight(aoYNXZPP);
+		saveShadingBottomLeft(aoYNXZNN);
+		saveShadingBottomRight(aoYNXZPN);
+	}
+
+	@Override
+	public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon) {
+		saveShadingTopLeft(aoYPXZPP);
+		saveShadingTopRight(aoYPXZNP);
+		saveShadingBottomLeft(aoYPXZPN);
+		saveShadingBottomRight(aoYPXZNN);
+	}
+	
+}

src/main/java/mods/betterfoliage/client/render/IRenderBlockDecorator.java

@@ -0,0 +1,30 @@
+package mods.betterfoliage.client.render;
+
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.world.IBlockAccess;
+
+/** Block rendering handler that is only used under certain conditions
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public interface IRenderBlockDecorator extends ISimpleBlockRenderingHandler {
+
+	/** Initialize necessary helper values
+	 */
+	public void init();
+	
+	/**
+	 * @param blockAccess the world
+	 * @param x
+	 * @param y
+	 * @param z
+	 * @param block
+	 * @param original renderType of the block
+	 * @return true if this renderer should handle this block
+	 */
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original);
+	
+}

src/main/java/mods/betterfoliage/client/render/IconSet.java

@@ -0,0 +1,52 @@
+package mods.betterfoliage.client.render;
+
+import mods.betterfoliage.common.util.Utils;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.ResourceLocation;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/** Holds an indexed set of textures
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public class IconSet {
+
+	/** Icon array */
+	public IIcon[] icons = new IIcon[16];
+	
+	/** Number of successfully loaded icons */
+	public int numLoaded = 0;
+	
+	/** Resource domain of icons */
+	String domain;
+	
+	/** Format string of icon paths */
+	String path;
+	
+	public IconSet(String domain, String path) {
+		this.domain = domain;
+		this.path = path;
+	}
+	
+	public void registerIcons(IIconRegister register) {
+		numLoaded = 0;
+		for (int idx = 0; idx < 16; idx++) {
+			icons[idx] = null;
+			// if the path contains a domain, use that to check if the resource exists
+			String resolvedDomain = path.contains(":") ? new ResourceLocation(path).getResourceDomain() : domain;
+			String resolvedPath = String.format("textures/blocks/" + (path.contains(":") ? new ResourceLocation(path).getResourcePath() : path) + ".png", idx);
+			if (Utils.resourceExists(new ResourceLocation(resolvedDomain, resolvedPath)))
+				icons[numLoaded++] = register.registerIcon(domain + ":" + String.format(path, idx));
+		}
+	}
+	
+	public IIcon get(int variation) {
+		return numLoaded == 0 ? null : icons[variation % numLoaded];
+	}
+	
+	public boolean hasIcons() {
+		return numLoaded > 0;
+	}
+}

src/main/java/mods/betterfoliage/client/render/RenderBlockAOBase.java

@@ -0,0 +1,462 @@
+package mods.betterfoliage.client.render;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import mods.betterfoliage.common.util.Double3;
+import mods.betterfoliage.common.util.Utils;
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.lwjgl.opengl.GL11;
+
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/** Block renderer base class. Stores calculated ambient occlusion light and color values when rendering
+ *  block sides for later use.
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public class RenderBlockAOBase extends RenderBlocks {
+
+	/** AO light and color values
+	 * @author octarine-noise
+	 */
+	@SideOnly(Side.CLIENT)
+	public static class ShadingValues {
+		public int passCounter = 0;
+		public int brightness;
+		public float red;
+		public float green;
+		public float blue;
+		public void setGray(float value) {
+			red = value; green = value; blue = value;
+		}
+	}
+	
+	protected double[] uValues = new double[] {0.0, 16.0, 16.0, 0.0};
+	protected double[] vValues = new double[] {0.0, 0.0, 16.0, 16.0};
+	
+	protected ForgeDirection[] faceDir1 = new ForgeDirection[] {ForgeDirection.WEST, ForgeDirection.WEST, ForgeDirection.WEST, ForgeDirection.EAST, ForgeDirection.SOUTH, ForgeDirection.NORTH};
+	protected ForgeDirection[] faceDir2 = new ForgeDirection[] {ForgeDirection.NORTH, ForgeDirection.SOUTH, ForgeDirection.UP, ForgeDirection.UP, ForgeDirection.UP, ForgeDirection.UP};
+	
+	/** Random vector pool. Unit rotation vectors in the XZ plane, Y coord goes between [-1.0, 1.0].
+	 * Filled at init time */
+	public Double3[] pRot = new Double3[64];
+	
+	/** Pool of random double values. Filled at init time. */
+	public double[] pRand = new double[64];
+	
+	public ShadingValues aoXPYZPP = new ShadingValues();
+	public ShadingValues aoXPYZPN = new ShadingValues();
+	public ShadingValues aoXPYZNP = new ShadingValues();
+	public ShadingValues aoXPYZNN = new ShadingValues();
+	public ShadingValues aoXNYZPP = new ShadingValues();
+	public ShadingValues aoXNYZPN = new ShadingValues();
+	public ShadingValues aoXNYZNP = new ShadingValues();
+	public ShadingValues aoXNYZNN = new ShadingValues();
+	public ShadingValues aoYPXZPP = new ShadingValues();
+	public ShadingValues aoYPXZPN = new ShadingValues();
+	public ShadingValues aoYPXZNP = new ShadingValues();
+	public ShadingValues aoYPXZNN = new ShadingValues();
+	public ShadingValues aoYNXZPP = new ShadingValues();
+	public ShadingValues aoYNXZPN = new ShadingValues();
+	public ShadingValues aoYNXZNP = new ShadingValues();
+	public ShadingValues aoYNXZNN = new ShadingValues();
+	public ShadingValues aoZPXYPP = new ShadingValues();
+	public ShadingValues aoZPXYPN = new ShadingValues();
+	public ShadingValues aoZPXYNP = new ShadingValues();
+	public ShadingValues aoZPXYNN = new ShadingValues();
+	public ShadingValues aoZNXYPP = new ShadingValues();
+	public ShadingValues aoZNXYPN = new ShadingValues();
+	public ShadingValues aoZNXYNP = new ShadingValues();
+	public ShadingValues aoZNXYNN = new ShadingValues();
+
+	// temporary shading values for a single face
+	public ShadingValues faceAOPP, faceAOPN, faceAONN, faceAONP;
+	
+	/** Initialize random values */
+	public void init() {
+		List<Double3> perturbs = new ArrayList<Double3>(64);
+		for (int idx = 0; idx < 64; idx++) {
+			double angle = (double) idx * Math.PI * 2.0 / 64.0;
+			perturbs.add(new Double3(Math.cos(angle), Math.random() * 2.0 - 1.0, Math.sin(angle)));
+			pRand[idx] = Math.random();
+		}
+		Collections.shuffle(perturbs);
+		Iterator<Double3> iter = perturbs.iterator();
+		for (int idx = 0; idx < 64; idx++) pRot[idx] = iter.next();
+	}
+			
+	/** Get a semi-random value depending on block position.
+	 * @param x block X coord
+	 * @param y block Y coord
+	 * @param z block Z coord
+	 * @param seed additional seed
+	 * @return semirandom value
+	 */
+	protected int getSemiRandomFromPos(double x, double y, double z, int seed) {
+		long lx = MathHelper.floor_double(x);
+		long ly = MathHelper.floor_double(y);
+		long lz = MathHelper.floor_double(z);
+		long value = (lx * lx + ly * ly + lz * lz + lx * ly + ly * lz + lz * lx + seed * seed) & 63;
+		value = (3 * lx * value + 5 * ly * value + 7 * lz * value + 11 * seed) & 63;
+		return (int) value;
+	}
+	
+	public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) {
+		renderStandardBlockAsItem(renderer, block, metadata, 1.0f);
+	}
+	
+	public boolean shouldRender3DInInventory(int modelId) {
+		return true;
+	}
+	
+	public int getRenderId() {
+		return 0;
+	}
+	
+	protected void renderWorldBlockBase(int pass, IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		// use original renderer for block breaking overlay
+		if (renderer.hasOverrideBlockTexture()) {
+			renderer.setRenderBoundsFromBlock(block);
+			renderer.renderStandardBlock(block, x, y, z);
+			return;
+		}
+		
+		// render block
+		setPassCounters(1);
+		setRenderBoundsFromBlock(block);
+		ISimpleBlockRenderingHandler handler = Utils.getRenderingHandler(block.getRenderType());
+		if (handler != null) {
+			handler.renderWorldBlock(world, x, y, z, block, block.getRenderType(), this);
+		} else {
+			renderStandardBlock(block, x, y, z);			
+		}
+	}
+	
+	protected void renderStandardBlockAsItem(RenderBlocks renderer, Block p_147800_1_, int p_147800_2_, float p_147800_3_) {
+		Tessellator tessellator = Tessellator.instance;
+		boolean flag = p_147800_1_ == Blocks.grass;
+		
+        float f2;
+        float f3;
+        int k;
+        
+		p_147800_1_.setBlockBoundsForItemRender();
+		renderer.setRenderBoundsFromBlock(p_147800_1_);
+        GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
+        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
+        tessellator.startDrawingQuads();
+        tessellator.setNormal(0.0F, -1.0F, 0.0F);
+        renderer.renderFaceYNeg(p_147800_1_, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(p_147800_1_, 0, p_147800_2_));
+        tessellator.draw();
+
+        if (flag && renderer.useInventoryTint)
+        {
+            k = p_147800_1_.getRenderColor(p_147800_2_);
+            f2 = (float)(k >> 16 & 255) / 255.0F;
+            f3 = (float)(k >> 8 & 255) / 255.0F;
+            float f4 = (float)(k & 255) / 255.0F;
+            GL11.glColor4f(f2 * p_147800_3_, f3 * p_147800_3_, f4 * p_147800_3_, 1.0F);
+        }
+
+        tessellator.startDrawingQuads();
+        tessellator.setNormal(0.0F, 1.0F, 0.0F);
+        renderer.renderFaceYPos(p_147800_1_, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(p_147800_1_, 1, p_147800_2_));
+        tessellator.draw();
+
+        if (flag && renderer.useInventoryTint)
+        {
+            GL11.glColor4f(p_147800_3_, p_147800_3_, p_147800_3_, 1.0F);
+        }
+
+        tessellator.startDrawingQuads();
+        tessellator.setNormal(0.0F, 0.0F, -1.0F);
+        renderer.renderFaceZNeg(p_147800_1_, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(p_147800_1_, 2, p_147800_2_));
+        tessellator.draw();
+        tessellator.startDrawingQuads();
+        tessellator.setNormal(0.0F, 0.0F, 1.0F);
+        renderer.renderFaceZPos(p_147800_1_, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(p_147800_1_, 3, p_147800_2_));
+        tessellator.draw();
+        tessellator.startDrawingQuads();
+        tessellator.setNormal(-1.0F, 0.0F, 0.0F);
+        renderer.renderFaceXNeg(p_147800_1_, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(p_147800_1_, 4, p_147800_2_));
+        tessellator.draw();
+        tessellator.startDrawingQuads();
+        tessellator.setNormal(1.0F, 0.0F, 0.0F);
+        renderer.renderFaceXPos(p_147800_1_, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(p_147800_1_, 5, p_147800_2_));
+        tessellator.draw();
+        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+	}
+	
+	protected void setShadingForFace(ForgeDirection dir) {
+		if (dir == ForgeDirection.DOWN) {
+			// dir1 WEST, dir2 NORTH
+			faceAOPP = aoYNXZPP; faceAOPN = aoYNXZPN; faceAONN = aoYNXZNN; faceAONP = aoYNXZNP;
+		} else if (dir == ForgeDirection.UP) {
+			// dir1 WEST, dir2 SOUTH
+			faceAOPP = aoYPXZPP; faceAOPN = aoYPXZPN; faceAONN = aoYPXZNN; faceAONP = aoYPXZNP;
+		} else if (dir == ForgeDirection.NORTH) {
+			// dir1 WEST, dir2 UP
+			faceAOPP = aoZNXYNP; faceAOPN = aoZNXYNN; faceAONN = aoZNXYPN; faceAONP = aoZNXYPP;
+		} else if (dir == ForgeDirection.SOUTH) {
+			// dir1 EAST, dir2 UP
+			faceAOPP = aoZPXYPP; faceAOPN = aoZPXYPN; faceAONN = aoZPXYNN; faceAONP = aoZPXYNP;
+		} else if (dir == ForgeDirection.WEST) {
+			// dir1 SOUTH, dir2 UP
+			faceAOPP = aoXNYZPP; faceAOPN = aoXNYZNP; faceAONN = aoXNYZNN; faceAONP = aoXNYZPN;
+		} else if (dir == ForgeDirection.EAST) {
+			// dir1 NORTH, dir2 UP
+			faceAOPP = aoXPYZPN; faceAOPN = aoXPYZNN; faceAONN = aoXPYZNP; faceAONP = aoXPYZPP;
+		}
+	}
+	
+	public void renderCrossedSideQuads(Double3 drawBase, ForgeDirection dir, double scale, double halfHeight, Double3 rendomVec, double offset, IIcon renderIcon, int uvRot, boolean noShading) {
+		Double3 facePP, faceNP, faceNormal, drawCenter;
+		
+		if (dir == ForgeDirection.UP) {
+			// special case for block top, we'll be rendering a LOT of those
+			facePP = new Double3(-scale, 0.0, scale);
+			faceNP = new Double3(scale, 0.0, scale);
+			faceNormal = new Double3(0.0, halfHeight, 0.0);
+			drawCenter = drawBase.add(faceNormal);
+			if (rendomVec != null) {
+				drawCenter = drawBase.add(faceNormal).add(rendomVec.scaleAxes(-offset, 0.0, offset));
+			}
+		} else {
+			facePP = new Double3(faceDir1[dir.ordinal()]).add(new Double3(faceDir2[dir.ordinal()])).scale(scale);
+			faceNP = new Double3(faceDir1[dir.ordinal()]).inverse().add(new Double3(faceDir2[dir.ordinal()])).scale(scale);
+			faceNormal = new Double3(dir).scale(halfHeight);
+			drawCenter = drawBase.add(faceNormal);
+			if (rendomVec != null) {
+				drawCenter = drawCenter.add(new Double3(faceDir1[dir.ordinal()]).scale(rendomVec.x).scale(offset))
+									   .add(new Double3(faceDir2[dir.ordinal()]).scale(rendomVec.z).scale(offset));
+			}
+		}
+		
+		if (Minecraft.isAmbientOcclusionEnabled() && !noShading) {
+			setShadingForFace(dir);
+			renderQuadWithShading(renderIcon, drawCenter, facePP, faceNormal, uvRot,			faceAOPP, faceAONN, faceAONN, faceAOPP);
+			renderQuadWithShading(renderIcon, drawCenter, facePP.inverse(), faceNormal, uvRot,	faceAONN, faceAOPP, faceAOPP, faceAONN);
+			renderQuadWithShading(renderIcon, drawCenter, faceNP, faceNormal, uvRot, 			faceAONP, faceAOPN, faceAOPN, faceAONP);
+			renderQuadWithShading(renderIcon, drawCenter, faceNP.inverse(), faceNormal, uvRot,	faceAOPN, faceAONP, faceAONP, faceAOPN);
+		} else {
+			renderQuad(renderIcon, drawCenter, facePP, faceNormal, uvRot);
+			renderQuad(renderIcon, drawCenter, facePP.inverse(), faceNormal, uvRot);
+			renderQuad(renderIcon, drawCenter, faceNP, faceNormal, uvRot);
+			renderQuad(renderIcon, drawCenter, faceNP.inverse(), faceNormal, uvRot);
+		}
+	}
+	
+	protected void renderCrossedBlockQuadsTranslate(Double3 blockCenter, double halfSize, Double3 offsetVec, IIcon crossLeafIcon, int uvRot, boolean isAirTop, boolean isAirBottom) {
+		Double3 drawCenter = blockCenter;
+		if (offsetVec != null) drawCenter = drawCenter.add(offsetVec);
+		Double3 horz1 = new Double3(halfSize, 0.0, halfSize);
+		Double3 horz2 = new Double3(halfSize, 0.0, -halfSize);
+		Double3 vert1 = new Double3(0.0, halfSize * 1.41, 0.0);
+		
+		renderCrossedBlockQuadsInternal(drawCenter, horz1, horz2, vert1, crossLeafIcon, uvRot, isAirTop, isAirBottom);
+	}
+	
+	protected void renderCrossedBlockQuadsSkew(Double3 blockCenter, double halfSize, Double3 offsetVec1, Double3 offsetVec2, IIcon crossLeafIcon, int uvRot, boolean isAirTop, boolean isAirBottom) {
+		Double3 horz1 = new Double3(halfSize, 0.0, halfSize).add(offsetVec1);
+		Double3 horz2 = new Double3(halfSize, 0.0, -halfSize).add(offsetVec2);
+		Double3 vert1 = new Double3(0.0, halfSize * 1.41, 0.0);
+		
+		renderCrossedBlockQuadsInternal(blockCenter, horz1, horz2, vert1, crossLeafIcon, uvRot, isAirTop, isAirBottom);
+	}
+	
+	private void renderCrossedBlockQuadsInternal(Double3 drawCenter, Double3 horz1, Double3 horz2, Double3 vert1, IIcon crossLeafIcon, int uvRot, boolean isAirTop, boolean isAirBottom) {
+		if (Minecraft.isAmbientOcclusionEnabled()) {
+			renderQuadWithShading(crossLeafIcon, drawCenter, horz1, vert1, uvRot,
+					isAirTop ? aoYPXZPP : aoZPXYPP, isAirTop ? aoYPXZNN : aoXNYZPN, isAirBottom ? aoYNXZNN : aoXNYZNN, isAirBottom ? aoYNXZPP : aoZPXYPN);
+			renderQuadWithShading(crossLeafIcon, drawCenter, horz1.inverse(), vert1, uvRot,
+					isAirTop ? aoYPXZNN : aoZNXYNP, isAirTop ? aoYPXZPP : aoXPYZPP, isAirBottom ? aoYNXZPP : aoXPYZNP, isAirBottom ? aoYNXZNN : aoZNXYNN);
+			renderQuadWithShading(crossLeafIcon, drawCenter, horz2, vert1, uvRot,
+					isAirTop ? aoYPXZPN : aoXPYZPN, isAirTop ? aoYPXZNP : aoZPXYNP, isAirBottom ? aoYNXZNP : aoZPXYNN, isAirBottom ? aoYNXZPN : aoXPYZNN);
+			renderQuadWithShading(crossLeafIcon, drawCenter, horz2.inverse(), vert1, uvRot,
+					isAirTop ? aoYPXZNP : aoXNYZPP, isAirTop ? aoYPXZPN : aoZNXYPP, isAirBottom ? aoYNXZPN : aoZNXYPN, isAirBottom ? aoYNXZNP : aoXNYZNP);
+		} else {
+			renderQuad(crossLeafIcon, drawCenter, horz1, vert1, uvRot);
+			renderQuad(crossLeafIcon, drawCenter, horz1.inverse(), vert1, uvRot);
+			renderQuad(crossLeafIcon, drawCenter, horz2, vert1, uvRot);
+			renderQuad(crossLeafIcon, drawCenter, horz2.inverse(), vert1, uvRot);
+		}
+	}
+	
+	@Override
+	public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceZNeg(block, x, y, z, icon);
+		saveShadingTopLeft(aoZNXYPP);
+		saveShadingTopRight(aoZNXYNP);
+		saveShadingBottomLeft(aoZNXYPN);
+		saveShadingBottomRight(aoZNXYNN);
+	}
+
+	@Override
+	public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceZPos(block, x, y, z, icon);
+		saveShadingTopLeft(aoZPXYNP);
+		saveShadingTopRight(aoZPXYPP);
+		saveShadingBottomLeft(aoZPXYNN);
+		saveShadingBottomRight(aoZPXYPN);
+	}
+
+	@Override
+	public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceXNeg(block, x, y, z, icon);
+		saveShadingTopLeft(aoXNYZPN);
+		saveShadingTopRight(aoXNYZPP);
+		saveShadingBottomLeft(aoXNYZNN);
+		saveShadingBottomRight(aoXNYZNP);
+	}
+
+	@Override
+	public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceXPos(block, x, y, z, icon);
+		saveShadingTopLeft(aoXPYZPP);
+		saveShadingTopRight(aoXPYZPN);
+		saveShadingBottomLeft(aoXPYZNP);
+		saveShadingBottomRight(aoXPYZNN);
+	}
+
+	@Override
+	public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceYNeg(block, x, y, z, icon);
+		saveShadingTopLeft(aoYNXZNP);
+		saveShadingTopRight(aoYNXZPP);
+		saveShadingBottomLeft(aoYNXZNN);
+		saveShadingBottomRight(aoYNXZPN);
+	}
+
+	@Override
+	public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceYPos(block, x, y, z, icon);
+		saveShadingTopLeft(aoYPXZPP);
+		saveShadingTopRight(aoYPXZNP);
+		saveShadingBottomLeft(aoYPXZPN);
+		saveShadingBottomRight(aoYPXZNN);
+	}
+	
+	protected void saveShadingTopLeft(ShadingValues values) {
+		if (--values.passCounter != 0) return;
+		values.brightness = brightnessTopLeft;
+		values.red = colorRedTopLeft;
+		values.green = colorGreenTopLeft;
+		values.blue = colorBlueTopLeft;
+	}
+	
+	protected void saveShadingTopRight(ShadingValues values) {
+		if (--values.passCounter != 0) return;
+		values.brightness = brightnessTopRight;
+		values.red = colorRedTopRight;
+		values.green = colorGreenTopRight;
+		values.blue = colorBlueTopRight;
+	}
+	
+	protected void saveShadingBottomLeft(ShadingValues values) {
+		if (--values.passCounter != 0) return;
+		values.brightness = brightnessBottomLeft;
+		values.red = colorRedBottomLeft;
+		values.green = colorGreenBottomLeft;
+		values.blue = colorBlueBottomLeft;
+	}
+	
+	protected void saveShadingBottomRight(ShadingValues values) {
+		if (--values.passCounter != 0) return;
+		values.brightness = brightnessBottomRight;
+		values.red = colorRedBottomRight;
+		values.green = colorGreenBottomRight;
+		values.blue = colorBlueBottomRight;
+	}
+	
+	/** Set pass counter on all shading value objects.
+	 *  Used to collect AO values from a specific draw pass
+	 *  if the underlying renderer draws overlays 
+	 * @param value pass counter
+	 */
+	protected void setPassCounters(int value) {
+		aoXPYZPP.passCounter = value;
+		aoXPYZPN.passCounter = value;
+		aoXPYZNP.passCounter = value;
+		aoXPYZNN.passCounter = value;
+		aoXNYZPP.passCounter = value;
+		aoXNYZPN.passCounter = value;
+		aoXNYZNP.passCounter = value;
+		aoXNYZNN.passCounter = value;
+		aoYPXZPP.passCounter = value;
+		aoYPXZPN.passCounter = value;
+		aoYPXZNP.passCounter = value;
+		aoYPXZNN.passCounter = value;
+		aoYNXZPP.passCounter = value;
+		aoYNXZPN.passCounter = value;
+		aoYNXZNP.passCounter = value;
+		aoYNXZNN.passCounter = value;
+		aoZPXYPP.passCounter = value;
+		aoZPXYPN.passCounter = value;
+		aoZPXYNP.passCounter = value;
+		aoZPXYNN.passCounter = value;
+		aoZNXYPP.passCounter = value;
+		aoZNXYPN.passCounter = value;
+		aoZNXYNP.passCounter = value;
+		aoZNXYNN.passCounter = value;
+	}
+	
+	/** Render textured quad
+	 * @param icon texture to use
+	 * @param center center of quad
+	 * @param vec1 vector to the half-point of one of the sides
+	 * @param vec2 vector to half-point of side next to vec1
+	 * @param uvRot number of increments to rotate UV coordinates by
+	 */
+	protected void renderQuad(IIcon icon, Double3 center, Double3 vec1, Double3 vec2, int uvRot) {
+		Tessellator tessellator = Tessellator.instance;
+		tessellator.addVertexWithUV(center.x + vec1.x + vec2.x, center.y + vec1.y + vec2.y, center.z + vec1.z + vec2.z, icon.getInterpolatedU(uValues[uvRot & 3]), icon.getInterpolatedV(vValues[uvRot & 3]));
+		tessellator.addVertexWithUV(center.x - vec1.x + vec2.x, center.y - vec1.y + vec2.y, center.z - vec1.z + vec2.z, icon.getInterpolatedU(uValues[(uvRot + 1) & 3]), icon.getInterpolatedV(vValues[(uvRot + 1) & 3]));
+		tessellator.addVertexWithUV(center.x - vec1.x - vec2.x, center.y - vec1.y - vec2.y, center.z - vec1.z - vec2.z, icon.getInterpolatedU(uValues[(uvRot + 2) & 3]), icon.getInterpolatedV(vValues[(uvRot + 2) & 3]));
+		tessellator.addVertexWithUV(center.x + vec1.x - vec2.x, center.y + vec1.y - vec2.y, center.z + vec1.z - vec2.z, icon.getInterpolatedU(uValues[(uvRot + 3) & 3]), icon.getInterpolatedV(vValues[(uvRot + 3) & 3]));
+	}
+	
+	/** Render textured quad using AO information
+	 * @param icon texture to use
+	 * @param center center of quad
+	 * @param vec1 vector to the half-point of one of the sides
+	 * @param vec2 vector to half-point of side next to vec1
+	 * @param uvRot number of increments to rotate UV coordinates by
+	 * @param aoPP AO values for vertex at (+vec1, +vec2)
+	 * @param aoNP AO values for vertex at (-vec1, +vec2)
+	 * @param aoNN AO values for vertex at (-vec1, -vec2)
+	 * @param aoPN AO values for vertex at (+vec1, -vec2) 
+	 */
+	protected void renderQuadWithShading(IIcon icon, Double3 center, Double3 vec1, Double3 vec2, int uvRot, ShadingValues aoPP, ShadingValues aoNP, ShadingValues aoNN, ShadingValues aoPN) {
+		Tessellator tessellator = Tessellator.instance;
+		tessellator.setBrightness(aoPP.brightness);
+		tessellator.setColorOpaque_F(aoPP.red, aoPP.green, aoPP.blue);
+		tessellator.addVertexWithUV(center.x + vec1.x + vec2.x, center.y + vec1.y + vec2.y, center.z + vec1.z + vec2.z, icon.getInterpolatedU(uValues[uvRot & 3]), icon.getInterpolatedV(vValues[uvRot & 3]));
+		tessellator.setBrightness(aoNP.brightness);
+		tessellator.setColorOpaque_F(aoNP.red, aoNP.green, aoNP.blue);
+		tessellator.addVertexWithUV(center.x - vec1.x + vec2.x, center.y - vec1.y + vec2.y, center.z - vec1.z + vec2.z, icon.getInterpolatedU(uValues[(uvRot + 1) & 3]), icon.getInterpolatedV(vValues[(uvRot + 1) & 3]));
+		tessellator.setBrightness(aoNN.brightness);
+		tessellator.setColorOpaque_F(aoNN.red, aoNN.green, aoNN.blue);
+		tessellator.addVertexWithUV(center.x - vec1.x - vec2.x, center.y - vec1.y - vec2.y, center.z - vec1.z - vec2.z, icon.getInterpolatedU(uValues[(uvRot + 2) & 3]), icon.getInterpolatedV(vValues[(uvRot + 2) & 3]));
+		tessellator.setBrightness(aoPN.brightness);
+		tessellator.setColorOpaque_F(aoPN.red, aoPN.green, aoPN.blue);
+		tessellator.addVertexWithUV(center.x + vec1.x - vec2.x, center.y + vec1.y - vec2.y, center.z + vec1.z - vec2.z, icon.getInterpolatedU(uValues[(uvRot + 3) & 3]), icon.getInterpolatedV(vValues[(uvRot + 3) & 3]));
+	}
+	
+	protected int getBrightness(Block block, int x, int y, int z) {
+		return block.getMixedBrightnessForBlock(blockAccess, x, y, z);
+	}
+}

src/main/java/mods/betterfoliage/client/render/impl/EntityFXFallingLeaves.java

@@ -0,0 +1,132 @@
+package mods.betterfoliage.client.render.impl;
+
+import java.awt.Color;
+
+import mods.betterfoliage.client.BetterFoliageClient;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Double3;
+import net.minecraft.block.Block;
+import net.minecraft.client.particle.EntityFX;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class EntityFXFallingLeaves extends EntityFX {
+
+	protected static double[] cos = new double[64];
+	protected static double[] sin = new double[64];
+	
+	static {
+		for (int idx = 0; idx < 64; idx++) {
+			cos[idx] = Math.cos(2.0 * Math.PI / 64.0 * idx);
+			sin[idx] = Math.sin(2.0 * Math.PI / 64.0 * idx);
+		}
+	}
+	
+	public static float biomeBrightnessMultiplier = 0.5f;
+	public boolean wasOnGround = false;
+	public boolean isMirrored;
+	public int particleRotation = 0;
+	public boolean rotationPositive = true;
+	
+	public EntityFXFallingLeaves(World world, int x, int y, int z) {
+		super(world, x + 0.5, y, z + 0.5);
+		particleMaxAge = MathHelper.floor_double((0.6 + 0.4 * rand.nextDouble()) * Config.leafFXLifetime * 20.0);
+		isMirrored = (rand.nextInt() & 1) == 1;
+		motionY = -Config.leafFXSpeed;
+		particleRotation = rand.nextInt(64);
+		
+		particleScale = (float) Config.leafFXSize;
+		particleIcon = BetterFoliageClient.leafParticles.icons.get(rand.nextInt(1024));
+		
+		Block block = world.getBlock(x, y, z);
+		IIcon blockIcon = block.getIcon(world, x, y, z, ForgeDirection.DOWN.ordinal());
+		calculateParticleColor(BetterFoliageClient.leafParticles.getColor(blockIcon), block.colorMultiplier(world, x, y, z));
+	}
+
+	@Override
+	public void onUpdate() {
+		super.onUpdate();
+		
+		particleScale = (float) Config.leafFXSize;
+		if (rand.nextFloat() > 0.95f) rotationPositive = !rotationPositive;
+		if (particleAge > particleMaxAge - 20) particleAlpha = 0.05f * (particleMaxAge - particleAge);
+		
+		if (onGround || wasOnGround) {
+			motionX = 0.0;
+			motionZ = 0.0;
+			motionZ = 0.0;
+			if (!wasOnGround) {
+				particleAge = Math.max(particleAge, particleMaxAge - 20);
+			}
+			wasOnGround = true;
+		} else {
+			motionX = (BetterFoliageClient.wind.currentX + cos[particleRotation] * Config.leafFXPerturb) * Config.leafFXSpeed;
+			motionZ = (BetterFoliageClient.wind.currentZ + sin[particleRotation] * Config.leafFXPerturb) * Config.leafFXSpeed;
+			motionY = -Config.leafFXSpeed;
+			particleRotation = (particleRotation + (rotationPositive ? 1 : -1)) & 63;
+		}
+	}
+
+	@Override
+    public void renderParticle(Tessellator tessellator, float partialTickTime, float rotX, float rotZ, float rotYZ, float rotXY, float rotXZ)
+    {
+        float minU = isMirrored ? particleIcon.getMinU() : particleIcon.getMaxU();
+        float maxU = isMirrored ? particleIcon.getMaxU() : particleIcon.getMinU();
+        float minV = particleIcon.getMinV();
+        float maxV = particleIcon.getMaxV();
+        float scale = 0.1F * this.particleScale;
+        
+        Double3 center = new Double3(prevPosX + (posX - prevPosX) * partialTickTime - interpPosX, 
+        							 prevPosY + (posY - prevPosY) * partialTickTime - interpPosY,
+        							 prevPosZ + (posZ - prevPosZ) * partialTickTime - interpPosZ);
+        Double3 vec1 = new Double3(rotX + rotXY, rotZ, rotYZ + rotXZ).scale(scale);
+        Double3 vec2 = new Double3(rotX - rotXY, -rotZ, rotYZ - rotXZ).scale(scale);
+        Double3 vec1Rot = vec1.scale(cos[particleRotation]).add(vec2.scale(sin[particleRotation]));
+        Double3 vec2Rot = vec1.scale(-sin[particleRotation]).add(vec2.scale(cos[particleRotation]));
+        
+        tessellator.setColorRGBA_F(this.particleRed, this.particleGreen, this.particleBlue, this.particleAlpha);
+        addVertex(tessellator, center.sub(vec1Rot), maxU, maxV);
+        addVertex(tessellator, center.sub(vec2Rot), maxU, minV);
+        addVertex(tessellator, center.add(vec1Rot), minU, minV);
+        addVertex(tessellator, center.add(vec2Rot), minU, maxV);
+    }
+    
+	protected void addVertex(Tessellator tessellator, Double3 coord, double u, double v) {
+		tessellator.addVertexWithUV(coord.x, coord.y, coord.z, u, v);
+	}
+	/** Calculates and sets the color of the particle by blending the average color of the block texture with the current biome color
+	 *  Blending is done in HSB color space, weighted by the relative saturation of the colors
+	 * @param textureAvgColor average color of the block texture
+	 * @param blockColor biome color at the spawning block
+	 */
+	public void calculateParticleColor(int textureAvgColor, int blockColor) {
+		float[] hsbTexture = Color.RGBtoHSB((textureAvgColor >> 16) & 0xFF, (textureAvgColor >> 8) & 0xFF, textureAvgColor & 0xFF, null);
+		float[] hsbBlock = Color.RGBtoHSB((blockColor >> 16) & 0xFF, (blockColor >> 8) & 0xFF, blockColor & 0xFF, null);
+		
+		float weightTex = hsbTexture[1] / (hsbTexture[1] + hsbBlock[1]);
+		float weightBlock = 1.0f - weightTex;
+		
+		// avoid circular average for hue for performance reasons
+		// one of the color components should dominate anyway
+		float h = weightTex * hsbTexture[0] + weightBlock * hsbBlock[0];
+		float s = weightTex * hsbTexture[1] + weightBlock * hsbBlock[1];
+		float b = weightTex * hsbTexture[2] + weightBlock * hsbBlock[2] * biomeBrightnessMultiplier;
+		int particleColor = Color.HSBtoRGB(h, s, b);
+		
+		particleBlue = (particleColor & 0xFF) / 256.0f;
+		particleGreen = ((particleColor >> 8) & 0xFF) / 256.0f;
+		particleRed = ((particleColor >> 16) & 0xFF) / 256.0f;
+	}
+	
+	@Override
+	public int getFXLayer() {
+		return 1;
+	}
+
+}

src/main/java/mods/betterfoliage/client/render/impl/RenderBlockBetterAlgae.java

@@ -0,0 +1,85 @@
+package mods.betterfoliage.client.render.impl;
+
+import java.util.Random;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.client.render.IconSet;
+import mods.betterfoliage.client.render.RenderBlockAOBase;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Double3;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.gen.NoiseGeneratorSimplex;
+import net.minecraftforge.client.event.TextureStitchEvent;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.event.world.WorldEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderBlockBetterAlgae extends RenderBlockAOBase implements IRenderBlockDecorator {
+
+	public IconSet algaeIcons = new IconSet("bettergrassandleaves", "better_algae_%d");
+	public NoiseGeneratorSimplex noise;
+	
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		if (!Config.algaeEnabled) return false;
+		if (!Config.dirt.matchesID(block)) return false;
+		if (!Config.algaeBiomeList.contains(blockAccess.getBiomeGenForCoords(x, z).biomeID)) return false;
+		if (blockAccess.getBlock(x, y + 1, z).getMaterial() != Material.water) return false;
+		if (blockAccess.getBlock(x, y + 2, z).getMaterial() != Material.water) return false;
+		int terrainVariation = MathHelper.floor_double((noise.func_151605_a(x, z) + 1.0) * 32.0);
+		return terrainVariation < Config.algaePopulation;
+	}
+	
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		// store world for later use
+		blockAccess = world;
+		
+		// use original renderer for block breaking overlay
+		if (renderer.hasOverrideBlockTexture()) {
+			renderer.setRenderBoundsFromBlock(block);
+			renderer.renderStandardBlock(block, x, y, z);
+			return true;
+		}
+		
+		// render dirt block
+		setPassCounters(1);
+		setRenderBoundsFromBlock(block);
+		renderStandardBlock(block, x, y, z);
+		
+		int variation = getSemiRandomFromPos(x, y, z, 0);
+		int heightVariation = getSemiRandomFromPos(x, y, z, 1);
+		
+		IIcon renderIcon = algaeIcons.get(variation);
+		if (renderIcon == null) return true;
+		
+		double scale = Config.algaeSize * 0.5;
+		double halfHeight = 0.5 * (Config.algaeHeightMin + pRand[heightVariation] * (Config.algaeHeightMax - Config.algaeHeightMin));
+		Tessellator.instance.setBrightness(getBrightness(block, x, y + 1, z));
+		renderCrossedSideQuads(new Double3(x + 0.5, y + 1.0 - 0.125 * halfHeight, z + 0.5), ForgeDirection.UP, scale, halfHeight, pRot[variation], Config.algaeHOffset, renderIcon, 0, false);
+		
+		return true;
+	}
+	
+	@SubscribeEvent
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		
+		algaeIcons.registerIcons(event.map);
+		BetterFoliage.log.info(String.format("Found %d algae textures", algaeIcons.numLoaded));
+	}
+	
+	@SubscribeEvent
+	public void handleWorldLoad(WorldEvent.Load event) {
+		noise = new NoiseGeneratorSimplex(new Random(event.world.getWorldInfo().getSeed() + 1));
+	}
+	
+}

src/main/java/mods/betterfoliage/client/render/impl/RenderBlockBetterCactus.java

@@ -0,0 +1,96 @@
+package mods.betterfoliage.client.render.impl;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.render.FakeRenderBlockAOBase;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.client.render.IconSet;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Double3;
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.client.event.TextureStitchEvent;
+import net.minecraftforge.common.util.ForgeDirection;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderBlockBetterCactus extends FakeRenderBlockAOBase implements IRenderBlockDecorator {
+
+	public IIcon cactusRoundIcon;
+	public IconSet cactusSideIcons = new IconSet("bettergrassandleaves", "better_cactus_arm_%d");
+	
+	/** Possible directions for cactus side growth*/
+	public static ForgeDirection[] cactusDirections = new ForgeDirection[] { ForgeDirection.NORTH, ForgeDirection.SOUTH, ForgeDirection.EAST, ForgeDirection.WEST};
+	
+	/** Inner radius of cactus stem */
+	public static double cactusRadius = 0.4375;
+	
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		return Config.cactusEnabled && block == Blocks.cactus;
+	}
+	
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		// store world for later use
+		blockAccess = world;
+		
+		// use original renderer for block breaking overlay
+		if (renderer.hasOverrideBlockTexture()) {
+			renderer.renderBlockCactus(block, x, y, z);
+			return true;
+		}
+		
+		// render cactus center
+		setPassCounters(1);
+		renderStandardBlock(block, x, y, z);
+		
+		Double3 blockCenter = new Double3(x + 0.5, y + 0.5, z + 0.5);
+		Tessellator.instance.setBrightness(getBrightness(block,x, y, z));
+		renderCactusCore(block.getBlockTextureFromSide(ForgeDirection.UP.ordinal()),
+						 block.getBlockTextureFromSide(ForgeDirection.NORTH.ordinal()),
+						 blockCenter, 0);
+		
+		// render side growth
+		ForgeDirection drawDirection = cactusDirections[getSemiRandomFromPos(x, y, z, 0) % 4];
+		int iconVariation = getSemiRandomFromPos(x, y, z, 1);
+		Double3 drawBase = blockCenter.add(new Double3(drawDirection).scale(cactusRadius));
+		
+		Tessellator.instance.setBrightness(getBrightness(block, x, y, z));
+		if (cactusSideIcons.hasIcons()) renderCrossedSideQuads(drawBase, drawDirection, 0.5, 0.5, pRot[iconVariation], 0.2, cactusSideIcons.get(iconVariation), 0, false);
+		renderCrossedBlockQuadsSkew(blockCenter, 0.65,
+									pRot[iconVariation].scaleAxes(0.1, 0.0, 0.1),
+									pRot[(iconVariation + 1) & 63].scaleAxes(0.1, 0.0, 0.1),
+									cactusRoundIcon, iconVariation, false, false);
+		return true;
+	}
+
+	protected void renderCactusCore(IIcon topIcon, IIcon sideIcon, Double3 blockCenter, int sideUvRot) {
+		if (Minecraft.isAmbientOcclusionEnabled()) {
+			renderQuadWithShading(sideIcon, blockCenter.add(cactusRadius, 0.0, 0.0), new Double3(0.0, 0.0, -0.5), new Double3(0.0, 0.5, 0.0), sideUvRot, aoXPYZPN, aoXPYZPP, aoXPYZNP, aoXPYZNN);
+			renderQuadWithShading(sideIcon, blockCenter.add(-cactusRadius, 0.0, 0.0), new Double3(0.0, 0.0, 0.5), new Double3(0.0, 0.5, 0.0), sideUvRot, aoXNYZPP, aoXNYZPN, aoXNYZNN, aoXNYZNP);
+			renderQuadWithShading(sideIcon, blockCenter.add(0.0, 0.0, cactusRadius), new Double3(0.5, 0.0, 0.0), new Double3(0.0, 0.5, 0.0), sideUvRot, aoZPXYPP, aoZPXYNP, aoZPXYNN, aoZPXYPN);
+			renderQuadWithShading(sideIcon, blockCenter.add(0.0, 0.0, -cactusRadius), new Double3(-0.5, 0.0, 0.0), new Double3(0.0, 0.5, 0.0), sideUvRot, aoZNXYNP, aoZNXYPP, aoZNXYPN, aoZNXYNN);
+			renderQuadWithShading(topIcon, blockCenter.add(0.0, 0.5, 0.0), new Double3(-0.5, 0.0, 0.0), new Double3(0.0, 0.0, 0.5), 0, aoYPXZNP, aoYPXZPP, aoYPXZPN, aoYPXZNN);
+		} else {
+			renderQuad(sideIcon, blockCenter.add(cactusRadius, 0.0, 0.0), new Double3(0.0, 0.0, -0.5), new Double3(0.0, 0.5, 0.0), sideUvRot);
+			renderQuad(sideIcon, blockCenter.add(-cactusRadius, 0.0, 0.0), new Double3(0.0, 0.0, 0.5), new Double3(0.0, 0.5, 0.0), sideUvRot);
+			renderQuad(sideIcon, blockCenter.add(0.0, 0.0, cactusRadius), new Double3(0.5, 0.0, 0.0), new Double3(0.0, 0.5, 0.0), sideUvRot);
+			renderQuad(sideIcon, blockCenter.add(0.0, 0.0, -cactusRadius), new Double3(-0.5, 0.0, 0.0), new Double3(0.0, 0.5, 0.0), sideUvRot);
+			renderQuad(topIcon, blockCenter.add(0.0, 0.5, 0.0), new Double3(-0.5, 0.0, 0.0), new Double3(0.0, 0.0, 0.5), 0);
+		}
+	}
+	
+	@SubscribeEvent
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		
+		cactusRoundIcon = event.map.registerIcon("bettergrassandleaves:better_cactus");
+		cactusSideIcons.registerIcons(event.map);
+		BetterFoliage.log.info(String.format("Found %d cactus arm textures", cactusSideIcons.numLoaded));
+	}
+}

src/main/java/mods/betterfoliage/client/render/impl/RenderBlockBetterCoral.java

@@ -0,0 +1,95 @@
+package mods.betterfoliage.client.render.impl;
+
+import java.util.Random;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.client.render.IconSet;
+import mods.betterfoliage.client.render.RenderBlockAOBase;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Double3;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.gen.NoiseGeneratorSimplex;
+import net.minecraftforge.client.event.TextureStitchEvent;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.event.world.WorldEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+public class RenderBlockBetterCoral extends RenderBlockAOBase implements IRenderBlockDecorator {
+
+	public IconSet coralCrustIcons = new IconSet("bettergrassandleaves", "better_crust_%d");
+	public IconSet coralCrossIcons = new IconSet("bettergrassandleaves", "better_coral_%d");
+	public NoiseGeneratorSimplex noise;
+	
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		if (!Config.coralEnabled) return false;
+		if (block != Blocks.sand) return false;
+		if (!Config.coralBiomeList.contains(blockAccess.getBiomeGenForCoords(x, z).biomeID)) return false;
+		int terrainVariation = MathHelper.floor_double((noise.func_151605_a(x * 0.1, z * 0.1) + 1.0) * 32.0);
+		return terrainVariation < Config.coralPopulation;
+	}
+	
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		blockAccess = world;
+		renderWorldBlockBase(1, world, x, y, z, block, modelId, renderer);
+		
+		Double3 blockCenter = new Double3(x + 0.5, y + 0.5, z + 0.5);
+		double offset = pRand[getSemiRandomFromPos(x, y, z, 6)] * Config.coralVOffset;
+		double halfSize = Config.coralSize * 0.5;
+		double halfCrustSize = Config.coralCrustSize * 0.5;
+		
+		Tessellator.instance.setBrightness(getBrightness(block, x, y, z));
+		for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
+			if (blockAccess.getBlock(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ).getMaterial() != Material.water) continue;
+			if (blockAccess.isAirBlock(x + dir.offsetX, y + dir.offsetY + 1, z + dir.offsetZ)) continue;
+				
+			int variation = getSemiRandomFromPos(x, y, z, dir.ordinal());
+			if (variation < Config.coralChance) {
+				IIcon crustIcon = coralCrustIcons.get(variation);
+				IIcon coralIcon = coralCrossIcons.get(variation);
+				if (crustIcon != null) renderCoralCrust(blockCenter, dir, offset, halfCrustSize, crustIcon, variation);
+				if (coralIcon != null) renderCrossedSideQuads(blockCenter.add(new Double3(dir).scale(0.5)), dir, 
+														      halfSize, halfSize, 
+														      pRot[variation], Config.coralHOffset,
+														      coralIcon, 0, false);
+			}
+		}
+		
+		return true;
+	}
+	
+	protected void renderCoralCrust(Double3 blockCenter, ForgeDirection dir, double offset, double scale, IIcon icon, int uvRot) {
+		Double3 face1 = new Double3(faceDir1[dir.ordinal()]).scale(scale);
+		Double3 face2 = new Double3(faceDir2[dir.ordinal()]).scale(scale);
+		Double3 drawCenter = blockCenter.add(new Double3(dir).scale(0.5 + offset));
+		if (Minecraft.isAmbientOcclusionEnabled()) {
+			setShadingForFace(dir);
+			renderQuadWithShading(icon, drawCenter, face1, face2, uvRot, faceAOPP, faceAONP, faceAONN, faceAOPN);
+		} else {
+			renderQuad(icon, drawCenter, face1, face2, uvRot);
+		}
+	}
+	
+	@SubscribeEvent
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		
+		coralCrustIcons.registerIcons(event.map);
+		coralCrossIcons.registerIcons(event.map);
+		BetterFoliage.log.info(String.format("Found %d coral crust textures", coralCrustIcons.numLoaded));
+		BetterFoliage.log.info(String.format("Found %d coral textures", coralCrossIcons.numLoaded));
+	}
+	
+	@SubscribeEvent
+	public void handleWorldLoad(WorldEvent.Load event) {
+		noise = new NoiseGeneratorSimplex(new Random(event.world.getWorldInfo().getSeed() + 2));
+	}
+}

src/main/java/mods/betterfoliage/client/render/impl/RenderBlockBetterGrass.java

@@ -0,0 +1,129 @@
+package mods.betterfoliage.client.render.impl;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.ShadersModIntegration;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.client.render.IconSet;
+import mods.betterfoliage.client.render.RenderBlockAOBase;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Double3;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.client.event.TextureStitchEvent;
+import net.minecraftforge.common.util.ForgeDirection;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderBlockBetterGrass extends RenderBlockAOBase implements IRenderBlockDecorator {
+
+	public IconSet grassIcons = new IconSet("bettergrassandleaves", "better_grass_long_%d");
+	public IconSet snowGrassIcons = new IconSet("bettergrassandleaves", "better_grass_snowed_%d");
+	public IIcon grassGenIcon;
+	public IIcon snowGrassGenIcon;
+	
+	protected IIcon grassTopIcon;
+	protected boolean connectXP, connectXN, connectZP, connectZN;
+	
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		return Config.grass.matchesID(block);
+	}
+	
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		blockAccess = world;
+		
+		// check for connected grass
+		checkConnectedGrass(x, y, z);
+		grassTopIcon = block.getIcon(blockAccess, x, y, z, ForgeDirection.UP.ordinal());
+		
+		renderWorldBlockBase(1, world, x, y, z, block, modelId, renderer);
+		if (!Config.grassEnabled) return true;
+		
+		boolean isSnowTop = blockAccess.getBlock(x, y + 1, z) == Blocks.snow_layer;
+		boolean isAirTop = blockAccess.isAirBlock(x, y + 1, z);
+		
+		if (isSnowTop || isAirTop) {
+			// render short grass
+			int iconVariation = getSemiRandomFromPos(x, y, z, 0);
+			int heightVariation = getSemiRandomFromPos(x, y, z, 1);
+			
+			double scale = Config.grassSize * 0.5;
+			double halfHeight = 0.5 * (Config.grassHeightMin + pRand[heightVariation] * (Config.grassHeightMax - Config.grassHeightMin));
+			
+			IIcon shortGrassIcon = null;
+			if (isSnowTop) {
+				// clear biome colors
+				aoYPXZNN.setGray(0.9f); aoYPXZNP.setGray(0.9f); aoYPXZPN.setGray(0.9f); aoYPXZPP.setGray(0.9f);
+				Tessellator.instance.setColorOpaque(230, 230, 230);
+				shortGrassIcon = Config.grassUseGenerated ? snowGrassGenIcon : snowGrassIcons.get(iconVariation);
+			} else {
+				Tessellator.instance.setColorOpaque_I(block.colorMultiplier(blockAccess, x, y, z));
+				shortGrassIcon = Config.grassUseGenerated ? grassGenIcon : grassIcons.get(iconVariation);
+			}
+			if (shortGrassIcon == null) return true;
+			
+			ShadersModIntegration.startGrassQuads();
+			Tessellator.instance.setBrightness(getBrightness(block, x, y + 1, z));
+			renderCrossedSideQuads(new Double3(x + 0.5, y + 1.0 + (isSnowTop ? 0.0625 : 0.0), z + 0.5), ForgeDirection.UP, scale, halfHeight, pRot[iconVariation], Config.grassHOffset, shortGrassIcon, 0, false);
+		}
+		return true;
+	}
+
+	protected void checkConnectedGrass(int x, int y, int z) {
+		Block blockBelow = blockAccess.getBlock(x, y - 1, z);
+		if (Config.ctxGrassAggressiveEnabled && (Config.grass.matchesID(blockBelow) || Config.dirt.matchesID(blockBelow))) {
+			connectXP = true;
+			connectXN = true;
+			connectZP = true;
+			connectZN = true;
+		} else if (Config.ctxGrassClassicEnabled) {
+			connectXP = Config.grass.matchesID(blockAccess.getBlock(x + 1, y - 1, z));
+			connectXN = Config.grass.matchesID(blockAccess.getBlock(x - 1, y - 1, z));
+			connectZP = Config.grass.matchesID(blockAccess.getBlock(x, y - 1, z + 1));
+			connectZN = Config.grass.matchesID(blockAccess.getBlock(x, y - 1, z - 1));
+		} else {
+			connectXP = false;
+			connectXN = false;
+			connectZP = false;
+			connectZN = false;
+		}
+	}
+	
+	@Override
+	public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceZNeg(block, x, y, z, connectZN ? grassTopIcon : icon);
+	}
+
+	@Override
+	public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceZPos(block, x, y, z, connectZP ? grassTopIcon : icon);
+	}
+
+	@Override
+	public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceXNeg(block, x, y, z, connectXN ? grassTopIcon : icon);
+	}
+
+	@Override
+	public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon) {
+		super.renderFaceXPos(block, x, y, z, connectXP ? grassTopIcon : icon);
+	}
+
+	@SubscribeEvent
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		
+		grassIcons.registerIcons(event.map);
+		snowGrassIcons.registerIcons(event.map);
+		grassGenIcon = event.map.registerIcon("bf_shortgrass:minecraft:tallgrass");
+		snowGrassGenIcon = event.map.registerIcon("bf_shortgrass_snow:minecraft:tallgrass");
+		BetterFoliage.log.info(String.format("Found %d short grass textures", grassIcons.numLoaded));
+		BetterFoliage.log.info(String.format("Found %d snowy grass textures", snowGrassIcons.numLoaded));
+	}
+
+}

src/main/java/mods/betterfoliage/client/render/impl/RenderBlockBetterLeaves.java

@@ -0,0 +1,89 @@
+package mods.betterfoliage.client.render.impl;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.BetterFoliageClient;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.client.render.RenderBlockAOBase;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Double3;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.util.ForgeDirection;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderBlockBetterLeaves extends RenderBlockAOBase implements IRenderBlockDecorator {
+	
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		if (!Config.leavesEnabled) return false;
+		if (original > 0 && original < 42) return false;
+		return Config.leaves.matchesID(block) && !isBlockSurrounded(blockAccess, x, y, z);
+	}
+	
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		blockAccess = world;
+		renderWorldBlockBase(1, world, x, y, z, block, modelId, renderer);
+
+		// find generated texture to render with, assume the
+		// "true" texture of the block is the one on the north size
+		TextureAtlasSprite blockLeafIcon = null;
+		try {
+			blockLeafIcon = (TextureAtlasSprite) block.getIcon(world, x, y, z, ForgeDirection.NORTH.ordinal());
+		} catch (ClassCastException e) {
+		}
+		
+		if (blockLeafIcon == null) {
+			BetterFoliage.log.debug(String.format("null leaf texture, x:%d, y:%d, z:%d, meta:%d, block:%s", x, y, z, blockAccess.getBlockMetadata(x, y, z), block.getClass().getName()));
+			return true;
+		}
+		IIcon crossLeafIcon = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(BetterFoliageClient.leafGenerator.domainName + ":" + blockLeafIcon.getIconName());
+		if (crossLeafIcon == null) {
+			return true;
+		}
+		
+		int offsetVariation = getSemiRandomFromPos(x, y, z, 0);
+		int uvVariation = getSemiRandomFromPos(x, y, z, 1);
+		double halfSize = 0.5 * Config.leavesSize;
+		boolean isAirTop = y == 255 || blockAccess.isAirBlock(x, y + 1, z);
+		boolean isAirBottom = y == 0 || blockAccess.isAirBlock(x, y - 1, z);
+		
+		Tessellator.instance.setBrightness(isAirTop ? getBrightness(block, x, y + 1, z) : (isAirBottom ? getBrightness(block, x, y - 1, z) : getBrightness(block, x, y, z)));
+		Tessellator.instance.setColorOpaque_I(block.colorMultiplier(blockAccess, x, y, z));
+		
+		if (Config.leavesSkew) {
+			renderCrossedBlockQuadsSkew(new Double3(x + 0.5, y + 0.5, z + 0.5), halfSize, 
+										pRot[offsetVariation].scaleAxes(Config.leavesHOffset, Config.leavesVOffset, Config.leavesHOffset),
+										pRot[(offsetVariation + 1) & 63].scaleAxes(Config.leavesHOffset, Config.leavesVOffset, Config.leavesHOffset),
+										crossLeafIcon, uvVariation, isAirTop, isAirBottom);
+		} else {
+			renderCrossedBlockQuadsTranslate(new Double3(x + 0.5, y + 0.5, z + 0.5), halfSize, 
+											 pRot[offsetVariation].scaleAxes(Config.leavesHOffset, Config.leavesVOffset, Config.leavesHOffset),
+											 crossLeafIcon, uvVariation, isAirTop, isAirBottom);
+		}
+
+
+		return true;
+	}
+
+	protected boolean isBlockSurrounded(IBlockAccess blockAccess, int x, int y, int z) {
+		if (isBlockNonSurrounding(blockAccess.getBlock(x + 1, y, z))) return false;
+		if (isBlockNonSurrounding(blockAccess.getBlock(x - 1, y, z))) return false;
+		if (isBlockNonSurrounding(blockAccess.getBlock(x, y + 1, z))) return false;
+		if (isBlockNonSurrounding(blockAccess.getBlock(x, y - 1, z))) return false;
+		if (isBlockNonSurrounding(blockAccess.getBlock(x, y, z + 1))) return false;
+		if (isBlockNonSurrounding(blockAccess.getBlock(x, y, z - 1))) return false;
+		return true;
+	}
+	
+	protected boolean isBlockNonSurrounding(Block block) {
+		return block.getMaterial() == Material.air || block == Blocks.snow_layer;
+	}
+}

src/main/java/mods/betterfoliage/client/render/impl/RenderBlockBetterLilypad.java

@@ -0,0 +1,74 @@
+package mods.betterfoliage.client.render.impl;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.render.FakeRenderBlockAOBase;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.client.render.IconSet;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Double3;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.init.Blocks;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.client.event.TextureStitchEvent;
+import net.minecraftforge.common.util.ForgeDirection;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderBlockBetterLilypad extends FakeRenderBlockAOBase implements IRenderBlockDecorator {
+
+	public IconSet lilypadFlowers = new IconSet("bettergrassandleaves", "better_lilypad_flower_%d");
+	public IconSet lilypadRoots = new IconSet("bettergrassandleaves", "better_lilypad_roots_%d");
+	
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		return Config.lilypadEnabled && block == Blocks.waterlily;
+	}
+	
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		// store world for later use
+		blockAccess = world;
+		
+		// use original renderer for block breaking overlay
+		if (renderer.hasOverrideBlockTexture()) {
+			renderer.renderBlockLilyPad(block, x, y, z);
+			return true;
+		}
+		
+		// render lilypad block
+		renderBlockLilyPad(block, x, y, z);
+		
+		int chanceVariation = getSemiRandomFromPos(x, y, z, 0);
+		int iconVariation = getSemiRandomFromPos(x, y, z, 1);
+		int offsetVariation = getSemiRandomFromPos(x, y, z, 2);
+		
+		Tessellator.instance.setBrightness(getBrightness(block, x, y, z));
+		Tessellator.instance.setColorOpaque(255, 255, 255);
+		if (lilypadRoots.hasIcons()) renderCrossedSideQuads(new Double3(x + 0.5, y + 0.015, z + 0.5), ForgeDirection.DOWN,
+														   	0.2, 0.3,
+														   	null, 0.0,
+														   	lilypadRoots.get(iconVariation), 2,
+														   	true);
+		if (chanceVariation < Config.lilypadChance && lilypadFlowers.hasIcons())
+			renderCrossedSideQuads(new Double3(x + 0.5, y + 0.02, z + 0.5), ForgeDirection.UP,
+					 			   0.2, 0.3, 
+					 			   pRot[offsetVariation], Config.lilypadHOffset, 
+					 			   lilypadFlowers.get(iconVariation), 0,
+					 			   true);
+		
+		return true;
+	}
+	
+	@SubscribeEvent
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		
+		lilypadFlowers.registerIcons(event.map);
+		lilypadRoots.registerIcons(event.map);
+		BetterFoliage.log.info(String.format("Found %d lilypad flower textures", lilypadFlowers.numLoaded));
+		BetterFoliage.log.info(String.format("Found %d lilypad root textures", lilypadRoots.numLoaded));
+	}
+	
+}

src/main/java/mods/betterfoliage/client/render/impl/RenderBlockBetterMycelium.java

@@ -0,0 +1,70 @@
+package mods.betterfoliage.client.render.impl;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.ShadersModIntegration;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.client.render.IconSet;
+import mods.betterfoliage.client.render.RenderBlockAOBase;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Double3;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.client.event.TextureStitchEvent;
+import net.minecraftforge.common.util.ForgeDirection;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderBlockBetterMycelium extends RenderBlockAOBase implements IRenderBlockDecorator {
+
+	public IconSet myceliumIcons = new IconSet("bettergrassandleaves", "better_mycel_%d");
+	
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		if (!Config.grassEnabled) return false;
+		if (block != Blocks.mycelium) return false;
+		if (!blockAccess.isAirBlock(x, y + 1, z) && blockAccess.getBlock(x, y + 1, z) != Blocks.snow_layer) return false;
+		return true;
+	}
+	
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		blockAccess = world;
+		renderWorldBlockBase(1, world, x, y, z, block, modelId, renderer);
+		
+		boolean isSnowed = blockAccess.getBlock(x, y + 1, z) == Blocks.snow_layer;
+		int iconVariation = getSemiRandomFromPos(x, y, z, 0);
+		IIcon renderIcon = myceliumIcons.get(iconVariation);
+		
+		if (isSnowed || renderIcon == null) return true;
+		
+		int heightVariation = getSemiRandomFromPos(x, y, z, 1);
+		double scale = Config.grassSize * 0.5;
+		double halfHeight = 0.5 * (Config.grassHeightMin + pRand[heightVariation] * (Config.grassHeightMax - Config.grassHeightMin));
+		
+		if (isSnowed) {
+			aoYPXZNN.setGray(0.9f); aoYPXZNP.setGray(0.9f); aoYPXZPN.setGray(0.9f); aoYPXZPP.setGray(0.9f);
+			Tessellator.instance.setColorOpaque(230, 230, 230);
+		}
+		
+		// render mycelium
+		ShadersModIntegration.startGrassQuads();
+		Tessellator.instance.setBrightness(getBrightness(block, x, y + 1, z));
+		Tessellator.instance.setColorOpaque_I(block.colorMultiplier(blockAccess, x, y, z));
+		renderCrossedSideQuads(new Double3(x + 0.5, y + 1.0 + (isSnowed ? 0.0625 : 0.0), z + 0.5), ForgeDirection.UP, scale, halfHeight, pRot[iconVariation], Config.grassHOffset, renderIcon, 0, false);
+		
+		return true;
+	}
+
+	@SubscribeEvent
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		
+		myceliumIcons.registerIcons(event.map);
+		BetterFoliage.log.info(String.format("Found %d mycelium textures", myceliumIcons.numLoaded));
+	}
+
+}

src/main/java/mods/betterfoliage/client/render/impl/RenderBlockBetterReed.java

@@ -0,0 +1,81 @@
+package mods.betterfoliage.client.render.impl;
+
+import java.util.Random;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.ShadersModIntegration;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.client.render.IconSet;
+import mods.betterfoliage.client.render.RenderBlockAOBase;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Double3;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.gen.NoiseGeneratorSimplex;
+import net.minecraftforge.client.event.TextureStitchEvent;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.event.world.WorldEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderBlockBetterReed extends RenderBlockAOBase implements IRenderBlockDecorator {
+
+	public IconSet reedBottomIcons = new IconSet("bf_reed_bottom", "bettergrassandleaves:better_reed_%d");
+	public IconSet reedTopIcons = new IconSet("bf_reed_top", "bettergrassandleaves:better_reed_%d");
+	public NoiseGeneratorSimplex noise;
+	
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		if (!Config.reedEnabled) return false;
+		if (!(Config.dirt.matchesID(block))) return false;
+		if (!Config.reedBiomeList.contains(blockAccess.getBiomeGenForCoords(x, z).biomeID)) return false;
+		if (blockAccess.getBlock(x, y + 1, z).getMaterial() != Material.water) return false;
+		if (!blockAccess.isAirBlock(x, y + 2, z)) return false;
+		int terrainVariation = MathHelper.floor_double((noise.func_151605_a(x, z) + 1.0) * 32.0);
+		return terrainVariation < Config.reedPopulation;
+	}
+	
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		blockAccess = world;
+		renderWorldBlockBase(1, world, x, y, z, block, modelId, renderer);
+		
+		int iconVariation = getSemiRandomFromPos(x, y, z, 0);
+		int heightVariation = getSemiRandomFromPos(x, y, z, 1);
+		
+		IIcon bottomIcon = reedBottomIcons.get(iconVariation);
+		IIcon topIcon = reedTopIcons.get(iconVariation);
+		if (bottomIcon == null || topIcon == null) return true;
+		
+		double quarterHeight = 0.25 * (Config.reedHeightMin + pRand[heightVariation] * (Config.reedHeightMax - Config.reedHeightMin));
+		Tessellator.instance.setBrightness(getBrightness(block, x, y + 2, z));
+		Tessellator.instance.setColorOpaque(255, 255, 255);
+		
+		// render reeds
+		ShadersModIntegration.startGrassQuads();
+		renderCrossedSideQuads(new Double3(x + 0.5, y + 1.0, z + 0.5), ForgeDirection.UP, 0.5, quarterHeight, pRot[iconVariation], Config.reedHOffset, bottomIcon, 0, true);
+		renderCrossedSideQuads(new Double3(x + 0.5, y + 1.0 + 2.0 * quarterHeight, z + 0.5), ForgeDirection.UP, 0.5, quarterHeight, pRot[iconVariation], Config.reedHOffset, topIcon, 0, true);
+		
+		return true;
+	}
+	
+	@SubscribeEvent
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		
+		reedBottomIcons.registerIcons(event.map);
+		reedTopIcons.registerIcons(event.map);
+		BetterFoliage.log.info(String.format("Found %d reed textures", reedBottomIcons.numLoaded));
+	}
+	
+	@SubscribeEvent
+	public void handleWorldLoad(WorldEvent.Load event) {
+		noise = new NoiseGeneratorSimplex(new Random(event.world.getWorldInfo().getSeed()));
+	}
+	
+}

src/main/java/mods/betterfoliage/client/render/impl/RenderBlocksBetterGrassSide.java

@@ -0,0 +1,49 @@
+package mods.betterfoliage.client.render.impl;
+
+import mods.betterfoliage.client.render.FakeRenderBlockAOBase;
+import mods.betterfoliage.client.render.IRenderBlockDecorator;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.OffsetBlockAccess;
+import mods.betterfoliage.common.util.Utils;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.world.IBlockAccess;
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/** Accepts dirt blocks with grass on top if aggressive connected grass is enabled.<br/>
+ *  Renders the grass block in place of dirt.
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public class RenderBlocksBetterGrassSide extends FakeRenderBlockAOBase implements IRenderBlockDecorator {
+
+	@Override
+	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
+		return Config.ctxGrassAggressiveEnabled && 
+			   Config.dirt.matchesID(block) &&
+			   Config.grass.matchesID(blockAccess.getBlock(x, y + 1, z));
+	}
+	
+	@Override
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		// fake grass block @(0, +1, 0) at render location
+		IBlockAccess originalBA = renderer.blockAccess;
+		renderer.blockAccess = new OffsetBlockAccess(world, x, y, z, 0, 1, 0);
+		
+		Block renderBlock = renderer.blockAccess.getBlock(x, y, z);
+		boolean result;
+		ISimpleBlockRenderingHandler handler = Utils.getRenderingHandler(renderBlock.getRenderType());
+		if (handler != null) {
+			result = handler.renderWorldBlock(renderer.blockAccess, x, y, z, renderBlock, renderBlock.getRenderType(), renderer);
+		} else {
+			result = renderer.renderStandardBlock(renderBlock, x, y, z);
+		}
+		
+		// restore renderer to sanity
+		renderer.blockAccess = originalBA;
+		return result;
+	}
+
+}

src/main/java/mods/betterfoliage/client/resource/BlockTextureGenerator.java

@@ -0,0 +1,92 @@
+package mods.betterfoliage.client.resource;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.common.util.Utils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.client.resources.IResource;
+import net.minecraft.client.resources.IResourceManager;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.event.TextureStitchEvent;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/** Base class for texture generators. Registers itself as a domain resource manager for the duration of block texture stitching.
+ * @author octarine-noise
+ *
+ */
+@SideOnly(Side.CLIENT)
+public abstract class BlockTextureGenerator implements IResourceManager {
+
+	/** Resource domain name of generated textures */
+	public String domainName;
+	
+	/** Resource location for fallback texture (if the generation process fails) */
+	public ResourceLocation missingResource;
+	
+	/** Texture atlas for block textures used in the current run */
+	public TextureMap blockTextures;
+	
+	public BlockTextureGenerator(String domainName, ResourceLocation missingResource) {
+		this.domainName = domainName;
+		this.missingResource = missingResource;
+	}
+	
+	@SubscribeEvent
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		blockTextures = event.map;
+
+		Map<String, IResourceManager> domainManagers = Utils.getDomainResourceManagers();
+		if (domainManagers == null) {
+			BetterFoliage.log.warn("Failed to inject texture generator");
+			return;
+		}
+		domainManagers.put(domainName, this);
+	}
+	
+	@SubscribeEvent
+	public void endTextureReload(TextureStitchEvent.Post event) {
+		blockTextures = null;
+		if (event.map.getTextureType() != 0) return;
+		
+		// don't leave a mess
+		Map<String, IResourceManager> domainManagers = Utils.getDomainResourceManagers();
+		if (domainManagers != null) domainManagers.remove(domainName);
+	}
+	
+	public Set<String> getResourceDomains() {
+		return ImmutableSet.<String>of(domainName);
+	}
+	
+	public List<IResource> getAllResources(ResourceLocation resource) throws IOException {
+		return ImmutableList.<IResource>of(getResource(resource));
+	}
+	
+	public IResource getMissingResource() throws IOException {
+		return Minecraft.getMinecraft().getResourceManager().getResource(missingResource);
+	}
+	
+	public ResourceLocation unwrapResource(ResourceLocation wrapped) {
+		return new ResourceLocation(wrapped.getResourcePath().substring(16));
+	}
+	
+	protected static int blendRGB(int rgbOrig, int rgbBlend, int weightOrig, int weightBlend) {
+		int r = (((rgbOrig >> 16) & 0xFF) * weightOrig + ((rgbBlend >> 16) & 0xFF) * weightBlend) / (weightOrig + weightBlend);
+		int g = (((rgbOrig >> 8) & 0xFF) * weightOrig + ((rgbBlend >> 8) & 0xFF) * weightBlend) / (weightOrig + weightBlend);
+		int b = ((rgbOrig & 0xFF) * weightOrig + (rgbBlend & 0xFF) * weightBlend) / (weightOrig + weightBlend);
+		int a = (rgbOrig >> 24) & 0xFF;
+		int result = (int) (a << 24 | r << 16 | g << 8 | b);
+		return result;
+	}
+}

src/main/java/mods/betterfoliage/client/resource/BufferedImageResource.java

@@ -0,0 +1,51 @@
+package mods.betterfoliage.client.resource;
+
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.imageio.ImageIO;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraft.client.resources.IResource;
+import net.minecraft.client.resources.data.IMetadataSection;
+
+/** {@link IResource} for a {@link BufferedImage}
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public class BufferedImageResource implements IResource {
+
+	/** Raw PNG data*/
+	protected byte[] data = null;
+	
+	public BufferedImageResource(BufferedImage image) {
+		// create PNG image
+		try {
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			ImageIO.write(image, "PNG", baos);
+			data = baos.toByteArray();
+		} catch (IOException e) {
+		}
+	}
+	
+	@Override
+	public InputStream getInputStream() {
+		return data == null ? null : new ByteArrayInputStream(data);
+	}
+
+	@Override
+	public boolean hasMetadata() {
+		return false;
+	}
+
+	@Override
+	public IMetadataSection getMetadata(String var1) {
+		return null;
+	}
+
+}

src/main/java/mods/betterfoliage/client/resource/LeafGenerator.java

@@ -0,0 +1,68 @@
+package mods.betterfoliage.client.resource;
+
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.BetterFoliageClient;
+import mods.betterfoliage.client.ShadersModIntegration;
+import net.minecraft.client.Minecraft;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.event.TextureStitchEvent.Post;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class LeafGenerator extends LeafGeneratorBase {
+
+	/** Name of the default alpha mask to use */
+	public static String defaultMask = "default";
+	
+	public LeafGenerator() {
+		super("bf_leaves", "betterfoliage", "textures/blocks/%s/%s", "betterfoliage:textures/blocks/leafmask_%d_%s.png", BetterFoliageClient.missingTexture);
+	}
+
+	@Override
+	protected BufferedImage generateLeaf(ResourceLocation originalWithDirs) throws IOException, TextureGenerationException {
+		// load normal leaf texture
+		BufferedImage origImage = ImageIO.read(Minecraft.getMinecraft().getResourceManager().getResource(originalWithDirs).getInputStream());
+		if (origImage.getWidth() != origImage.getHeight()) throw new TextureGenerationException();
+		int size = origImage.getWidth();
+
+		// tile leaf texture 2x2
+		BufferedImage overlayIcon = new BufferedImage(size * 2, size * 2, BufferedImage.TYPE_4BYTE_ABGR);
+		Graphics2D graphics = overlayIcon.createGraphics();
+		graphics.drawImage(origImage, 0, 0, null);
+		graphics.drawImage(origImage, 0, size, null);
+		graphics.drawImage(origImage, size, 0, null);
+		graphics.drawImage(origImage, size, size, null);
+		
+		// overlay mask alpha on texture
+		if (!ShadersModIntegration.isSpecialTexture(originalWithDirs)) {
+			// load alpha mask of appropriate size
+			BufferedImage maskImage = loadLeafMaskImage(defaultMask, size * 2);
+			int scale = size * 2 / maskImage.getWidth();
+			
+			for (int x = 0; x < overlayIcon.getWidth(); x++) for (int y = 0; y < overlayIcon.getHeight(); y++) {
+				long origPixel = overlayIcon.getRGB(x, y) & 0xFFFFFFFFl;
+				long maskPixel = maskImage.getRGB(x / scale, y / scale) & 0xFF000000l | 0x00FFFFFF;
+				overlayIcon.setRGB(x, y, (int) (origPixel & maskPixel));
+			}
+		}
+		
+		return overlayIcon;
+	}
+	
+	@Override
+	@SubscribeEvent
+	public void endTextureReload(Post event) {
+		super.endTextureReload(event);
+		if (event.map.getTextureType() != 0) return;
+		BetterFoliage.log.info(String.format("Found %d pre-drawn leaf textures", drawnCounter));
+		BetterFoliage.log.info(String.format("Generated %d leaf textures", generatedCounter));
+	}
+}

src/main/java/mods/betterfoliage/client/resource/LeafGeneratorBase.java

@@ -0,0 +1,119 @@
+package mods.betterfoliage.client.resource;
+
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+import mods.betterfoliage.client.resource.LeafTextureEnumerator.LeafTextureFoundEvent;
+import mods.betterfoliage.common.util.Utils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.resources.IResource;
+import net.minecraft.client.resources.IResourceManager;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.event.TextureStitchEvent.Pre;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/** Texture generator base class for textures based on leaf blocks.
+ * Supports loading from resource packs instead of generating if available.
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public abstract class LeafGeneratorBase extends BlockTextureGenerator {
+
+	@SideOnly(Side.CLIENT)
+	public static class TextureGenerationException extends Exception {
+		private static final long serialVersionUID = 7339757761980002651L;
+	};
+	
+	/** Format string of pre-drawn texture location */
+	public String handDrawnLocationFormat;
+	
+	/** Format string of alpha mask location */
+	public String maskImageLocationFormat;
+	
+	/** Resource domain name of pre-drawn textures */
+	public String nonGeneratedDomain;
+	
+	/** Number of textures generated in the current run */
+	public int generatedCounter = 0;
+	
+	/** Number of pre-drawn textures found in the current run */
+	public int drawnCounter = 0;
+	
+	public LeafGeneratorBase(String domain, String nonGeneratedDomain, String handDrawnLocationFormat, String maskImageLocationFormat, ResourceLocation missingResource) {
+		super(domain, missingResource);
+		this.nonGeneratedDomain = nonGeneratedDomain;
+		this.handDrawnLocationFormat = handDrawnLocationFormat;
+		this.maskImageLocationFormat = maskImageLocationFormat;
+	}
+
+	@Override
+	public IResource getResource(ResourceLocation resourceLocation) throws IOException {
+		IResourceManager resourceManager = Minecraft.getMinecraft().getResourceManager();
+		ResourceLocation originalNoDirs = unwrapResource(resourceLocation);
+		ResourceLocation originalWithDirs = new ResourceLocation(originalNoDirs.getResourceDomain(), "textures/blocks/" + originalNoDirs.getResourcePath());
+		
+		// check for provided texture
+		ResourceLocation handDrawnLocation = new ResourceLocation(nonGeneratedDomain, String.format(handDrawnLocationFormat, originalNoDirs.getResourceDomain(), originalNoDirs.getResourcePath())); 
+		if (Utils.resourceExists(handDrawnLocation)) {
+			drawnCounter++;
+			return resourceManager.getResource(handDrawnLocation);
+		}
+		
+		// generate our own
+		if (!Utils.resourceExists(originalWithDirs)) return getMissingResource();
+		
+		BufferedImage result;
+		try {
+			result = generateLeaf(originalWithDirs);
+		} catch (TextureGenerationException e) {
+			return getMissingResource();
+		}
+		generatedCounter++;
+		return new BufferedImageResource(result);
+	}
+	
+	protected abstract BufferedImage generateLeaf(ResourceLocation originalWithDirs) throws IOException, TextureGenerationException;
+	
+	/** Loads the alpha mask of the given type and size. If a mask of the exact size can not be found,
+	 *  will try to load progressively smaller masks down to 16x16
+	 * @param type mask type
+	 * @param size texture size
+	 * @return alpha mask
+	 */
+	protected BufferedImage loadLeafMaskImage(String type, int size) {
+		IResourceManager resourceManager = Minecraft.getMinecraft().getResourceManager();
+		IResource maskResource = null;
+		
+		while (maskResource == null && size >= 1) {
+			try {
+				maskResource = resourceManager.getResource(new ResourceLocation(String.format(maskImageLocationFormat, size, type)));
+			} catch (Exception e) {}
+			size /= 2;
+		}
+		
+		try {
+			return maskResource == null ? null : ImageIO.read(maskResource.getInputStream());
+		} catch (IOException e) {
+			return null;
+		}
+	}
+	
+	@Override
+	@SubscribeEvent
+	public void handleTextureReload(Pre event) {
+		super.handleTextureReload(event);
+		if (event.map.getTextureType() != 0) return;
+		generatedCounter = 0;
+		drawnCounter = 0;
+	}
+
+	@SubscribeEvent
+	public void handleRegisterTexture(LeafTextureFoundEvent event) {
+		event.blockTextures.registerIcon(new ResourceLocation(domainName, event.icon.getIconName()).toString());
+	}
+
+}

src/main/java/mods/betterfoliage/client/resource/LeafParticleTextures.java

@@ -0,0 +1,93 @@
+package mods.betterfoliage.client.resource;
+
+import java.awt.Color;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.util.Map;
+
+import javax.imageio.ImageIO;
+
+import mods.betterfoliage.client.render.IconSet;
+import mods.betterfoliage.client.resource.LeafTextureEnumerator.LeafTextureFoundEvent;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.event.TextureStitchEvent;
+
+import com.google.common.collect.Maps;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/** Holds the texture for the falling leaf particles, and stores average texture color values for leaf textures
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public class LeafParticleTextures {
+
+	/** Icons for leaf particles */
+	public IconSet icons = new IconSet("betterfoliage", "falling_leaf_default_%d");
+	
+	/** Map of average color values */
+	public Map<IIcon, Integer> colors = Maps.newHashMap();
+	
+	/** Default color value */
+	public int defaultColor = 0x208040;
+	
+	public LeafParticleTextures(int defaultColor) {
+		this.defaultColor = defaultColor;
+	}
+	
+	public int getColor(IIcon icon) {
+		Integer result = colors.get(icon);
+		return result == null ? defaultColor : result;
+	}
+	
+	/** Calculate average color value (in HSB color space) for a texture and store it in the map.
+	 * @param icon texture
+	 */
+	protected void addAtlasTexture(TextureAtlasSprite icon) {
+		ResourceLocation locationNoDirs = new ResourceLocation(icon.getIconName());
+		ResourceLocation locationWithDirs = new ResourceLocation(locationNoDirs.getResourceDomain(), String.format("textures/blocks/%s.png", locationNoDirs.getResourcePath()));
+		try {
+			BufferedImage image = ImageIO.read(Minecraft.getMinecraft().getResourceManager().getResource(locationWithDirs).getInputStream());
+			
+			int numOpaque = 0;
+			float sumHueX = 0.0f;
+			float sumHueY = 0.0f;
+			float sumSaturation = 0.0f;
+			float sumBrightness = 0.0f;
+			for (int x = 0; x < image.getWidth(); x++) for (int y = 0; y < image.getHeight(); y++) {
+				int pixel = image.getRGB(x, y);
+				int alpha = (pixel >> 24) & 0xFF;
+				float[] hsbVals = Color.RGBtoHSB((pixel >> 16) & 0xFF, (pixel >> 8) & 0xFF, pixel & 0xFF, null);
+				if (alpha == 255) {
+					numOpaque++;
+					sumHueX += Math.cos((hsbVals[0] - 0.5) * 2.0 * Math.PI);
+					sumHueY += Math.sin((hsbVals[0] - 0.5) * 2.0 * Math.PI);
+					sumSaturation += hsbVals[1];
+					sumBrightness += hsbVals[2];
+				}
+			}
+			
+			// average hue as usual for circular values - transform average unit vector back to polar angle
+			float avgHue = (float) (Math.atan2(sumHueY, sumHueX) / (2.0 * Math.PI) + 0.5);
+			colors.put(icon, Color.HSBtoRGB(avgHue, sumSaturation / numOpaque, sumBrightness / numOpaque));
+		} catch (IOException e) {
+		}
+	}
+	
+	@SubscribeEvent
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		colors.clear();
+		icons.registerIcons(event.map);
+	}
+	
+	@SubscribeEvent
+	public void handleRegisterTexture(LeafTextureFoundEvent event) {
+		addAtlasTexture(event.icon);
+	}
+}

src/main/java/mods/betterfoliage/client/resource/LeafTextureEnumerator.java

@@ -0,0 +1,109 @@
+package mods.betterfoliage.client.resource;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.BetterFoliageClient;
+import mods.betterfoliage.common.config.Config;
+import mods.betterfoliage.common.util.Utils;
+import mods.betterfoliage.loader.DeobfHelper;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.util.IIcon;
+import net.minecraftforge.client.event.TextureStitchEvent;
+import net.minecraftforge.common.MinecraftForge;
+
+import com.google.common.collect.Sets;
+
+import cpw.mods.fml.common.eventhandler.Event;
+import cpw.mods.fml.common.eventhandler.EventPriority;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/** Enumerates all leaf textures at stitch time and emits an event for each.
+ * @author octarine-noise
+ */
+@SideOnly(Side.CLIENT)
+public class LeafTextureEnumerator implements IIconRegister {
+
+	/**{@link Event} that is emitted for each texture belonging to a leaf block.
+	 * @author octarine-noise
+	 */
+	@SideOnly(Side.CLIENT)
+	public static class LeafTextureFoundEvent extends Event {
+		
+		public TextureMap blockTextures;
+		public TextureAtlasSprite icon;
+		
+		private LeafTextureFoundEvent(TextureMap blockTextures, TextureAtlasSprite icon) {
+			super();
+			this.blockTextures = blockTextures;
+			this.icon = icon;
+		}
+	}
+	
+	/** Texture atlas for block textures used in the current run */
+	public TextureMap blockTextures;
+	
+	/** Leaf blocks register their textures here.
+	 *  @return the originally registered {@link IIcon} already in the atlas
+	 */
+	public IIcon registerIcon(String resourceLocation) {
+		TextureAtlasSprite original = blockTextures.getTextureExtry(resourceLocation);
+		MinecraftForge.EVENT_BUS.post(new LeafTextureFoundEvent(blockTextures, original));
+		BetterFoliage.log.debug(String.format("Found leaf texture: %s", resourceLocation));
+		return original;
+	}
+
+	/** Iterates through all leaf blocks in the registry and makes them register
+	 *  their textures to "sniff out" all leaf textures.
+	 * @param event
+	 */
+	@SubscribeEvent(priority=EventPriority.LOWEST)
+	@SuppressWarnings("unchecked")
+	public void handleTextureReload(TextureStitchEvent.Pre event) {
+		if (event.map.getTextureType() != 0) return;
+		blockTextures = event.map;
+		
+		BetterFoliage.log.info("Reloading leaf textures");
+		
+		// register simple block textures
+		Iterator<Block> iter = Block.blockRegistry.iterator();
+		while(iter.hasNext()) {
+			Block block = iter.next();
+			if (Config.leaves.matchesClass(block)) {
+				BetterFoliage.log.debug(String.format("Inspecting leaf block: %s", block.getClass().getName()));
+				block.registerBlockIcons(this);
+			}
+		}
+		
+		// enumerate all registered textures, find leaf textures among them
+		Map<String, TextureAtlasSprite> mapAtlas = null;
+		mapAtlas = Utils.getField(blockTextures, DeobfHelper.transformElementSearge("mapRegisteredSprites"), Map.class);
+		if (mapAtlas == null) mapAtlas = Utils.getField(blockTextures, "mapRegisteredSprites", Map.class);
+		
+		if (mapAtlas == null) {
+			BetterFoliage.log.warn("Failed to reflect texture atlas, textures may be missing");
+		} else {
+			Set<TextureAtlasSprite> foundLeafTextures = Sets.newHashSet();
+			for (TextureAtlasSprite icon : mapAtlas.values())
+				if (BetterFoliageClient.isLeafTexture(icon)) foundLeafTextures.add(icon);
+			for (TextureAtlasSprite icon : foundLeafTextures) {
+				BetterFoliage.log.debug(String.format("Found non-block-registered leaf texture: %s", icon.getIconName()));
+				MinecraftForge.EVENT_BUS.post(new LeafTextureFoundEvent(blockTextures, icon));
+			}
+		}
+	}
+	
+	@SubscribeEvent
+	public void endTextureReload(TextureStitchEvent.Post event) {
+		if (event.map.getTextureType() != 0) return;
+		blockTextures = null;
+	}
+	
+}

src/main/java/mods/betterfoliage/client/resource/ReedGenerator.java

@@ -0,0 +1,44 @@
+package mods.betterfoliage.client.resource;
+
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.resources.IResource;
+import net.minecraft.client.resources.IResourceManager;
+import net.minecraft.util.ResourceLocation;
+
+@SideOnly(Side.CLIENT)
+public class ReedGenerator extends BlockTextureGenerator {
+
+	public boolean isBottom;
+	
+	public ReedGenerator(String domainName, ResourceLocation missingResource, boolean isBottom) {
+		super(domainName, missingResource);
+		this.isBottom = isBottom;
+	}
+
+	@Override
+	public IResource getResource(ResourceLocation resourceLocation) throws IOException {
+		IResourceManager resourceManager = Minecraft.getMinecraft().getResourceManager();
+		ResourceLocation originalNoDirs = unwrapResource(resourceLocation);
+		ResourceLocation originalWithDirs = new ResourceLocation(originalNoDirs.getResourceDomain(), "textures/blocks/" + originalNoDirs.getResourcePath());
+		
+		// load full texture
+		BufferedImage origImage = ImageIO.read(resourceManager.getResource(originalWithDirs).getInputStream());
+
+		// draw half texture
+		BufferedImage result = new BufferedImage(origImage.getWidth(), origImage.getHeight() / 2, BufferedImage.TYPE_4BYTE_ABGR);
+		Graphics2D graphics = result.createGraphics();
+		graphics.drawImage(origImage, 0, isBottom ? -origImage.getHeight() / 2 : 0, null);
+		
+		return new BufferedImageResource(result);
+	}
+
+}

src/main/java/mods/betterfoliage/client/resource/ShortGrassGenerator.java

@@ -0,0 +1,56 @@
+package mods.betterfoliage.client.resource;
+
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import mods.betterfoliage.client.ShadersModIntegration;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.resources.IResource;
+import net.minecraft.client.resources.IResourceManager;
+import net.minecraft.util.ResourceLocation;
+
+@SideOnly(Side.CLIENT)
+public class ShortGrassGenerator extends BlockTextureGenerator {
+
+	protected boolean isSnowed = false;
+	
+	protected int snowOriginalWeight = 2;
+	
+	protected int snowWhiteWeight = 3;
+	
+	public ShortGrassGenerator(String domainName, ResourceLocation missingResource, boolean isSnowed) {
+		super(domainName, missingResource);
+		this.isSnowed = isSnowed;
+	}
+
+	@Override
+	public IResource getResource(ResourceLocation resourceLocation) throws IOException {
+		IResourceManager resourceManager = Minecraft.getMinecraft().getResourceManager();
+		ResourceLocation originalNoDirs = unwrapResource(resourceLocation);
+		ResourceLocation originalWithDirs = new ResourceLocation(originalNoDirs.getResourceDomain(), "textures/blocks/" + originalNoDirs.getResourcePath());
+		
+		// load full texture
+		BufferedImage origImage = ImageIO.read(resourceManager.getResource(originalWithDirs).getInputStream());
+
+		// draw bottom half of texture
+		BufferedImage result = new BufferedImage(origImage.getWidth(), origImage.getHeight(), BufferedImage.TYPE_4BYTE_ABGR);
+		Graphics2D graphics = result.createGraphics();
+		graphics.drawImage(origImage, 0, 3 * origImage.getHeight() / 8, null);
+
+		// blend with white if snowed
+		if (isSnowed && !ShadersModIntegration.isSpecialTexture(originalWithDirs)) {
+			for (int x = 0; x < result.getWidth(); x++) for (int y = 0; y < result.getHeight(); y++) {
+				result.setRGB(x, y, blendRGB(result.getRGB(x, y), 0xFFFFFF, 2, 3));
+			}
+		}
+		
+		return new BufferedImageResource(result);
+	}
+
+}

src/main/java/mods/betterfoliage/common/config/Config.java

@@ -0,0 +1,306 @@
+package mods.betterfoliage.common.config;
+
+import java.io.File;
+import java.util.List;
+
+import mods.betterfoliage.BetterFoliage;
+import mods.betterfoliage.client.BlockMatcher;
+import mods.betterfoliage.client.gui.AlternateTextBooleanEntry;
+import mods.betterfoliage.client.gui.BiomeListConfigEntry;
+import mods.betterfoliage.client.gui.NonVerboseArrayEntry;
+import mods.betterfoliage.common.util.Utils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraftforge.common.config.ConfigCategory;
+import net.minecraftforge.common.config.ConfigElement;
+import net.minecraftforge.common.config.Configuration;
+import net.minecraftforge.common.config.Property;
+
+import com.google.common.base.Function;
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.Lists;
+
+import cpw.mods.fml.client.config.IConfigElement;
+import cpw.mods.fml.client.event.ConfigChangedEvent;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+public class Config {
+
+	public enum Category {
+	    blockTypes, extraLeaves, shortGrass, cactus, lilypad, reed, algae, coral, fallingLeaves, connectedGrass;
+	}
+	
+	/** {@link Configuration} object bound to the config file */
+	public static Configuration rawConfig;
+	
+	// block matchers
+    public static BlockMatcher leaves = new BlockMatcher();
+    public static BlockMatcher crops = new BlockMatcher();
+    public static BlockMatcher dirt = new BlockMatcher();
+    public static BlockMatcher grass = new BlockMatcher();
+    
+	// extracted config values
+	public static boolean leavesEnabled;
+	public static boolean leavesSkew;
+	public static double leavesHOffset;
+	public static double leavesVOffset;
+	public static double leavesSize;
+	
+	public static boolean grassEnabled;
+	public static boolean grassUseGenerated;
+	public static double grassHOffset;
+	public static double grassHeightMin;
+	public static double grassHeightMax;
+	public static double grassSize;
+	
+	public static boolean cactusEnabled;
+	
+	public static boolean lilypadEnabled;
+	public static double lilypadHOffset;
+	public static int lilypadChance;
+	
+	public static boolean reedEnabled;
+	public static double reedHOffset;
+	public static double reedHeightMin;
+	public static double reedHeightMax;
+	public static int reedPopulation;
+	
+	public static boolean algaeEnabled;
+	public static double algaeHOffset;
+	public static double algaeSize;
+	public static double algaeHeightMin;
+	public static double algaeHeightMax;
+	public static int algaePopulation;
+	
+	public static boolean coralEnabled;
+	public static int coralPopulation;
+	public static int coralChance;
+	public static double coralVOffset;
+	public static double coralHOffset;
+	public static double coralCrustSize;
+	public static double coralSize;
+	
+	public static boolean leafFXEnabled;
+	public static double leafFXSpeed;
+	public static double leafFXWindStrength;
+	public static double leafFXStormStrength;
+	public static double leafFXSize;
+	public static double leafFXChance;
+	public static double leafFXPerturb;
+	public static double leafFXLifetime;
+	
+	public static boolean ctxGrassClassicEnabled;
+	public static boolean ctxGrassAggressiveEnabled;
+	
+	public static List<Integer> reedBiomeList = Lists.newArrayList();
+	public static List<Integer> algaeBiomeList = Lists.newArrayList();
+	public static List<Integer> coralBiomeList = Lists.newArrayList();
+	
+	/** Read the config file
+	 * @param configFile
+	 */
+	public static void readConfig(File configFile) {
+		rawConfig = new Configuration(configFile, true);
+		updateValues();
+		if (rawConfig.hasChanged()) rawConfig.save();
+	}
+	
+	/** Extract the config properties to static value fields for quick access */
+	public static void updateValues() {
+        leavesEnabled = getBoolean(Category.extraLeaves, "enabled", true, "betterfoliage.enabled");
+        leavesSkew = getBoolean(Category.extraLeaves, "skewMode", false, "betterfoliage.leavesMode");
+        leavesHOffset = getDouble(Category.extraLeaves, "hOffset", 0.2, 0.0, 0.4, "betterfoliage.hOffset");
+        leavesVOffset = getDouble(Category.extraLeaves, "vOffset", 0.1, 0.0, 0.4, "betterfoliage.vOffset");
+        leavesSize = getDouble(Category.extraLeaves, "size", 1.4, 0.75, 1.8, "betterfoliage.size");
+
+        grassEnabled = getBoolean(Category.shortGrass, "enabled", true, "betterfoliage.enabled");
+        grassHOffset = getDouble(Category.shortGrass, "hOffset", 0.2, 0.0, 0.4, "betterfoliage.hOffset");
+        grassHeightMin = getDouble(Category.shortGrass, "heightMin", 0.6, 0.1, 1.5, "betterfoliage.minHeight");
+        grassHeightMax = getDouble(Category.shortGrass, "heightMax", 0.8, 0.1, 1.5, "betterfoliage.maxHeight");
+        grassSize = getDouble(Category.shortGrass, "size", 1.0, 0.5, 1.5, "betterfoliage.size");
+        grassUseGenerated = getBoolean(Category.shortGrass, "useGenerated", false, "betterfoliage.shortGrass.useGenerated");
+        grassHeightMin = clampDoubleToMax(Category.shortGrass, "heightMin", "heightMax");
+
+        cactusEnabled = getBoolean(Category.cactus, "enabled", true, "betterfoliage.enabled");
+
+        lilypadEnabled = getBoolean(Category.lilypad, "enabled", true, "betterfoliage.enabled");
+        lilypadHOffset = getDouble(Category.lilypad, "hOffset", 0.1, 0.0, 0.25, "betterfoliage.hOffset");
+        lilypadChance = getInt(Category.lilypad, "flowerChance", 16, 0, 64, "betterfoliage.lilypad.flowerChance");
+
+        reedEnabled = getBoolean(Category.reed, "enabled", true, "betterfoliage.enabled");
+        reedHOffset = getDouble(Category.reed, "hOffset", 0.2, 0.0, 0.4, "betterfoliage.hOffset");
+        reedHeightMin = getDouble(Category.reed, "heightMin", 2.0, 1.5, 3.5, "betterfoliage.minHeight");
+        reedHeightMax = getDouble(Category.reed, "heightMax", 2.5, 1.5, 3.5, "betterfoliage.maxHeight");
+        reedPopulation = getInt(Category.reed, "population", 32, 0, 64, "betterfoliage.population");
+        reedHeightMin = clampDoubleToMax(Category.reed, "heightMin", "heightMax");
+        reedBiomeList = getIntList(Category.reed, "reedBiomeList", reedBiomeList, "betterfoliage.reed.biomeList");
+        
+        algaeEnabled = getBoolean(Category.algae, "enabled", true, "betterfoliage.enabled");
+        algaeHOffset = getDouble(Category.algae, "hOffset", 0.1, 0.0, 0.25, "betterfoliage.hOffset");
+        algaeSize = getDouble(Category.algae, "size", 1.0, 0.5, 1.5, "betterfoliage.size");
+        algaeHeightMin = getDouble(Category.algae, "heightMin", 0.5, 0.1, 1.5, "betterfoliage.minHeight");
+        algaeHeightMax = getDouble(Category.algae, "heightMax", 1.0, 0.1, 1.5, "betterfoliage.maxHeight");
+        algaePopulation = getInt(Category.algae, "population", 48, 0, 64, "betterfoliage.population");
+        algaeHeightMin = clampDoubleToMax(Category.algae, "heightMin", "heightMax");
+        algaeBiomeList = getIntList(Category.algae, "algaeBiomeList", algaeBiomeList, "betterfoliage.algae.biomeList");
+        
+        coralEnabled = getBoolean(Category.coral, "enabled", true, "betterfoliage.enabled");
+        coralHOffset = getDouble(Category.coral, "hOffset", 0.2, 0.0, 0.4, "betterfoliage.hOffset");
+        coralVOffset = getDouble(Category.coral, "vOffset", 0.1, 0.0, 0.4, "betterfoliage.vOffset");
+        coralSize = getDouble(Category.coral, "size", 0.7, 0.5, 1.5, "betterfoliage.coral.size");
+        coralCrustSize = getDouble(Category.coral, "crustSize", 1.4, 0.5, 1.5, "betterfoliage.coral.crustSize");
+        coralChance = getInt(Category.coral, "chance", 32, 0, 64, "betterfoliage.coral.chance");
+        coralPopulation = getInt(Category.coral, "population", 48, 0, 64, "betterfoliage.population");
+        coralBiomeList = getIntList(Category.coral, "coralBiomeList", coralBiomeList, "betterfoliage.coral.biomeList");
+        
+        leafFXEnabled = getBoolean(Category.fallingLeaves, "enabled", true, "betterfoliage.enabled");
+        leafFXSpeed = getDouble(Category.fallingLeaves, "speed", 0.05, 0.01, 0.15, "betterfoliage.fallingLeaves.speed");
+        leafFXWindStrength = getDouble(Category.fallingLeaves, "windStrength", 0.5, 0.1, 2.0, "betterfoliage.fallingLeaves.windStrength");
+        leafFXStormStrength = getDouble(Category.fallingLeaves, "stormStrength", 0.8, 0.1, 2.0, "betterfoliage.fallingLeaves.stormStrength");
+        leafFXSize = getDouble(Category.fallingLeaves, "size", 0.75, 0.25, 1.5, "betterfoliage.fallingLeaves.size");
+        leafFXChance = getDouble(Category.fallingLeaves, "chance", 0.05, 0.001, 1.0, "betterfoliage.fallingLeaves.chance");
+        leafFXPerturb = getDouble(Category.fallingLeaves, "perturb", 0.25, 0.01, 1.0, "betterfoliage.fallingLeaves.perturb");
+        leafFXLifetime = getDouble(Category.fallingLeaves, "lifetime", 5.0, 1.0, 15.0, "betterfoliage.fallingLeaves.lifetime");
+        
+        ctxGrassClassicEnabled = getBoolean(Category.connectedGrass, "classic", true, "betterfoliage.connectedGrass.classic");
+        ctxGrassAggressiveEnabled= getBoolean(Category.connectedGrass, "aggressive", true, "betterfoliage.connectedGrass.aggressive");
+		
+        updateBlockMatcher(dirt, Category.blockTypes, "dirtWhitelist", "betterfoliage.blockTypes.dirtWhitelist", "dirtBlacklist", "betterfoliage.blockTypes.dirtBlacklist", new ResourceLocation("betterfoliage:classesDirtDefault.cfg"));
+        updateBlockMatcher(grass, Category.blockTypes, "grassWhitelist", "betterfoliage.blockTypes.grassWhitelist", "grassBlacklist", "betterfoliage.blockTypes.grassBlacklist", new ResourceLocation("betterfoliage:classesGrassDefault.cfg"));
+        updateBlockMatcher(leaves, Category.blockTypes, "leavesWhitelist", "betterfoliage.blockTypes.leavesWhitelist", "leavesBlacklist", "betterfoliage.blockTypes.leavesBlacklist", new ResourceLocation("betterfoliage:classesLeavesDefault.cfg"));
+        updateBlockMatcher(crops, Category.blockTypes, "cropWhitelist", "betterfoliage.blockTypes.cropWhitelist", "cropBlacklist", "betterfoliage.blockTypes.cropBlacklist", new ResourceLocation("betterfoliage:classesCropDefault.cfg"));
+        
+        rawConfig.getCategory(Category.extraLeaves.toString()).get("skewMode").setConfigEntryClass(AlternateTextBooleanEntry.class);
+        rawConfig.getCategory(Category.reed.toString()).get("reedBiomeList").setConfigEntryClass(BiomeListConfigEntry.class);
+        rawConfig.getCategory(Category.algae.toString()).get("algaeBiomeList").setConfigEntryClass(BiomeListConfigEntry.class);
+        rawConfig.getCategory(Category.coral.toString()).get("coralBiomeList").setConfigEntryClass(BiomeListConfigEntry.class);
+        
+		for (Category category : Category.values()) rawConfig.setCategoryLanguageKey(category.toString(), String.format("betterfoliage.%s", category.toString()));
+		
+		setOrder(Category.extraLeaves, "enabled", "skewMode", "hOffset", "vOffset", "size");
+		setOrder(Category.shortGrass, "enabled", "useGenerated", "hOffset", "heightMin", "heightMax", "size");
+		setOrder(Category.lilypad, "enabled", "hOffset", "flowerChance");
+		setOrder(Category.reed, "enabled", "hOffset", "heightMin", "heightMax", "population", "biomeList");
+		setOrder(Category.algae, "enabled", "hOffset", "heightMin", "heightMax", "population");
+		setOrder(Category.coral, "enabled", "hOffset", "vOffset", "size", "crustSize", "population", "chance");
+		setOrder(Category.fallingLeaves, "enabled", "size", "chance", "lifetime", "speed", "windStrength", "stormStrength", "perturb");
+		setOrder(Category.connectedGrass, "classic", "aggressive");
+	}
+	
+	public static void getDefaultBiomes() {
+	    for (BiomeGenBase biome : BiomeGenBase.getBiomeGenArray()) {
+	        if (biome == null) continue;
+	        if (Utils.biomeTempRainFilter(0.4f, null, 0.4f, null).apply(biome)) {
+	            reedBiomeList.add(biome.biomeID);
+	            BiomeListConfigEntry.reedBiomeList.add(biome);
+	        }
+	        if (Utils.biomeClassNameFilter("river", "ocean").apply(biome)) {
+	            algaeBiomeList.add(biome.biomeID);
+	            BiomeListConfigEntry.algaeBiomeList.add(biome);
+	        }
+	        if (Utils.biomeClassNameFilter("river", "ocean", "beach").apply(biome)) {
+	            coralBiomeList.add(biome.biomeID);
+                BiomeListConfigEntry.coralBiomeList.add(biome);
+            }
+	    }
+	}
+	
+	protected static List<Integer> getFilteredBiomeIds(List<BiomeGenBase> biomes, Predicate<BiomeGenBase> filter) {
+	    return Lists.newArrayList(Collections2.transform(
+	        Collections2.filter(biomes, filter),
+	        new Function<BiomeGenBase, Integer>() {
+	            public Integer apply(BiomeGenBase input) {
+	                return input.biomeID;
+	            }
+            }
+	    ));
+	}
+	
+	@SuppressWarnings("rawtypes")
+	public static List<IConfigElement> getConfigRootElements() {
+		List<IConfigElement> result = Lists.newLinkedList();
+		for (Category category : Category.values()) {
+			ConfigElement<?> element = new ConfigElement(rawConfig.getCategory(category.toString()));
+			result.add(element);
+		}
+		return result;
+	}
+	
+	protected static double getDouble(Category category, String key, double defaultValue, double min, double max, String langKey) {
+		Property prop = rawConfig.get(category.toString(), key, defaultValue);
+		prop.setMinValue(min);
+		prop.setMaxValue(max);
+		prop.setLanguageKey(langKey);
+		return prop.getDouble();
+	}
+	
+    protected static double clampDoubleToMax(Category category, String keySmaller, String keyLarger) {
+        ConfigCategory cfgCat = rawConfig.getCategory(category.toString());
+        Property smaller = cfgCat.get(keySmaller);
+        Property larger = cfgCat.get(keyLarger);
+        if (smaller.getDouble() > larger.getDouble()) smaller.set(larger.getDouble());
+        return smaller.getDouble();
+    }
+	   
+	protected static int getInt(Category category, String key, int defaultValue, int min, int max, String langKey) {
+		Property prop = rawConfig.get(category.toString(), key, defaultValue);
+		prop.setMinValue(min);
+		prop.setMaxValue(max);
+		prop.setLanguageKey(langKey);
+		return prop.getInt();
+	}
+	
+	protected static List<Integer> getIntList(Category category, String key, List<Integer> defaultList, String langKey) {
+	    int[] defaults = new int[]{};
+	    if (defaultList != null) {
+	        defaults = new int[defaultList.size()];
+	        int idx = 0;
+	        for (Integer value : defaultList) defaults[idx++] = value;
+	    }
+	    
+	    Property prop = rawConfig.get(category.toString(), key, defaults);
+	    prop.setLanguageKey(langKey);
+	    
+	    int[] values = prop.getIntList();
+	    List<Integer> result = Lists.newArrayListWithCapacity(values.length);
+	    for (int value : values) result.add(value);
+	    return result;
+	}
+	    
+    protected static boolean getBoolean(Category category, String key, boolean defaultValue, String langKey) {
+        Property prop = rawConfig.get(category.toString(), key, defaultValue);
+        prop.setLanguageKey(langKey);
+        return prop.getBoolean();
+    }
+    
+	protected static void updateBlockMatcher(BlockMatcher bm, Category category, String whitelistKey, String whitelistLangKey, String blacklistKey, String blacklistLangKey, ResourceLocation defaults) {
+        List<String> defaultWhitelist = Lists.newLinkedList();
+        List<String> defaultBlacklist = Lists.newLinkedList();
+        BlockMatcher.loadDefaultLists(defaults, defaultBlacklist, defaultWhitelist);
+        
+        Property whitelist = rawConfig.get(category.toString(), whitelistKey, defaultWhitelist.toArray(new String[]{}));
+        Property blacklist = rawConfig.get(category.toString(), blacklistKey, defaultBlacklist.toArray(new String[]{}));
+        
+        whitelist.setLanguageKey(whitelistLangKey);
+        blacklist.setLanguageKey(blacklistLangKey);
+	    whitelist.setConfigEntryClass(NonVerboseArrayEntry.class);
+	    blacklist.setConfigEntryClass(NonVerboseArrayEntry.class);
+	    
+	    bm.updateClassLists(whitelist.getStringList(), blacklist.getStringList());
+	}
+	
+	protected static void setOrder(Category category, String... properties) {
+		rawConfig.setCategoryPropertyOrder(category.toString(), Lists.newArrayList(properties));
+	}
+
+	@SubscribeEvent
+	public void handleConfigChange(ConfigChangedEvent.OnConfigChangedEvent event) {
+	    if (event.modID.equals(BetterFoliage.MOD_ID)) {
+	        updateValues();
+	        if (rawConfig.hasChanged()) rawConfig.save();
+	        Minecraft.getMinecraft().renderGlobal.loadRenderers();
+	    }
+	}
+}

src/main/java/mods/betterfoliage/common/util/Double3.java

@@ -0,0 +1,49 @@
+package mods.betterfoliage.common.util;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+/** Immutable 3D vector of double precision.
+ * @author octarine-noise
+ */
+public class Double3 {
+
+	public final double x;
+	public final double y;
+	public final double z;
+	
+	public Double3(double x, double y, double z) {
+		this.x = x;
+		this.y = y;
+		this.z = z;
+	}
+	
+	public Double3(ForgeDirection dir) {
+		this.x = dir.offsetX;
+		this.y = dir.offsetY;
+		this.z = dir.offsetZ;
+	}
+	
+	public Double3 add(Double3 other) {
+		return new Double3(x + other.x, y + other.y, z + other.z);
+	}
+	
+	public Double3 sub(Double3 other) {
+		return new Double3(x - other.x, y - other.y, z - other.z);
+	}
+	
+	public Double3 add(double x, double y, double z) {
+		return new Double3(this.x + x, this.y + y, this.z + z);
+	}
+	
+	public Double3 scaleAxes(double sx, double sy, double sz) {
+		return new Double3(x * sx, y * sy, z * sz);
+	}
+	
+	public Double3 scale(double s) {
+		return new Double3(x * s, y * s, z * s);
+	}
+	
+	public Double3 inverse() {
+		return new Double3(-x, -y, -z);
+	}
+}

src/main/java/mods/betterfoliage/common/util/OffsetBlockAccess.java

@@ -0,0 +1,100 @@
+package mods.betterfoliage.common.util;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.Vec3Pool;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraftforge.common.util.ForgeDirection;
+
+/** {@link IBlockAccess} wrapper that applies an offset for a single target coordinate for all rendering-related methods.
+ * Returns normal values for all other coordinates.
+ * @author octarine-noise
+ *
+ */
+public class OffsetBlockAccess implements IBlockAccess {
+
+	public IBlockAccess source;
+	public int xTarget, yTarget, zTarget;
+	public int xOffset, yOffset, zOffset;
+
+	public OffsetBlockAccess(IBlockAccess source, int x, int y, int z, int xOffset, int yOffset, int zOffset) {
+		this.source = source;
+		this.xTarget = x;
+		this.yTarget = y;
+		this.zTarget = z;
+		this.xOffset = xOffset;
+		this.yOffset = yOffset;
+		this.zOffset = zOffset;
+	}
+
+	public Block getBlock(int x, int y, int z) {
+		if (x == xTarget && y == yTarget && z == zTarget)
+			return source.getBlock(x + xOffset, y + yOffset, z + zOffset);
+		else
+			return source.getBlock(x, y, z);
+	}
+
+	public TileEntity getTileEntity(int x, int y, int z) {
+		if (x == xTarget && y == yTarget && z == zTarget)
+			return source.getTileEntity(x + xOffset, y + yOffset, z + zOffset);
+		else
+			return source.getTileEntity(x, y, z);
+	}
+
+	@SideOnly(Side.CLIENT)
+	public int getLightBrightnessForSkyBlocks(int x, int y, int z, int min) {
+		if (x == xTarget && y == yTarget && z == zTarget)
+			return source.getLightBrightnessForSkyBlocks(x + xOffset, y + yOffset, z + zOffset, min);
+		else 
+			return source.getLightBrightnessForSkyBlocks(x, y, z, min);
+	}
+
+	public int getBlockMetadata(int x, int y, int z) {
+		if (x == xTarget && y == yTarget && z == zTarget)
+			return source.getBlockMetadata(x + xOffset, y + yOffset, z + zOffset);
+		else
+			return source.getBlockMetadata(x, y, z);
+	}
+
+	public boolean isAirBlock(int x, int y, int z) {
+		if (x == xTarget && y == yTarget && z == zTarget)
+			return source.isAirBlock(x + xOffset, y + yOffset, z + zOffset);
+		else
+			return source.isAirBlock(x, y, z);
+	}
+
+	@SideOnly(Side.CLIENT)
+	public BiomeGenBase getBiomeGenForCoords(int x, int z) {
+		return source.getBiomeGenForCoords(x, z);
+	}
+
+	@SideOnly(Side.CLIENT)
+	public int getHeight() {
+		return source.getHeight();
+	}
+
+	@SideOnly(Side.CLIENT)
+	public boolean extendedLevelsInChunkCache() {
+		return source.extendedLevelsInChunkCache();
+	}
+
+	@Deprecated
+	public Vec3Pool getWorldVec3Pool() {
+		return source.getWorldVec3Pool();
+	}
+
+	public int isBlockProvidingPowerTo(int x, int y, int z, int dir) {
+		return source.isBlockProvidingPowerTo(x, y, z, dir);
+	}
+
+	public boolean isSideSolid(int x, int y, int z, ForgeDirection side, boolean _default) {
+		if (x == xTarget && y == yTarget && z == zTarget)
+			return source.isSideSolid(x + xOffset, y + yOffset, z + zOffset, side, _default);
+		else
+			return source.isSideSolid(x, y, z, side, _default);
+	}
+
+}

src/main/java/mods/betterfoliage/common/util/Utils.java

@@ -0,0 +1,157 @@
+package mods.betterfoliage.common.util;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.Field;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import mods.betterfoliage.loader.DeobfHelper;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.resources.IResource;
+import net.minecraft.client.resources.IResourceManager;
+import net.minecraft.client.resources.SimpleReloadableResourceManager;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.biome.BiomeGenBase;
+
+import com.google.common.base.Charsets;
+import com.google.common.base.Predicate;
+
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+
+public class Utils {
+
+	/** Hide constructor */
+	private Utils() {}
+	
+	/** 
+	 * @return (({@link SimpleReloadableResourceManager}) Minecraft.getMinecraft().getResourceManager()).domainResourceManagers
+	 */
+	@SuppressWarnings("unchecked")
+	public static Map<String, IResourceManager> getDomainResourceManagers() {
+		IResourceManager manager = Minecraft.getMinecraft().getResourceManager();
+		Map<String, IResourceManager> result = getField(manager, DeobfHelper.transformElementSearge("domainResourceManagers"), Map.class);
+		if (result == null) result = getField(manager, "domainResourceManagers", Map.class);
+		return result;
+	}
+	
+	@SuppressWarnings("unchecked")
+	public static <T> T getField(Object target, String fieldName, Class<T> resultClass) {
+		try {
+			Field field = target.getClass().getDeclaredField(fieldName);
+			field.setAccessible(true);
+			return (T) field.get(target);
+		} catch (Exception e) {
+			return null;
+		}
+	}
+	
+	@SuppressWarnings("unchecked")
+	public static <T> T getStaticField(Class<?> clazz, String fieldName, Class<T> resultClass) {
+		try {
+			Field field = clazz.getDeclaredField(fieldName);
+			field.setAccessible(true);
+			return (T) field.get(null);
+		} catch (Exception e) {
+			return null;
+		}
+	}
+	
+	/** Retrieve a specific rendering handler from the registry
+	 * @param renderType render type of block
+	 * @return {@link ISimpleBlockRenderingHandler} if defined, null otherwise
+	 */
+	@SuppressWarnings("unchecked")
+	public static ISimpleBlockRenderingHandler getRenderingHandler(int renderType) {
+		try {
+			Field field = RenderingRegistry.class.getDeclaredField("INSTANCE");
+			field.setAccessible(true);
+			RenderingRegistry inst = (RenderingRegistry) field.get(null);
+			field = RenderingRegistry.class.getDeclaredField("blockRenderers");
+			field.setAccessible(true);
+			return ((Map<Integer, ISimpleBlockRenderingHandler>) field.get(inst)).get(renderType);
+		} catch (Exception e) {
+			return null;
+		}
+	}
+	
+	/** Check for the existence of a {@link IResource}
+	 * @param resourceLocation
+	 * @return true if the resource exists
+	 */
+	public static boolean resourceExists(ResourceLocation resourceLocation) {
+		try {
+			IResource resource = Minecraft.getMinecraft().getResourceManager().getResource(resourceLocation);
+			if (resource != null) return true;
+		} catch (IOException e) {
+		}
+		return false;
+	}
+	
+	/** Copy a text file from a resource to the filesystem 
+	 * @param resourceLocation resource location of text file
+	 * @param target target file
+	 * @throws IOException 
+	 */
+	public static void copyFromTextResource(ResourceLocation resourceLocation, File target) throws IOException {
+		IResource defaults = Minecraft.getMinecraft().getResourceManager().getResource(resourceLocation);
+		BufferedReader reader = new BufferedReader(new InputStreamReader(defaults.getInputStream(), Charsets.UTF_8));
+		FileWriter writer = new FileWriter(target);
+		
+		String line = reader.readLine();
+		while(line != null) {
+			writer.write(line + System.lineSeparator());
+			line = reader.readLine();
+		}
+		
+		reader.close();
+		writer.close();
+	}
+	
+	public static void stripTooltipDefaultText(List<String> tooltip) {
+        boolean defaultRows = false;
+        Iterator<String> iter = tooltip.iterator();
+        while(iter.hasNext()) {
+            if (iter.next().startsWith(EnumChatFormatting.AQUA.toString())) defaultRows = true;
+            if (defaultRows) iter.remove();
+        }
+	}
+	
+	public static Predicate<BiomeGenBase> biomeTempRainFilter(final Float minTemp, final Float maxTemp, final Float minRain, final Float maxRain) {
+	    return new Predicate<BiomeGenBase>() {
+	        public boolean apply(BiomeGenBase biome) {
+	            if (minTemp != null && biome.temperature < minTemp) return false;
+	            if (maxTemp != null && biome.temperature > maxTemp) return false;
+                if (minRain != null && biome.rainfall < minRain) return false;
+                if (maxRain != null && biome.rainfall > maxRain) return false;
+                return true;
+	        }
+        };
+	}
+	
+	public static Predicate<BiomeGenBase> biomeClassFilter(final Class<?>... classList) {
+	    return new Predicate<BiomeGenBase>() {
+            public boolean apply(BiomeGenBase biome) {
+                for (Class<?> clazz : classList)
+                    if (clazz.isAssignableFrom(biome.getClass()) || clazz.equals(biome.getClass()))
+                        return true;
+                return false;
+            }
+	    };
+	}
+	
+	public static Predicate<BiomeGenBase> biomeClassNameFilter(final String... names) {
+	    return new Predicate<BiomeGenBase>() {
+            public boolean apply(BiomeGenBase biome) {
+                for (String name : names) if (biome.getClass().getName().toLowerCase().contains(name.toLowerCase())) return true;
+                return false;
+            }
+	    };
+	}
+}

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

@@ -0,0 +1,29 @@
+package mods.betterfoliage.loader;
+
+import java.util.Map;
+
+import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
+
+@IFMLLoadingPlugin.TransformerExclusions({"mods.betterfoliage.loader"})
+public class BetterFoliageLoader implements IFMLLoadingPlugin {
+
+	public String[] getASMTransformerClass() {
+		return new String[] {"mods.betterfoliage.loader.BetterFoliageTransformer"};
+	}
+
+	public String getModContainerClass() {
+		return null;
+	}
+
+	public String getSetupClass() {
+		return null;
+	}
+
+	public void injectData(Map<String, Object> data) {
+	}
+
+	public String getAccessTransformerClass() {
+		return null;
+	}
+
+}

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

@@ -0,0 +1,79 @@
+package mods.betterfoliage.loader;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import com.google.common.collect.ImmutableList;
+
+import cpw.mods.fml.relauncher.FMLInjectionData;
+
+public class BetterFoliageTransformer implements IClassTransformer {
+
+	protected Iterable<MethodTransformerBase> transformers = ImmutableList.<MethodTransformerBase>of(
+		new TransformRenderBlockOverride(),
+		new TransformShaderModBlockOverride(),
+		new TransformRandomDisplayTick()
+	);
+	
+	protected Logger logger = LogManager.getLogger(getClass().getSimpleName());
+	
+	public BetterFoliageTransformer() {
+		String mcVersion = FMLInjectionData.data()[4].toString();
+		if (!ImmutableList.<String>of("1.7.2", "1.7.10").contains(mcVersion))
+		logger.warn(String.format("Unsupported Minecraft version %s", mcVersion));
+		
+		DeobfHelper.init();
+	}
+	
+	@Override
+	public byte[] transform(String name, String transformedName, byte[] basicClass) {
+		// ???
+		if (basicClass == null) return null;
+		
+		// read class
+		ClassNode classNode = new ClassNode();
+        ClassReader classReader = new ClassReader(basicClass);
+        classReader.accept(classNode, 0);
+        boolean hasTransformed = false;
+        
+        for (MethodTransformerBase transformer : transformers) {
+        	// try to find specified method in class
+			if (!transformedName.equals(transformer.getClassName())) continue;
+			
+			logger.debug(String.format("Found class: %s -> %s", name, transformedName));
+			for (MethodNode methodNode : classNode.methods) {
+				logger.trace(String.format("Checking method: %s, sig: %s", methodNode.name, methodNode.desc));
+				Boolean isObfuscated = null;
+				if (methodNode.name.equals(DeobfHelper.transformElementName(transformer.getMethodName())) && methodNode.desc.equals(DeobfHelper.transformSignature(transformer.getSignature()))) {
+					isObfuscated = true;
+				} else if (methodNode.name.equals(transformer.getMethodName()) && methodNode.desc.equals(transformer.getSignature())) {
+					isObfuscated = false;
+				}
+				
+				if (isObfuscated != null) {
+					// transform
+					hasTransformed = true;
+					try {
+						transformer.transform(methodNode, isObfuscated);
+						logger.info(String.format("%s: SUCCESS", transformer.getLogMessage()));
+					} catch (Exception e) {
+						logger.info(String.format("%s: FAILURE", transformer.getLogMessage()));
+					}
+					break;
+				}
+			}
+        }
+        
+        // return result
+ 		ClassWriter writer = new ClassWriter(0);
+ 		if (hasTransformed) classNode.accept(writer);
+ 		return !hasTransformed ? basicClass : writer.toByteArray();
+	}
+
+}

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

@@ -0,0 +1,84 @@
+package mods.betterfoliage.loader;
+
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+
+import cpw.mods.fml.relauncher.FMLInjectionData;
+
+public class DeobfHelper {
+
+	private static Map<String, String> obfClasses = Maps.newHashMap();
+	private static Map<String, String> obfElements = Maps.newHashMap();
+	private static Map<String, String> srgElements = Maps.newHashMap();
+	
+	public static void init() {
+		String mcVersion = FMLInjectionData.data()[4].toString();
+		srgElements.put("domainResourceManagers", "field_110548_a");
+		srgElements.put("mapRegisteredSprites", "field_110574_e");
+		if ("1.7.2".equals(mcVersion)) {
+			obfClasses.put("net/minecraft/client/renderer/RenderBlocks", "ble");
+			obfClasses.put("net/minecraft/world/IBlockAccess", "afx");
+			obfClasses.put("net/minecraft/block/Block", "ahu");
+			obfClasses.put("net/minecraft/client/multiplayer/WorldClient", "biz");
+			obfClasses.put("net/minecraft/world/World", "afn");
+			
+			obfElements.put("blockAccess", "a");
+			obfElements.put("renderBlockByRenderType", "b");
+			obfElements.put("mapRegisteredSprites", "bpr");
+			obfElements.put("doVoidFogParticles", "C");
+		} else if ("1.7.10".equals(mcVersion)) {
+			obfClasses.put("net/minecraft/client/renderer/RenderBlocks", "blm");
+			obfClasses.put("net/minecraft/world/IBlockAccess", "ahl");
+			obfClasses.put("net/minecraft/block/Block", "aji");
+			obfClasses.put("net/minecraft/client/multiplayer/WorldClient", "bjf");
+			obfClasses.put("net/minecraft/world/World", "ahb");
+			
+			obfElements.put("blockAccess", "a");
+			obfElements.put("renderBlockByRenderType", "b");
+			obfElements.put("mapRegisteredSprites", "bpr");
+			obfElements.put("doVoidFogParticles", "C");
+		}
+	}
+	
+	/** Transform a class name from MCP to obfuscated names.
+	 * @param className MCP name
+	 * @return obfuscated name
+	 */
+	public static String transformClassName(String className) {
+		return obfClasses.containsKey(className) ? obfClasses.get(className) : className;
+	}
+	
+	/** Transform a method or field name from MCP to obfuscated names.
+	 * @param elementName MCP name
+	 * @return obfuscated name
+	 */
+	public static String transformElementName(String elementName) {
+		return obfElements.containsKey(elementName) ? obfElements.get(elementName) : elementName;
+	}
+	
+	/** Transform a method or field name from MCP to SRG names.
+	 * @param elementName MCP name
+	 * @return SRG name
+	 */
+	public static String transformElementSearge(String elementName) {
+		return srgElements.containsKey(elementName) ? srgElements.get(elementName) : elementName;
+	}
+	
+	/** Transform an ASM signature from MCP to obfuscated names.
+	 * @param signature MCP signature
+	 * @return obfuscated signature
+	 */
+	public static String transformSignature(String signature) {
+		String result = signature;
+		boolean hasChanged = false;
+		do {
+			hasChanged = false;
+			for (Map.Entry<String, String> entry : obfClasses.entrySet()) if (result.contains("L" + entry.getKey() + ";")) {
+				result = result.replace("L" + entry.getKey() + ";", "L" + entry.getValue() + ";");
+				hasChanged = true;
+			}
+		} while(hasChanged);
+		return result;
+	}
+}

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

@@ -0,0 +1,144 @@
+package mods.betterfoliage.loader;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+
+/** Base class for class transformers operating on a single method.
+ * @author octarine-noise
+ */
+public abstract class MethodTransformerBase {
+
+	/** Instruction node filter
+	 * @author octarine-noise
+	 */
+	public static interface IInstructionMatch {
+		public boolean matches(AbstractInsnNode node);
+	}
+	
+	/**
+	 * @return MCP name of the class to transform
+	 */
+	public abstract String getClassName();
+	
+	/**
+	 * @return MCP name of the method to transform
+	 */
+	public abstract String getMethodName();
+	
+	/**
+	 * @return ASM signature of the method to transform using MCP names
+	 */
+	public abstract String getSignature();
+	
+	/**
+	 * @return Log message to write when method is found
+	 */
+	public abstract String getLogMessage();
+	
+	/** Transform method node
+	 * @param method method node
+	 * @param isObfuscated true for obfuscated environment
+	 */
+	public abstract void transform(MethodNode method, boolean isObfuscated);
+	
+	/** Transform a class name from MCP to obfuscated names if necessary.
+	 * @param className MCP name
+	 * @param isObfuscated true for obfuscated environment
+	 * @return transformed name
+	 */
+	protected static String className(String className, boolean isObfuscated) {
+		return isObfuscated ? DeobfHelper.transformClassName(className) : className;
+	}
+	
+	/** Transform a method or field name from MCP to obfuscated names if necessary.
+	 * @param fieldName MCP name
+	 * @param isObfuscated true for obfuscated environment
+	 * @return transformed name
+	 */
+	protected static String element(String fieldName, boolean isObfuscated) {
+		return isObfuscated ? DeobfHelper.transformElementName(fieldName) : fieldName;
+	}
+	
+	/** Transform an ASM signature from MCP to obfuscated names if necessary.
+	 * @param signature MCP signature
+	 * @param isObfuscated true for obfuscated environment
+	 * @return transformed signature
+	 */
+	protected static String signature(String signature, boolean isObfuscated) {
+		return isObfuscated ? DeobfHelper.transformSignature(signature) : signature;
+	}
+	
+	/** Find the next instruction node in an instruction list starting from a given node, matching a given filter
+	 * @param start start node
+	 * @param match filter
+	 * @return instruction node if found, null otherwise
+	 */
+	protected AbstractInsnNode findNext(AbstractInsnNode start, IInstructionMatch match) {
+		AbstractInsnNode current = start;
+		while(current != null) {
+			if (match.matches(current)) break;
+			current = current.getNext();
+		}
+		return current;
+	}
+	
+	/** Find the previous instruction node in a list starting from a given node, matching a given filter
+	 * @param start start node
+	 * @param match filter
+	 * @return instruction node if found, null otherwise
+	 */
+	protected AbstractInsnNode findPrevious(AbstractInsnNode start, IInstructionMatch match) {
+		AbstractInsnNode current = start;
+		while(current != null) {
+			if (match.matches(current)) break;
+			current = current.getPrevious();
+		}
+		return current;
+	}
+	
+	/**
+	 * @return an instruction node filter matching any invoke instruction
+	 */
+	protected IInstructionMatch matchInvokeAny() {
+		return new IInstructionMatch() {
+			public boolean matches(AbstractInsnNode node) {
+				return node instanceof MethodInsnNode;
+			}
+		};
+	}
+	
+	/**
+	 * @return an instruction node filter matching the given opcode
+	 */
+	protected IInstructionMatch matchOpcode(final int opcode) {
+		return new IInstructionMatch() {
+			public boolean matches(AbstractInsnNode node) {
+				return node.getOpcode() == opcode;
+			}
+		};
+	}
+	
+	/** Insert a list of instruction nodes in a list after a given node
+	 * @param insnList instruction list
+	 * @param node start node
+	 * @param added instructions to add
+	 */
+	protected void insertAfter(InsnList insnList, AbstractInsnNode node, AbstractInsnNode... added) {
+		InsnList listAdd = new InsnList();
+		for (AbstractInsnNode inst : added) listAdd.add(inst);
+		insnList.insert(node, listAdd);
+	}
+	
+	/** Insert a list of instruction nodes in a list before a given node
+	 * @param insnList instruction list
+	 * @param node start node
+	 * @param added instructions to add
+	 */
+	protected void insertBefore(InsnList insnList, AbstractInsnNode node, AbstractInsnNode... added) {
+		InsnList listAdd = new InsnList();
+		for (AbstractInsnNode inst : added) listAdd.add(inst);
+		insnList.insertBefore(node, listAdd);
+	}
+}

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

@@ -0,0 +1,43 @@
+package mods.betterfoliage.loader;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+public class TransformRandomDisplayTick extends MethodTransformerBase {
+
+	@Override
+	public String getClassName() {
+		return "net.minecraft.client.multiplayer.WorldClient";
+	}
+
+	@Override
+	public String getMethodName() {
+		return "doVoidFogParticles";
+	}
+
+	@Override
+	public String getSignature() {
+		return "(III)V";
+	}
+
+	@Override
+	public String getLogMessage() {
+		return "Applying random display tick call hook";
+	}
+
+	@Override
+	public void transform(MethodNode method, boolean obf) {
+		AbstractInsnNode endLoop = findNext(method.instructions.getFirst(), matchOpcode(Opcodes.IINC));
+		insertBefore(method.instructions, endLoop,
+			new VarInsnNode(Opcodes.ALOAD, 10),
+			new VarInsnNode(Opcodes.ALOAD, 0),
+			new VarInsnNode(Opcodes.ILOAD, 7),
+			new VarInsnNode(Opcodes.ILOAD, 8),
+			new VarInsnNode(Opcodes.ILOAD, 9),
+			new MethodInsnNode(Opcodes.INVOKESTATIC, "mods/betterfoliage/client/BetterFoliageClient", "onRandomDisplayTick", signature("(Lnet/minecraft/block/Block;Lnet/minecraft/world/World;III)V", obf))
+		);
+	}
+}

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

@@ -0,0 +1,49 @@
+package mods.betterfoliage.loader;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+public class TransformRenderBlockOverride extends MethodTransformerBase {
+
+	@Override
+	public String getClassName() {
+		return "net.minecraft.client.renderer.RenderBlocks";
+	}
+
+	@Override
+	public String getMethodName() {
+		return "renderBlockByRenderType";
+	}
+
+	@Override
+	public String getSignature() {
+		return "(Lnet/minecraft/block/Block;III)Z";
+	}
+
+	@Override
+	public String getLogMessage() {
+		return "Applying RenderBlocks.renderBlockByRenderType() render type override";
+	}
+
+	@Override
+	public void transform(MethodNode method, boolean obf) {
+		AbstractInsnNode invokeGetRenderType = findNext(method.instructions.getFirst(), matchInvokeAny());
+		AbstractInsnNode storeRenderType = findNext(invokeGetRenderType, matchOpcode(Opcodes.ISTORE));
+		insertAfter(method.instructions, storeRenderType,
+			new VarInsnNode(Opcodes.ALOAD, 0),
+			new FieldInsnNode(Opcodes.GETFIELD, className("net/minecraft/client/renderer/RenderBlocks", obf), element("blockAccess", obf), signature("Lnet/minecraft/world/IBlockAccess;", obf)),
+			new VarInsnNode(Opcodes.ILOAD, 2),
+			new VarInsnNode(Opcodes.ILOAD, 3),
+			new VarInsnNode(Opcodes.ILOAD, 4),
+			new VarInsnNode(Opcodes.ALOAD, 1),
+			new VarInsnNode(Opcodes.ILOAD, 5),
+			new MethodInsnNode(Opcodes.INVOKESTATIC, "mods/betterfoliage/client/BetterFoliageClient", "getRenderTypeOverride", signature("(Lnet/minecraft/world/IBlockAccess;IIILnet/minecraft/block/Block;I)I", obf)),
+			new VarInsnNode(Opcodes.ISTORE, 5)
+		);
+	}
+
+}

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

@@ -0,0 +1,40 @@
+package mods.betterfoliage.loader;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+public class TransformShaderModBlockOverride extends MethodTransformerBase {
+
+	@Override
+	public String getClassName() {
+		return "shadersmodcore.client.Shaders";
+	}
+
+	@Override
+	public String getMethodName() {
+		return "pushEntity";
+	}
+
+	@Override
+	public String getSignature() {
+		return "(Lnet/minecraft/client/renderer/RenderBlocks;Lnet/minecraft/block/Block;III)V";
+	}
+
+	@Override
+	public String getLogMessage() {
+		return "Applying Shaders.pushEntity() block id override";
+	}
+
+	@Override
+	public void transform(MethodNode method, boolean obf) {
+		AbstractInsnNode arrayStore = findNext(method.instructions.getFirst(), matchOpcode(Opcodes.IASTORE));
+		insertAfter(method.instructions, arrayStore.getPrevious(),
+			new VarInsnNode(Opcodes.ALOAD, 1),
+			new MethodInsnNode(Opcodes.INVOKESTATIC, "mods/betterfoliage/client/ShadersModIntegration", "getBlockIdOverride", signature("(ILnet/minecraft/block/Block;)I", obf))
+		);
+	}
+
+}

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

@@ -1,33 +0,0 @@
-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;shouldSideBeRendered(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

@@ -1,41 +0,0 @@
-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.ILightReader;
-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/ILightReader;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/ILightReader;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/ILightReader;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, ILightReader 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, ILightReader 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

@@ -1,27 +0,0 @@
-package mods.betterfoliage.mixin;
-
-import mods.betterfoliage.Hooks;
-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.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-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(BlockState.class)
-@SuppressWarnings({"deprecation"})
-public class MixinBlockState {
-    private static final String callFrom = "Lnet/minecraft/block/BlockState;getAmbientOcclusionLightValue(Lnet/minecraft/world/IBlockReader;Lnet/minecraft/util/math/BlockPos;)F";
-    private static final String callTo = "Lnet/minecraft/block/Block;getAmbientOcclusionLightValue(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.getAmbientOcclusionLightValue(state, reader, pos), state);
-    }
-}

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

@@ -1,44 +0,0 @@
-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;animateTick(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;notifyBlockUpdate(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;notifyBlockUpdate(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, 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.notifyBlockUpdate(world, pos, oldState, newState, flags);
-    }
-}

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

@@ -1,44 +0,0 @@
-package mods.betterfoliage.mixin;
-
-import com.mojang.blaze3d.matrix.MatrixStack;
-import mods.betterfoliage.render.pipeline.RenderCtxForge;
-import mods.betterfoliage.model.SpecialRenderModel;
-import net.minecraft.block.BlockState;
-import net.minecraft.client.renderer.model.IBakedModel;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.ILightReader;
-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 = "renderModelFlat(Lnet/minecraft/world/ILightReader;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 = "renderModelSmooth(Lnet/minecraft/world/ILightReader;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/ILightReader;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,
-            ILightReader 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

@@ -1,65 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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;endStartSection(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;bakeModel(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.endStartSection("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<Material, TextureAtlasSprite> spriteGetter,
-            IModelTransform transform,
-            ResourceLocation locationIn
-    ) {
-        return BakeWrapperManager.INSTANCE.onBake(unbaked, bakery, spriteGetter, transform, locationIn);
-    }
-}

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

@@ -1,38 +0,0 @@
-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/kotlin/mods/betterfoliage/BetterFoliage.kt

@@ -1,100 +0,0 @@
-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 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)
-        (Minecraft.getInstance().resourceManager as IReloadableResourceManager).addReloadListener(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,40 +0,0 @@
-package mods.betterfoliage
-
-import mods.betterfoliage.config.BlockConfig
-import mods.betterfoliage.config.Config
-import net.alexwells.kottle.FMLKotlinModLoadingContext
-import net.minecraft.client.Minecraft
-import net.minecraftforge.fml.ModLoadingContext
-import net.minecraftforge.fml.common.Mod
-import net.minecraftforge.fml.config.ModConfig
-import org.apache.logging.log4j.Level
-import org.apache.logging.log4j.LogManager
-import org.apache.logging.log4j.simple.SimpleLogger
-import org.apache.logging.log4j.util.PropertiesUtil
-import java.io.File
-import java.io.PrintStream
-import java.util.Properties
-
-@Mod(BetterFoliageMod.MOD_ID)
-object BetterFoliageMod {
-    const val MOD_ID = "betterfoliage"
-
-    val bus = FMLKotlinModLoadingContext.get().modEventBus
-
-    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 {
-        ModLoadingContext.get().registerConfig(ModConfig.Type.CLIENT, Config.build())
-        Minecraft.getInstance().resourcePackList.addPackFinder(BetterFoliage.generatedPack.finder)
-        bus.register(BlockConfig)
-        BetterFoliage.init()
-    }
-}

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

@@ -1,97 +0,0 @@
-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.IBlockReader
-import net.minecraft.world.ILightReader
-import net.minecraftforge.client.model.pipeline.BlockInfo
-import net.minecraftforge.client.model.pipeline.VertexLighterFlat
-import java.util.*
-
-// 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<ILightReader>("net.minecraft.world.ILightReader")
-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 Shaders : ClassRef<Any>("net.optifine.shaders.Shaders") {
-    val shaderPackLoaded = FieldRef(this, "shaderPackLoaded", boolean)
-    val blockLightLevel05 = FieldRef(this, "blockLightLevel05", float)
-    val blockLightLevel06 = FieldRef(this, "blockLightLevel06", float)
-    val blockLightLevel08 = FieldRef(this, "blockLightLevel08", float)
-}
-
-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

@@ -1,8 +0,0 @@
-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

@@ -1,76 +0,0 @@
-@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.IBlockReader
-import net.minecraft.world.ILightReader
-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: World, pos: BlockPos, random: Random) {
-    if (Config.enabled &&
-        Config.risingSoul.enabled &&
-        state.block == Blocks.SOUL_SAND &&
-        world.isAirBlock(pos.offset(UP)) &&
-        Math.random() < Config.risingSoul.chance) {
-            RisingSoulParticle(world, pos).addIfValid()
-    }
-
-    if (Config.enabled &&
-        Config.fallingLeaves.enabled &&
-        random.nextDouble() < Config.fallingLeaves.chance &&
-        world.isAirBlock(pos.offset(DOWN))
-    ) {
-        (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.offset(face)).let { neighbor -> BetterFoliage.blockTypes.hasTyped<RoundLogKey>(neighbor) }
-
-fun getActualRenderModel(world: ILightReader, pos: BlockPos, state: BlockState, random: Random): SpecialRenderModel? {
-    val model = Minecraft.getInstance().blockRendererDispatcher.blockModelShapes.getModel(state) as? SpecialRenderModel
-        ?: return null
-    if (model is WeightedModelWrapper) {
-        random.setSeed(state.getPositionRandom(pos))
-        return model.getModel(random).model
-    }
-    return model
-}

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

@@ -1,61 +0,0 @@
-package mods.betterfoliage.chunk
-
-import mods.betterfoliage.util.Int3
-import mods.betterfoliage.util.allDirections
-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.ILightReader
-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: ILightReader
-    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)?.world?.getBiome(pos)
-
-    val isNormalCube: Boolean get() = state.isNormalCube(world, pos)
-
-    fun isNeighborSolid(dir: Direction) = offset(dir).let { it.state.isSolidSide(it.world, it.pos, dir.opposite) }
-
-    fun shouldSideBeRendered(side: Direction) = Block.shouldSideBeRendered(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.getBlockColor(pos, resolver)
-}
-
-class BasicBlockCtx(
-    override val world: ILightReader,
-    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

@@ -1,124 +0,0 @@
-package mods.betterfoliage.chunk
-
-import mods.octarinecore.ChunkCacheOF
-import mods.betterfoliage.util.get
-import mods.betterfoliage.util.isInstance
-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.ILightReader
-import net.minecraft.world.IWorldReader
-import net.minecraft.world.dimension.DimensionType
-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.List
-import kotlin.collections.MutableMap
-import kotlin.collections.associateWith
-import kotlin.collections.forEach
-import kotlin.collections.mutableListOf
-import kotlin.collections.mutableMapOf
-import kotlin.collections.set
-
-val ILightReader.dimType: DimensionType get() = when {
-    this is IWorldReader -> dimension.type
-    this is ChunkRenderCache -> world.dimension.type
-    this.isInstance(ChunkCacheOF) -> this[ChunkCacheOF.chunkCache].world.dimension.type
-    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: ILightReader, 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/config/Config.kt

@@ -1,179 +0,0 @@
-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 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

@@ -1,89 +0,0 @@
-@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

@@ -1,18 +0,0 @@
-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.SNOW_BLOCK, Material.SNOW)
-val BlockState.isSnow: Boolean get() = material in SNOW_MATERIALS

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

@@ -1,54 +0,0 @@
-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().gameSettings.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

@@ -1,95 +0,0 @@
-package mods.betterfoliage.integration
-
-import mods.betterfoliage.render.pipeline.RenderCtxBase
-import mods.betterfoliage.render.pipeline.RenderCtxVanilla
-import mods.betterfoliage.resource.discovery.BakeWrapperManager
-import mods.betterfoliage.util.HasLogger
-import mods.betterfoliage.util.allAvailable
-import mods.betterfoliage.util.get
-import mods.betterfoliage.util.mapArray
-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.Direction
-import net.minecraft.util.Direction.DOWN
-import net.minecraft.util.Direction.EAST
-import net.minecraft.util.Direction.NORTH
-import net.minecraft.util.Direction.SOUTH
-import net.minecraft.util.Direction.WEST
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.ILightReader
-import net.minecraftforge.client.model.pipeline.LightUtil
-import org.apache.logging.log4j.Level.INFO
-
-/**
- * Integration for ShadersMod.
- */
-object ShadersModIntegration : HasLogger() {
-    @JvmStatic val isEffectsAvailable = allAvailable(SVertexBuilder.pushState, SVertexBuilder.popState, BlockAliases.getAliasBlockId)
-    @JvmStatic val isDiffuseAvailable = allAvailable(Shaders.shaderPackLoaded, Shaders.blockLightLevel05, Shaders.blockLightLevel06, Shaders.blockLightLevel08)
-
-    @JvmStatic val defaultLeaves = Blocks.OAK_LEAVES.defaultState!!
-    @JvmStatic val defaultGrass = Blocks.GRASS.defaultState!!
-
-    @JvmStatic var diffuseShades = Direction.values().mapArray { LightUtil.diffuseLight(it) }
-
-    /**
-     * Called from transformed ShadersMod code.
-     * @see mods.betterfoliage.loader.BetterFoliageTransformer
-     */
-    @JvmStatic fun getBlockStateOverride(state: BlockState, world: ILightReader, 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 diffuse shading integration is ${if (isDiffuseAvailable) "enabled" else "disabled" }")
-        logger.log(INFO, "ShadersMod vertex shader integration is ${if (isEffectsAvailable) "enabled" else "disabled" }")
-
-        // Recalculate the diffsuse shading values used when resources are reloaded
-        if (isDiffuseAvailable) BakeWrapperManager.onInvalidate {
-            if (Shaders.shaderPackLoaded.getStatic()) {
-                diffuseShades = Direction.values().mapArray { face ->
-                    when(face) {
-                        DOWN -> Shaders.blockLightLevel05.getStatic()
-                        WEST, EAST -> Shaders.blockLightLevel06.getStatic()
-                        NORTH, SOUTH -> Shaders.blockLightLevel08.getStatic()
-                        else -> LightUtil.diffuseLight(face)
-                    }
-                }
-            } else {
-                diffuseShades = Direction.values().mapArray { LightUtil.diffuseLight(it) }
-            }
-        }
-    }
-
-    /** 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 (isEffectsAvailable && 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/model/HalfBaked.kt

@@ -1,118 +0,0 @@
-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.minU + (quad.sprite.maxU - quad.sprite.minU) * (vertex.uv.u + 0.5).toFloat(),
-                    quad.sprite.minV + (quad.sprite.maxV - quad.sprite.minV) * (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(vertexData[vIdx * size + 0]) - 0.5f
-        val y = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 1]) - 0.5f
-        val z = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 2]) - 0.5f
-        val color = vertexData[vIdx * size + 3]
-        val u = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 4])
-        val v = java.lang.Float.intBitsToFloat(vertexData[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 (hasTintIndex()) tintIndex else -1,
-        face = face
-    )
-    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

@@ -1,207 +0,0 @@
-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

@@ -1,34 +0,0 @@
-package mods.betterfoliage.model
-
-import mods.betterfoliage.render.pipeline.RenderCtxBase
-import mods.betterfoliage.util.HasLogger
-import net.minecraft.client.renderer.model.IBakedModel
-import net.minecraft.client.renderer.model.Material
-import net.minecraft.client.renderer.model.ModelBakery
-import net.minecraft.client.renderer.model.VariantList
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.util.ResourceLocation
-import net.minecraft.util.WeightedRandom
-import org.apache.logging.log4j.Level.WARN
-import java.util.Random
-import java.util.function.Function
-
-/**
- * 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.itemWeight }
-
-    fun getModel(random: Random) = WeightedRandom.getRandomItem(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

@@ -1,83 +0,0 @@
-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.textureLocation != 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

@@ -1,108 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,119 +0,0 @@
-package mods.betterfoliage.render.block.vanilla
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.config.Config
-import mods.betterfoliage.config.DIRT_BLOCKS
-import mods.betterfoliage.config.SALTWATER_BIOMES
-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.render.pipeline.RenderCtxVanilla
-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.Blocks
-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
-import net.minecraft.world.biome.Biome
-
-object StandardDirtDiscovery : AbstractModelDiscovery() {
-    fun canRenderInLayer(layer: RenderType) = when {
-        !Config.enabled -> layer == RenderType.getSolid()
-        !Config.connectedGrass.enabled && !Config.algae.enabled && !Config.reed.enabled -> layer == RenderType.getSolid()
-        else -> layer == RenderType.getCutoutMipped()
-    }
-
-    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
-        if (isConnectedGrass) {
-            (ctx.blockModelShapes.getModel(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 && ctx.offset(Int3(2 to UP)).state.material == Material.WATER
-        val isShallowWater = isWater && ctx.offset(Int3(2 to UP)).state.isAir
-        val isSaltWater = isWater && ctx.biome?.category 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

@@ -1,118 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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.getCutout())
-        }
-        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

@@ -1,81 +0,0 @@
-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.getSolid()
-        !Config.netherrack.enabled -> layer == RenderType.getSolid()
-        else -> layer == RenderType.getCutoutMipped()
-    }
-
-    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

@@ -1,95 +0,0 @@
-package mods.betterfoliage.render.block.vanilla
-
-import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.config.BlockConfig
-import mods.betterfoliage.config.Config
-import mods.betterfoliage.resource.discovery.ModelTextureList
-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.util.Atlas
-import mods.betterfoliage.util.LazyMapInvalidatable
-import mods.betterfoliage.util.tryDefault
-import net.minecraft.block.BlockState
-import net.minecraft.block.LogBlock
-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")
-        ctx.addReplacement(StandardRoundLogKey(axis, textureMatch[0], textureMatch[1]))
-    }
-
-    fun getAxis(state: BlockState): Axis? {
-        val axis = tryDefault(null) { state.get(LogBlock.AXIS).toString() } ?:
-        state.values.entries.find { it.key.getName().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

@@ -1,107 +0,0 @@
-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.getCutoutMipped())
-        }
-        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?.category !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

@@ -1,166 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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,195 +0,0 @@
-package mods.betterfoliage.render.column
-
-import mods.betterfoliage.chunk.BlockCtx
-import mods.betterfoliage.chunk.ChunkOverlayLayer
-import mods.betterfoliage.chunk.ChunkOverlayManager
-import mods.betterfoliage.chunk.dimType
-import mods.betterfoliage.config.Config
-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.BlockType.SOLID
-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.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.ILightReader
-
-/** Index of SOUTH-EAST quadrant. */
-const val SE = 0
-/** Index of NORTH-EAST quadrant. */
-const val NE = 1
-/** Index of NORTH-WEST quadrant. */
-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
- */
-sealed class ColumnLayerData {
-    /**
-     * Data structure to cache texture and world neighborhood data relevant to column rendering
-     */
-    @Suppress("ArrayInDataClass") // not used in comparisons anywhere
-    data class SpecialRender(
-        val column: ColumnBlockKey,
-        val upType: BlockType,
-        val downType: BlockType,
-        val quadrants: Array<QuadrantType>,
-        val quadrantsTop: Array<QuadrantType>,
-        val quadrantsBottom: Array<QuadrantType>
-    ) : ColumnLayerData() {
-        enum class BlockType { SOLID, NONSOLID, PARALLEL, PERPENDICULAR }
-        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 */
-    object SkipRender : ColumnLayerData()
-
-    /** Column block must be rendered normally */
-    object NormalRender : ColumnLayerData()
-
-    /** Error while resolving render data, column block must be rendered normally */
-    object ResolveError : ColumnLayerData()
-}
-
-abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {
-
-    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: ILightReader, pos: BlockPos) {
-        allNeighborOffsets.forEach { offset -> ChunkOverlayManager.clear(world.dimType, this, pos + offset) }
-    }
-
-    override fun calculate(ctx: BlockCtx): ColumnLayerData {
-        // TODO detect round logs
-        if (allDirections.all { dir -> ctx.offset(dir).let { it.isNormalCube } }) return ColumnLayerData.SkipRender
-        val columnTextures = getColumnKey(ctx.state) ?: 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) Axis.Y else return ColumnLayerData.NormalRender
-
-        // check log neighborhood
-        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))
-
-        val quadrants = Array(4) { SMALL_RADIUS }.checkNeighbors(ctx, baseRotation, logAxis, 0)
-        val quadrantsTop = Array(4) { SMALL_RADIUS }
-        if (upType == PARALLEL) quadrantsTop.checkNeighbors(ctx, baseRotation, logAxis, 1)
-        val quadrantsBottom = Array(4) { SMALL_RADIUS }
-        if (downType == PARALLEL) quadrantsBottom.checkNeighbors(ctx, baseRotation, logAxis, -1)
-        return ColumnLayerData.SpecialRender(columnTextures, upType, downType, quadrants, quadrantsTop, quadrantsBottom)
-    }
-
-    /** Sets the type of the given quadrant only if the new value is "stronger" (larger ordinal). */
-    inline fun Array<QuadrantType>.upgrade(idx: Int, value: QuadrantType) {
-        if (this[idx].ordinal < value.ordinal) this[idx] = value
-    }
-
-    /** Fill the array of [QuadrantType]s based on the blocks to the sides of this one. */
-    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))
-        val blkW = ctx.blockType(rotation, logAxis, Int3(-1, yOff, 0))
-
-        // a solid block on one side will make the 2 neighboring quadrants SQUARE
-        // if there are solid blocks to both sides of a quadrant, it is INVISIBLE
-        if (connectSolids) {
-            if (blkS == SOLID) {
-                upgrade(SW, SQUARE); upgrade(SE, SQUARE)
-            }
-            if (blkE == SOLID) {
-                upgrade(SE, SQUARE); upgrade(NE, SQUARE)
-            }
-            if (blkN == SOLID) {
-                upgrade(NE, SQUARE); upgrade(NW, SQUARE)
-            }
-            if (blkW == SOLID) {
-                upgrade(NW, SQUARE); upgrade(SW, SQUARE)
-            }
-            if (blkS == SOLID && blkE == SOLID) upgrade(SE, INVISIBLE)
-            if (blkN == SOLID && blkE == SOLID) upgrade(NE, INVISIBLE)
-            if (blkN == SOLID && blkW == SOLID) upgrade(NW, INVISIBLE)
-            if (blkS == SOLID && blkW == SOLID) upgrade(SW, INVISIBLE)
-        }
-        val blkSE = ctx.blockType(rotation, logAxis, Int3(1, yOff, 1))
-        val blkNE = ctx.blockType(rotation, logAxis, Int3(1, yOff, -1))
-        val blkNW = ctx.blockType(rotation, logAxis, Int3(-1, yOff, -1))
-        val blkSW = ctx.blockType(rotation, logAxis, Int3(-1, yOff, 1))
-
-        if (lenientConnect) {
-            // if the block forms the tip of an L-shape, connect to its neighbor with SQUARE quadrants
-            if (blkE == PARALLEL && (blkSE == PARALLEL || blkNE == PARALLEL)) {
-                upgrade(SE, SQUARE); upgrade(NE, SQUARE)
-            }
-            if (blkN == PARALLEL && (blkNE == PARALLEL || blkNW == PARALLEL)) {
-                upgrade(NE, SQUARE); upgrade(NW, SQUARE)
-            }
-            if (blkW == PARALLEL && (blkNW == PARALLEL || blkSW == PARALLEL)) {
-                upgrade(NW, SQUARE); upgrade(SW, SQUARE)
-            }
-            if (blkS == PARALLEL && (blkSE == PARALLEL || blkSW == PARALLEL)) {
-                upgrade(SW, SQUARE); upgrade(SE, SQUARE)
-            }
-        }
-
-        // if the block forms the middle of an L-shape, or is part of a 2x2 configuration,
-        // connect to its neighbors with SQUARE quadrants, INVISIBLE on the inner corner, and LARGE_RADIUS on the outer corner
-        if (blkN == PARALLEL && blkW == PARALLEL && (lenientConnect || blkNW == PARALLEL)) {
-            upgrade(SE, LARGE_RADIUS); upgrade(NE, SQUARE); upgrade(SW, SQUARE); upgrade(NW, INVISIBLE)
-        }
-        if (blkS == PARALLEL && blkW == PARALLEL && (lenientConnect || blkSW == PARALLEL)) {
-            upgrade(NE, LARGE_RADIUS); upgrade(SE, SQUARE); upgrade(NW, SQUARE); upgrade(SW, INVISIBLE)
-        }
-        if (blkS == PARALLEL && blkE == PARALLEL && (lenientConnect || blkSE == PARALLEL)) {
-            upgrade(NW, LARGE_RADIUS); upgrade(NE, SQUARE); upgrade(SW, SQUARE); upgrade(SE, INVISIBLE)
-        }
-        if (blkN == PARALLEL && blkE == PARALLEL && (lenientConnect || blkNE == PARALLEL)) {
-            upgrade(SW, LARGE_RADIUS); upgrade(SE, SQUARE); upgrade(NW, SQUARE); upgrade(NE, INVISIBLE)
-        }
-        return this
-    }
-
-    /**
-     * Get the type of the block at the given offset in a rotated reference frame.
-     */
-    fun BlockCtx.blockType(rotation: Rotation, axis: Axis, offset: Int3): ColumnLayerData.SpecialRender.BlockType {
-        val offsetRot = offset.rotate(rotation)
-        val key = getColumnKey(state(offsetRot))
-        return if (key == null) {
-            if (offset(offsetRot).isNormalCube) SOLID else NONSOLID
-        } else {
-            (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

@@ -1,138 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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.ILightReader
-
-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 }
-    }
-}
-
-// Vanilla has a very suspicious-looking offset here, which Indigo gets rid of and calls it a fix
-// Naturally, we're going to believe Indigo, it's a hardcoded option for now
-const val OCCLUSION_OFFSET_FIX = true
-
-/**
- * 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: ILightReader
-
-    /** [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_COMBINED_LIGHT.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).isCollisionShapeOpaque(world, blockPos)
-
-        val lightOrigin = if (isFullBlock) lightPos.offset(lightFace) else lightPos
-
-        // AO calculation for the face center
-        probe.position { setPos(lightOrigin) }.writeTo(centerAo)
-        if (!isFullBlock && !probe.position { move(lightFace) }.state.isOpaqueCube(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 { setPos(lightOrigin).move(sideDir) }.writeTo(sideAo[sideIdx])
-            // side is considered occluded if the block 1 step to that side is not fully transparent
-            if (!OCCLUSION_OFFSET_FIX) probe.position { move(lightFace) }
-            isOccluded[sideIdx] = probe.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 {
-                    setPos(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.getPackedLight(state, world, pos)
-        val colorMultiplier: Float get() = cache.getBrightness(state, world, pos)
-        val isNonTransparent: Boolean get() = state.getOpacity(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

@@ -1,210 +0,0 @@
-package mods.betterfoliage.render.lighting
-
-import mods.betterfoliage.integration.ShadersModIntegration
-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.get
-import mods.betterfoliage.util.minBy
-import net.minecraft.client.renderer.color.BlockColors
-import net.minecraft.util.Direction
-import net.minecraft.util.Direction.*
-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 = ShadersModIntegration.diffuseShades[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.shouldApplyDiffuseLighting()) 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

@@ -1,101 +0,0 @@
-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.Vector3f
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.util.math.MathHelper
-import net.minecraft.world.World
-
-abstract class AbstractParticle(world: World, 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(posX, posY, posZ)
-        prevPos.setTo(prevPosX, prevPosY, prevPosZ)
-        velocity.setTo(motionX, motionY, motionZ)
-        update()
-        posX = currentPos.x; posY = currentPos.y; posZ = currentPos.z;
-        motionX = velocity.x; motionY = velocity.y; motionZ = 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().particles.addEffect(this) }
-
-    override fun renderParticle(vertexBuilder: IVertexBuilder, camera: ActiveRenderInfo, tickDelta: Float) {
-        super.renderParticle(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 = particleScale.toDouble(),
-                           currentAngle: Float = this.particleAngle,
-                           prevAngle: Float = this.prevParticleAngle,
-                           sprite: TextureAtlasSprite = this.sprite,
-                           alpha: Float = this.particleAlpha) {
-
-        val center = Double3.lerp(tickDelta.toDouble(), prevPos, currentPos)
-        val angle = MathHelper.lerp(tickDelta, prevAngle, currentAngle)
-        val rotation = camera.rotation.copy().apply { multiply(Vector3f.ZP.rotation(angle)) }
-        val lightmapCoord = getBrightnessForRender(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.projectedView.x, camera.projectedView.y, camera.projectedView.z) }
-
-        fun renderVertex(vertex: Double3, u: Float, v: Float) = vertexConsumer
-            .pos(vertex.x, vertex.y, vertex.z).tex(u, v)
-            .color(particleRed, particleGreen, particleBlue, alpha).lightmap(lightmapCoord)
-            .endVertex()
-
-        renderVertex(coords[0], sprite.maxU, sprite.maxV)
-        renderVertex(coords[1], sprite.maxU, sprite.minV)
-        renderVertex(coords[2], sprite.minU, sprite.minV)
-        renderVertex(coords[3], sprite.minU, sprite.maxV)
-    }
-
-    fun setColor(color: Int) {
-        particleBlue = (color and 255) / 256.0f
-        particleGreen = ((color shr 8) and 255) / 256.0f
-        particleRed = ((color shr 16) and 255) / 256.0f
-    }
-}
-

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

@@ -1,112 +0,0 @@
-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.Minecraft
-import net.minecraft.client.particle.IParticleRenderType
-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.event.world.WorldEvent
-import net.minecraftforge.eventbus.api.SubscribeEvent
-import java.util.Random
-import kotlin.math.abs
-import kotlin.math.cos
-import kotlin.math.sin
-
-class FallingLeafParticle(
-    world: World, 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 {
-        particleAngle = random.randomF(max = PI2)
-        prevParticleAngle = particleAngle - rotationSpeed
-
-        maxAge = MathHelper.floor(randomD(0.6, 1.0) * Config.fallingLeaves.lifetime * 20.0)
-        motionY = -Config.fallingLeaves.speed
-
-        particleScale = 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 (rand.nextFloat() > 0.95f) rotationSpeed *= -1.0f
-        if (age > maxAge - 20) particleAlpha = 0.05f * (maxAge - age)
-
-        if (onGround || wasCollided) {
-            velocity.setTo(0.0, 0.0, 0.0)
-            if (!wasCollided) {
-                age = age.coerceAtLeast(maxAge - 20)
-                wasCollided = true
-            }
-        } else {
-            val cosRotation = cos(particleAngle).toDouble(); val sinRotation = sin(particleAngle).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)
-            prevParticleAngle = particleAngle
-            particleAngle += 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.worldInfo.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.ClientTickEvent) {
-        if (event.phase == TickEvent.Phase.START) Minecraft.getInstance().world?.let { world ->
-            // change target wind speed
-            if (world.worldInfo.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.isRemote) changeWind(event.world.world) }
-}