Update README: Add fix details for texture rendering adjustments

# Conflicts:
#	src/main/resources/assets/betterfoliage/crop_default.cfg
#	src/main/resources/assets/betterfoliage/leaves_blocks_default.cfg

.classpath

@@ -1,8 +0,0 @@
-<?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,5 +1,9 @@
+.idea/
+*.iml
+*.ipr
+*.iws
+run/
 .gradle/
-.settings/
-bin/
 build/
-libs/
+classes/
+temp/

.project

@@ -1,18 +0,0 @@
-<?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,9 +1,7 @@
 BetterFoliage
 =============
+
 Minecraft mod that alters the appearance of leaves & grass
 
-More info: http://www.minecraftforum.net/topic/2776217-better-foliage/
-
-Download
-========
-[BetterFoliage 0.9.7-beta] (http://goo.gl/xNVloR) (MC 1.7.2 & 1.7.10)
+fixed by @CatmanGames for StateMC<br>
+(don't render certain textures when there is a block from another mod above)

build.gradle

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

gradle.properties

@@ -0,0 +1,13 @@
+group = com.github.octarine-noise
+jarName = BetterFoliage-MC1.12
+
+version = 2.3.1
+
+mc_version = 1.12.2
+forge_version = 14.23.5.2847
+mcp_mappings = stable_39
+
+kotlin_version = 1.3.40
+forgelin_version = 1.8.4
+
+org.gradle.java.home=C:\\Users\\catma\\.jdks\\corretto-1.8.0_482

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -0,0 +1,172 @@
+#!/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

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

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

src/main/java/mods/betterfoliage/BetterFoliage.java

@@ -1,48 +0,0 @@
-package mods.betterfoliage;
-
-import java.io.File;
-import java.util.Map;
-
-import mods.betterfoliage.client.BetterFoliageClient;
-import mods.betterfoliage.common.config.BetterFoliageConfig;
-
-import org.apache.logging.log4j.Logger;
-
-import cpw.mods.fml.common.Mod;
-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 BetterFoliageConfig config = new BetterFoliageConfig();
-	
-	public static Logger log;
-	
-	public static File configDir;
-	
-	@Mod.EventHandler
-	public void preInit(FMLPreInitializationEvent event)  {
-		log = event.getModLog();
-		if (event.getSide() == Side.CLIENT) {
-			configDir = new File(event.getModConfigurationDirectory(), MOD_ID);
-			configDir.mkdir();
-			config.load(new File(configDir, "betterfoliage.cfg"));
-			BetterFoliageClient.preInit();
-		}
-	}
-	
-	@NetworkCheckHandler
-	public boolean checkVersion(Map<String, String> mods, Side side) {
-		return true;
-	}
-}

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

@@ -1,96 +0,0 @@
-package mods.betterfoliage.client;
-
-import java.io.File;
-import java.util.Map;
-
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.client.render.IRenderBlockDecorator;
-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.RenderBlockBetterReed;
-import mods.betterfoliage.client.resource.LeafGenerator;
-import mods.betterfoliage.client.resource.LeafTextureEnumerator;
-import mods.betterfoliage.client.resource.ReedGenerator;
-import mods.betterfoliage.client.resource.ShortGrassGenerator;
-import net.minecraft.block.Block;
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.util.ResourceLocation;
-import net.minecraft.world.IBlockAccess;
-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 Map<Integer, IRenderBlockDecorator> decorators = Maps.newHashMap();
-	public static LeafGenerator leafGenerator;
-	
-	public static BlockMatcher leaves = new BlockMatcher();
-	public static BlockMatcher crops = new BlockMatcher();
-	
-	public static ResourceLocation missingTexture = new ResourceLocation("betterfoliage", "textures/blocks/missing_leaf.png");
-	
-	public static void preInit() {
-		FMLCommonHandler.instance().bus().register(new KeyHandler());
-		
-		BetterFoliage.log.info("Registering renderers");
-		registerRenderer(new RenderBlockBetterLeaves());
-		registerRenderer(new RenderBlockBetterGrass());
-		registerRenderer(new RenderBlockBetterCactus());
-		registerRenderer(new RenderBlockBetterLilypad());
-		registerRenderer(new RenderBlockBetterReed());
-		registerRenderer(new RenderBlockBetterAlgae());
-		registerRenderer(new RenderBlockBetterCoral());
-		
-		leaves.load(new File(BetterFoliage.configDir, "classesLeaves.cfg"), new ResourceLocation("betterfoliage:classesLeavesDefault.cfg"));
-		MinecraftForge.EVENT_BUS.register(leaves);
-		
-		crops.load(new File(BetterFoliage.configDir, "classesCrops.cfg"), new ResourceLocation("betterfoliage:classesCropsDefault.cfg"));
-		MinecraftForge.EVENT_BUS.register(crops);
-		
-		MinecraftForge.EVENT_BUS.register(new LeafTextureEnumerator("bf_leaves"));
-		
-		BetterFoliage.log.info("Registering texture generators");
-		leafGenerator = new LeafGenerator("bf_leaves", missingTexture);
-		MinecraftForge.EVENT_BUS.register(leafGenerator);
-		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 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

@@ -1,83 +0,0 @@
-package mods.betterfoliage.client;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.util.Iterator;
-import java.util.Set;
-
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.common.util.Utils;
-import net.minecraft.block.Block;
-import net.minecraft.client.multiplayer.WorldClient;
-import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.event.world.WorldEvent;
-
-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 void addClass(String className) {
-		try {
-			if (className.startsWith("-"))
-				blackList.add(Class.forName(className.substring(1)));
-			else
-				whiteList.add(Class.forName(className));
-		} catch(ClassNotFoundException e) {}
-	}
-	
-	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 load(File file, ResourceLocation defaults) {
-		if (!file.exists()) Utils.copyFromTextResource(defaults, file);
-		
-		BufferedReader reader = null;
-		try {
-			reader = new BufferedReader(new FileReader(file));
-			whiteList.clear();
-			blackList.clear();
-			String line = reader.readLine();
-			while(line != null) {
-				addClass(line.trim());
-				line = reader.readLine();
-			}
-			reader.close();
-		} catch (Exception e) {
-			BetterFoliage.log.warn(String.format("Error reading configuration: %s", file.getName()));
-		}
-	}
-	
-	/** Caches block IDs on world load for fast lookup
-	 * @param event
-	 */
-	@SuppressWarnings("unchecked")
-	@SubscribeEvent
-	public void handleWorldLoad(WorldEvent.Load event) {
-		if (!(event.world instanceof WorldClient)) return;
-		
-		blockIDs.clear();
-		Iterator<Block> iter = Block.blockRegistry.iterator();
-		while (iter.hasNext()) {
-			Block block = iter.next();
-			if (matchesClass(block)) blockIDs.add(Block.blockRegistry.getIDForObject(block));
-		}
-	}
-}

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

@@ -1,27 +0,0 @@
-package mods.betterfoliage.client;
-
-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;
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.client.gui.ConfigGuiMain;
-import net.minecraft.client.settings.KeyBinding;
-
-@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 ConfigGuiMain(null));
-	}
-}

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

@@ -1,60 +0,0 @@
-package mods.betterfoliage.client;
-
-import java.lang.reflect.Field;
-
-import net.minecraft.block.Block;
-import net.minecraft.init.Blocks;
-import net.minecraft.util.ResourceLocation;
-
-public class ShadersModIntegration {
-
-	private static boolean hasShadersMod = false;
-	private static int tallGrassEntityData;
-	private static int leavesEntityData;
-	private static Field shadersEntityData;
-	private static Field shadersEntityDataIndex;
-	
-	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) {
-		}
-	}
-	
-	public static void startGrassQuads() {
-		if (!hasShadersMod) return;
-		setShadersEntityData(tallGrassEntityData);
-	}
-
-	public static void startLeavesQuads() {
-		if (!hasShadersMod) return;
-		setShadersEntityData(leavesEntityData);
-	}
-	
-	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) {
-		}
-	}
-	
-	public static int getBlockIdOverride(int original, Block block) {
-		if (BetterFoliageClient.leaves.matchesID(original & 0xFFFF)) return leavesEntityData;
-		if (BetterFoliageClient.crops.matchesID(original & 0xFFFF)) return tallGrassEntityData;
-		return original;
-	}
-	
-	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/gui/ConfigGuiAlgae.java

@@ -1,36 +0,0 @@
-package mods.betterfoliage.client.gui;
-
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.client.gui.widget.OptionDoubleWidget;
-import mods.betterfoliage.client.gui.widget.OptionIntegerWidget;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-import cpw.mods.fml.client.FMLClientHandler;
-
-public class ConfigGuiAlgae extends ConfigGuiScreenBase {
-
-	public ConfigGuiAlgae(GuiScreen parent) {
-		super(parent);
-		int id = 10;
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.algaeHOffset, -100, -70, 200, 50, id++, id++, "message.betterfoliage.hOffset", "%.3f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.algaeSize, -100, -40, 200, 50, id++, id++, "message.betterfoliage.size", "%.2f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.algaeHeightMin, -100, -10, 200, 50, id++, id++, "message.betterfoliage.minHeight", "%.2f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.algaeHeightMax, -100, 20, 200, 50, id++, id++, "message.betterfoliage.maxHeight", "%.2f"));
-		widgets.add(new OptionIntegerWidget(BetterFoliage.config.algaeChance, -100, 50, 200, 50, id++, id++, "message.betterfoliage.algaeChance"));
-	}
-
-	@SuppressWarnings("unchecked")
-	@Override
-	public void addButtons(int x, int y) {
-		buttonList.add(new GuiButton(0, x - 50, y + 100, 100, 20, I18n.format("message.betterfoliage.back")));
-	}
-
-	@Override
-	protected void onButtonPress(int id) {
-		if (id == 0) FMLClientHandler.instance().showGuiScreen(parent);
-		
-		if (BetterFoliage.config.algaeHeightMin.value > BetterFoliage.config.algaeHeightMax.value) BetterFoliage.config.algaeHeightMin.value = BetterFoliage.config.algaeHeightMax.value;
-	}
-	
-}

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

@@ -1,34 +0,0 @@
-package mods.betterfoliage.client.gui;
-
-import cpw.mods.fml.client.FMLClientHandler;
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.client.gui.widget.OptionDoubleWidget;
-import mods.betterfoliage.client.gui.widget.OptionIntegerWidget;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-
-public class ConfigGuiCoral extends ConfigGuiScreenBase {
-
-	public ConfigGuiCoral(GuiScreen parent) {
-		super(parent);
-		int id = 10;
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.coralCrustSize, -100, -100, 200, 50, id++, id++, "message.betterfoliage.crustSize", "%.2f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.coralVOffset, -100, -70, 200, 50, id++, id++, "message.betterfoliage.vOffset", "%.3f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.coralSize, -100, -40, 200, 50, id++, id++, "message.betterfoliage.size", "%.2f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.coralHOffset, -100, -10, 200, 50, id++, id++, "message.betterfoliage.hOffset", "%.3f"));
-		widgets.add(new OptionIntegerWidget(BetterFoliage.config.coralPopulation, -100, 20, 200, 50, id++, id++, "message.betterfoliage.coralPopulation"));
-		widgets.add(new OptionIntegerWidget(BetterFoliage.config.coralChance, -100, 50, 200, 50, id++, id++, "message.betterfoliage.coralChance"));
-	}
-	
-	@SuppressWarnings("unchecked")
-	@Override
-	public void addButtons(int x, int y) {
-		buttonList.add(new GuiButton(0, x - 50, y + 80, 100, 20, I18n.format("message.betterfoliage.back")));
-	}
-	
-	@Override
-	protected void onButtonPress(int id) {
-		if (id == 0) FMLClientHandler.instance().showGuiScreen(parent);
-	}
-}

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

@@ -1,32 +0,0 @@
-package mods.betterfoliage.client.gui;
-
-import java.util.Set;
-
-import com.google.common.collect.ImmutableSet;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiScreen;
-import cpw.mods.fml.client.IModGuiFactory;
-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 ConfigGuiMain.class;
-	}
-
-	public Set<RuntimeOptionCategoryElement> runtimeGuiCategories() {
-		return ImmutableSet.<RuntimeOptionCategoryElement>of();
-	}
-
-	public RuntimeOptionGuiHandler getHandlerFor(RuntimeOptionCategoryElement element) {
-		return null;
-	}
-
-}

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

@@ -1,42 +0,0 @@
-package mods.betterfoliage.client.gui;
-
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.client.gui.widget.OptionDoubleWidget;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-import cpw.mods.fml.client.FMLClientHandler;
-
-public class ConfigGuiGrass extends ConfigGuiScreenBase {
-
-	public enum Button {CLOSE, GRASS_USE_GENERATED}
-	
-	public ConfigGuiGrass(GuiScreen parent) {
-		super(parent);
-		int id = 10;
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.grassSize, -100, -70, 200, 50, id++, id++, "message.betterfoliage.size", "%.2f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.grassHOffset, -100, -10, 200, 50, id++, id++, "message.betterfoliage.hOffset", "%.3f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.grassHeightMin, -100, 20, 200, 50, id++, id++, "message.betterfoliage.minHeight", "%.2f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.grassHeightMax, -100, 50, 200, 50, id++, id++, "message.betterfoliage.maxHeight", "%.2f"));
-	}
-
-	@SuppressWarnings("unchecked")
-	@Override
-	public void addButtons(int x, int y) {
-		buttonList.add(new GuiButton(Button.CLOSE.ordinal(), x - 50, y + 80, 100, 20, I18n.format("message.betterfoliage.back")));
-		buttonList.add(new GuiButton(Button.GRASS_USE_GENERATED.ordinal(), x - 100, y - 40, 200, 20, ""));
-	}
-
-	protected void updateButtons() {
-		setButtonOptionBoolean(Button.GRASS_USE_GENERATED.ordinal(), "message.betterfoliage.genShortgrass", BetterFoliage.config.grassUseGenerated);
-	}
-	
-	@Override
-	protected void onButtonPress(int id) {
-		if (id == Button.CLOSE.ordinal()) FMLClientHandler.instance().showGuiScreen(parent);
-		if (id == Button.GRASS_USE_GENERATED.ordinal()) BetterFoliage.config.grassUseGenerated = !BetterFoliage.config.grassUseGenerated;
-		
-		if (BetterFoliage.config.grassHeightMin.value > BetterFoliage.config.grassHeightMax.value) BetterFoliage.config.grassHeightMin.value = BetterFoliage.config.grassHeightMax.value;
-	}
-	
-}

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

@@ -1,39 +0,0 @@
-package mods.betterfoliage.client.gui;
-
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.client.gui.widget.OptionDoubleWidget;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-import cpw.mods.fml.client.FMLClientHandler;
-
-public class ConfigGuiLeaves extends ConfigGuiScreenBase {
-
-	public enum Button {CLOSE, LEAVES_OFFSET_MODE}
-	
-	public ConfigGuiLeaves(GuiScreen parent) {
-		super(parent);
-		int id = 10;
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.leavesSize, -100, -70, 200, 50, id++, id++, "message.betterfoliage.size", "%.2f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.leavesHOffset, -100, -10, 200, 50, id++, id++, "message.betterfoliage.hOffset", "%.3f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.leavesVOffset, -100, 20, 200, 50, id++, id++, "message.betterfoliage.vOffset", "%.3f"));
-	}
-
-	@SuppressWarnings("unchecked")
-	@Override
-	public void addButtons(int x, int y) {
-		buttonList.add(new GuiButton(Button.CLOSE.ordinal(), x - 50, y + 50, 100, 20, I18n.format("message.betterfoliage.back")));
-		buttonList.add(new GuiButton(Button.LEAVES_OFFSET_MODE.ordinal(), x - 100, y - 40, 200, 20, ""));
-	}
-
-	protected void updateButtons() {
-		setButtonOptionBoolean(Button.LEAVES_OFFSET_MODE.ordinal(), "message.betterfoliage.leavesMode", BetterFoliage.config.leavesSkew ? "message.betterfoliage.leavesSkew" : "message.betterfoliage.leavesTranslate");
-	}
-
-	@Override
-	protected void onButtonPress(int id) {
-		if (id == Button.CLOSE.ordinal()) FMLClientHandler.instance().showGuiScreen(parent);
-		if (id == Button.LEAVES_OFFSET_MODE.ordinal()) BetterFoliage.config.leavesSkew = !BetterFoliage.config.leavesSkew;
-	}
-	
-}

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

@@ -1,31 +0,0 @@
-package mods.betterfoliage.client.gui;
-
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.client.gui.widget.OptionDoubleWidget;
-import mods.betterfoliage.client.gui.widget.OptionIntegerWidget;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-import cpw.mods.fml.client.FMLClientHandler;
-
-public class ConfigGuiLilypad extends ConfigGuiScreenBase {
-
-	public ConfigGuiLilypad(GuiScreen parent) {
-		super(parent);
-		int id = 10;
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.lilypadHOffset, -100, -40, 200, 50, id++, id++, "message.betterfoliage.hOffset", "%.3f"));
-		widgets.add(new OptionIntegerWidget(BetterFoliage.config.lilypadChance, -100, -10, 200, 50, id++, id++, "message.betterfoliage.flowerChance"));
-	}
-
-	@SuppressWarnings("unchecked")
-	@Override
-	public void addButtons(int x, int y) {
-		buttonList.add(new GuiButton(0, x - 50, y + 50, 100, 20, I18n.format("message.betterfoliage.back")));
-	}
-
-	@Override
-	protected void onButtonPress(int id) {
-		if (id == 0) FMLClientHandler.instance().showGuiScreen(parent);
-	}
-	
-}

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

@@ -1,90 +0,0 @@
-package mods.betterfoliage.client.gui;
-
-import mods.betterfoliage.BetterFoliage;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-import cpw.mods.fml.client.FMLClientHandler;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-@SideOnly(Side.CLIENT)
-public class ConfigGuiMain extends ConfigGuiScreenBase {
-
-	public enum Button {CLOSE, 
-						TOGGLE_LEAVES, CONFIG_LEAVES,
-						TOGGLE_GRASS, CONFIG_GRASS,
-						TOGGLE_CACTUS, CONFIG_CACTUS,
-						TOGGLE_LILYPAD, CONFIG_LILYPAD,
-						TOGGLE_REED, CONFIG_REED,
-						TOGGLE_ALGAE, CONFIG_ALGAE,
-						TOGGLE_CORAL, CONFIG_CORAL}
-	
-	public ConfigGuiMain(GuiScreen parent) {
-		super(parent);
-
-	}
-
-	@SuppressWarnings("unchecked")
-	@Override
-	protected void addButtons(int x, int y) {
-		buttonList.add(new GuiButton(Button.CLOSE.ordinal(), x - 50, y + 110, 100, 20, I18n.format("message.betterfoliage.close")));
-		
-		buttonList.add(new GuiButton(Button.TOGGLE_LEAVES.ordinal(), x - 100, y - 100, 150, 20, ""));
-		buttonList.add(new GuiButton(Button.CONFIG_LEAVES.ordinal(), x + 60, y - 100, 40, 20, I18n.format("message.betterfoliage.config")));
-		
-		buttonList.add(new GuiButton(Button.TOGGLE_GRASS.ordinal(), x - 100, y - 70, 150, 20, ""));
-		buttonList.add(new GuiButton(Button.CONFIG_GRASS.ordinal(), x + 60, y - 70, 40, 20, I18n.format("message.betterfoliage.config")));
-		
-		buttonList.add(new GuiButton(Button.TOGGLE_CACTUS.ordinal(), x - 100, y - 40, 150, 20, ""));
-		buttonList.add(new GuiButton(Button.CONFIG_CACTUS.ordinal(), x + 60, y - 40, 40, 20, I18n.format("message.betterfoliage.config")));
-		
-		buttonList.add(new GuiButton(Button.TOGGLE_LILYPAD.ordinal(), x - 100, y - 10, 150, 20, ""));
-		buttonList.add(new GuiButton(Button.CONFIG_LILYPAD.ordinal(), x + 60, y - 10, 40, 20, I18n.format("message.betterfoliage.config")));
-		
-		buttonList.add(new GuiButton(Button.TOGGLE_REED.ordinal(), x - 100, y + 20, 150, 20, ""));
-		buttonList.add(new GuiButton(Button.CONFIG_REED.ordinal(), x + 60, y + 20, 40, 20, I18n.format("message.betterfoliage.config")));
-		
-		buttonList.add(new GuiButton(Button.TOGGLE_ALGAE.ordinal(), x - 100, y + 50, 150, 20, ""));
-		buttonList.add(new GuiButton(Button.CONFIG_ALGAE.ordinal(), x + 60, y + 50, 40, 20, I18n.format("message.betterfoliage.config")));
-		
-		buttonList.add(new GuiButton(Button.TOGGLE_CORAL.ordinal(), x - 100, y + 80, 150, 20, ""));
-		buttonList.add(new GuiButton(Button.CONFIG_CORAL.ordinal(), x + 60, y + 80, 40, 20, I18n.format("message.betterfoliage.config")));
-	}
-
-	protected void updateButtons() {
-		setButtonOptionBoolean(Button.TOGGLE_LEAVES.ordinal(), "message.betterfoliage.betterLeaves", BetterFoliage.config.leavesEnabled);
-		setButtonOptionBoolean(Button.TOGGLE_GRASS.ordinal(), "message.betterfoliage.betterGrass", BetterFoliage.config.grassEnabled);
-		setButtonOptionBoolean(Button.TOGGLE_CACTUS.ordinal(), "message.betterfoliage.betterCactus", BetterFoliage.config.cactusEnabled);
-		setButtonOptionBoolean(Button.TOGGLE_LILYPAD.ordinal(), "message.betterfoliage.betterLilypad", BetterFoliage.config.lilypadEnabled);
-		setButtonOptionBoolean(Button.TOGGLE_REED.ordinal(), "message.betterfoliage.betterReed", BetterFoliage.config.reedEnabled);
-		setButtonOptionBoolean(Button.TOGGLE_ALGAE.ordinal(), "message.betterfoliage.betterAlgae", BetterFoliage.config.algaeEnabled);
-		setButtonOptionBoolean(Button.TOGGLE_CORAL.ordinal(), "message.betterfoliage.betterCoral", BetterFoliage.config.coralEnabled);
-		((GuiButton) buttonList.get(Button.CONFIG_CACTUS.ordinal())).enabled = false;
-	}
-	
-	@Override
-	protected void onButtonPress(int id) {
-		if (id == Button.CLOSE.ordinal()) {
-			BetterFoliage.config.save();
-			Minecraft.getMinecraft().renderGlobal.loadRenderers();
-			FMLClientHandler.instance().showGuiScreen(parent);
-		}
-		if (id == Button.TOGGLE_LEAVES.ordinal()) BetterFoliage.config.leavesEnabled = !BetterFoliage.config.leavesEnabled;
-		if (id == Button.TOGGLE_GRASS.ordinal()) BetterFoliage.config.grassEnabled = !BetterFoliage.config.grassEnabled;
-		if (id == Button.TOGGLE_CACTUS.ordinal()) BetterFoliage.config.cactusEnabled = !BetterFoliage.config.cactusEnabled;
-		if (id == Button.TOGGLE_LILYPAD.ordinal()) BetterFoliage.config.lilypadEnabled = !BetterFoliage.config.lilypadEnabled;
-		if (id == Button.TOGGLE_REED.ordinal()) BetterFoliage.config.reedEnabled = !BetterFoliage.config.reedEnabled;
-		if (id == Button.TOGGLE_ALGAE.ordinal()) BetterFoliage.config.algaeEnabled = !BetterFoliage.config.algaeEnabled;
-		if (id == Button.TOGGLE_CORAL.ordinal()) BetterFoliage.config.coralEnabled = !BetterFoliage.config.coralEnabled;
-		
-		if (id== Button.CONFIG_LEAVES.ordinal()) FMLClientHandler.instance().showGuiScreen(new ConfigGuiLeaves(this));
-		if (id== Button.CONFIG_GRASS.ordinal()) FMLClientHandler.instance().showGuiScreen(new ConfigGuiGrass(this));
-		if (id== Button.CONFIG_LILYPAD.ordinal()) FMLClientHandler.instance().showGuiScreen(new ConfigGuiLilypad(this));
-		if (id== Button.CONFIG_REED.ordinal()) FMLClientHandler.instance().showGuiScreen(new ConfigGuiReed(this));
-		if (id== Button.CONFIG_ALGAE.ordinal()) FMLClientHandler.instance().showGuiScreen(new ConfigGuiAlgae(this));
-		if (id== Button.CONFIG_CORAL.ordinal()) FMLClientHandler.instance().showGuiScreen(new ConfigGuiCoral(this));
-	}
-
-}

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

@@ -1,35 +0,0 @@
-package mods.betterfoliage.client.gui;
-
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.client.gui.widget.OptionDoubleWidget;
-import mods.betterfoliage.client.gui.widget.OptionIntegerWidget;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-import cpw.mods.fml.client.FMLClientHandler;
-
-public class ConfigGuiReed extends ConfigGuiScreenBase {
-
-	public ConfigGuiReed(GuiScreen parent) {
-		super(parent);
-		int id = 10;
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.reedHOffset, -100, -70, 200, 50, id++, id++, "message.betterfoliage.hOffset", "%.3f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.reedHeightMin, -100, -40, 200, 50, id++, id++, "message.betterfoliage.minHeight", "%.2f"));
-		widgets.add(new OptionDoubleWidget(BetterFoliage.config.reedHeightMax, -100, -10, 200, 50, id++, id++, "message.betterfoliage.maxHeight", "%.2f"));
-		widgets.add(new OptionIntegerWidget(BetterFoliage.config.reedChance, -100, 20, 200, 50, id++, id++, "message.betterfoliage.reedChance"));
-	}
-
-	@SuppressWarnings("unchecked")
-	@Override
-	public void addButtons(int x, int y) {
-		buttonList.add(new GuiButton(0, x - 50, y + 50, 100, 20, I18n.format("message.betterfoliage.back")));
-	}
-
-	@Override
-	protected void onButtonPress(int id) {
-		if (id == 0) FMLClientHandler.instance().showGuiScreen(parent);
-		
-		if (BetterFoliage.config.reedHeightMin.value > BetterFoliage.config.reedHeightMax.value) BetterFoliage.config.reedHeightMin.value = BetterFoliage.config.reedHeightMax.value;
-	}
-	
-}

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

@@ -1,75 +0,0 @@
-package mods.betterfoliage.client.gui;
-
-import java.util.List;
-
-import mods.betterfoliage.client.gui.widget.IOptionWidget;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-import net.minecraft.util.EnumChatFormatting;
-
-import com.google.common.collect.Lists;
-
-public class ConfigGuiScreenBase extends GuiScreen {
-
-	protected GuiScreen parent;
-	protected List<IOptionWidget> widgets = Lists.newLinkedList();
-	
-	public ConfigGuiScreenBase(GuiScreen parent) {
-		this.parent = parent;
-	}
-	
-	@Override
-	public void drawScreen(int par1, int par2, float par3) {
-		this.drawDefaultBackground();
-		int x = width / 2;
-		int y = height / 2;
-		for (IOptionWidget widget : widgets) widget.drawStrings(this, fontRendererObj, x, y, 14737632, 16777120);
-		super.drawScreen(par1, par2, par3);
-	}
-	
-	@SuppressWarnings("unchecked")
-	@Override
-	public void initGui() {
-		int x = width / 2;
-		int y = height / 2;
-		for (IOptionWidget widget : widgets) widget.addButtons(buttonList, x, y);
-		addButtons(x, y);
-		updateButtons();
-	}
-	
-	protected void addButtons(int x, int y) {}
-	
-	protected void updateButtons() {}
-	
-	protected void onButtonPress(int id) {}
-	
-	@Override
-	protected void actionPerformed(GuiButton button) {
-		super.actionPerformed(button);
-		for (IOptionWidget widget : widgets) widget.onAction(button.id);
-		onButtonPress(button.id);
-		updateButtons();
-	}
-	
-	@SuppressWarnings("unchecked")
-	protected void setButtonOptionBoolean(int id, String msgKey, boolean option) {
-		for (GuiButton button : (List<GuiButton>) buttonList) {
-			if (button.id == id) {
-				String optionText = option ? (EnumChatFormatting.GREEN + I18n.format("message.betterfoliage.optionOn")) : (EnumChatFormatting.RED + I18n.format("message.betterfoliage.optionOff"));
-				button.displayString = I18n.format(msgKey, optionText);
-				break;
-			}
-		}
-	}
-	
-	@SuppressWarnings("unchecked")
-	protected void setButtonOptionBoolean(int id, String msgKey, String optionKey) {
-		for (GuiButton button : (List<GuiButton>) buttonList) {
-			if (button.id == id) {
-				button.displayString = I18n.format(msgKey, I18n.format(optionKey));
-				break;
-			}
-		}
-	}
-}

src/main/java/mods/betterfoliage/client/gui/widget/IOptionWidget.java

@@ -1,15 +0,0 @@
-package mods.betterfoliage.client.gui.widget;
-
-import java.util.List;
-
-import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-
-public interface IOptionWidget {
-
-	public void addButtons(List<GuiButton> buttonList, int xOffset, int yOffset);
-	public void drawStrings(GuiScreen screen, FontRenderer fontRenderer, int xOffset, int yOffset, int labelColor, int numColor);
-	public void onAction(int buttonId);
-
-}

src/main/java/mods/betterfoliage/client/gui/widget/OptionDoubleWidget.java

@@ -1,53 +0,0 @@
-package mods.betterfoliage.client.gui.widget;
-
-import java.util.List;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-import mods.betterfoliage.common.config.OptionDouble;
-import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-
-@SideOnly(Side.CLIENT)
-public class OptionDoubleWidget implements IOptionWidget {
-
-	public OptionDouble option;
-	public int x;
-	public int y;
-	public int width;
-	public int numWidth;
-	public int idDecrement;
-	public int idIncrement;
-	public String keyLabel;
-	public String formatString;
-	
-	public OptionDoubleWidget(OptionDouble option, int x, int y, int width, int numWidth, int idDecrement, int idIncrement, String keyLabel, String formatString) {
-		this.option = option;
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.numWidth = numWidth;
-		this.idDecrement = idDecrement;
-		this.idIncrement = idIncrement;
-		this.keyLabel = keyLabel;
-		this.formatString = formatString;
-	}
-	
-	public void addButtons(List<GuiButton> buttonList, int xOffset, int yOffset) {
-		buttonList.add(new GuiButton(idDecrement, xOffset + x + width - numWidth - 40, yOffset + y, 20, 20, "-"));
-		buttonList.add(new GuiButton(idIncrement, xOffset + x + width - 20, yOffset + y, 20, 20, "+"));
-	}
-	
-	public void drawStrings(GuiScreen screen, FontRenderer fontRenderer, int xOffset, int yOffset, int labelColor, int numColor) {
-		screen.drawString(fontRenderer, I18n.format(keyLabel), xOffset + x, yOffset + y + 5, labelColor);
-		screen.drawCenteredString(fontRenderer, String.format(formatString, option.value), xOffset + x + width - 20 - numWidth / 2, yOffset + y + 5, numColor);
-	}
-
-	public void onAction(int buttonId) {
-		if (buttonId == idDecrement) option.decrement();
-		if (buttonId == idIncrement) option.increment();
-	}
-}

src/main/java/mods/betterfoliage/client/gui/widget/OptionIntegerWidget.java

@@ -1,50 +0,0 @@
-package mods.betterfoliage.client.gui.widget;
-
-import java.util.List;
-
-import mods.betterfoliage.common.config.OptionInteger;
-import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.resources.I18n;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-@SideOnly(Side.CLIENT)
-public class OptionIntegerWidget implements IOptionWidget {
-
-	public OptionInteger option;
-	public int x;
-	public int y;
-	public int width;
-	public int numWidth;
-	public int idDecrement;
-	public int idIncrement;
-	public String keyLabel;
-	
-	public OptionIntegerWidget(OptionInteger option, int x, int y, int width, int numWidth, int idDecrement, int idIncrement, String keyLabel) {
-		this.option = option;
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.numWidth = numWidth;
-		this.idDecrement = idDecrement;
-		this.idIncrement = idIncrement;
-		this.keyLabel = keyLabel;
-	}
-	
-	public void addButtons(List<GuiButton> buttonList, int xOffset, int yOffset) {
-		buttonList.add(new GuiButton(idDecrement, xOffset + x + width - numWidth - 40, yOffset + y, 20, 20, "-"));
-		buttonList.add(new GuiButton(idIncrement, xOffset + x + width - 20, yOffset + y, 20, 20, "+"));
-	}
-	
-	public void drawStrings(GuiScreen screen, FontRenderer fontRenderer, int xOffset, int yOffset, int labelColor, int numColor) {
-		screen.drawString(fontRenderer, I18n.format(keyLabel), xOffset + x, yOffset + y + 5, labelColor);
-		screen.drawCenteredString(fontRenderer, Integer.toString(option.value), xOffset + x + width - 20 - numWidth / 2, yOffset + y + 5, numColor);
-	}
-	
-	public void onAction(int buttonId) {
-		if (buttonId == idDecrement) option.decrement();
-		if (buttonId == idIncrement) option.increment();
-	}
-}

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

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

@@ -1,15 +0,0 @@
-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;
-
-@SideOnly(Side.CLIENT)
-public interface IRenderBlockDecorator extends ISimpleBlockRenderingHandler {
-
-	public void init();
-	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original);
-	
-}

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

@@ -1,52 +0,0 @@
-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;
-
-/** Loads 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

@@ -1,440 +0,0 @@
-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 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.minecraftforge.common.util.ForgeDirection;
-
-import org.lwjgl.opengl.GL11;
-
-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 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/RenderBlockBetterAlgae.java

@@ -1,85 +0,0 @@
-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.util.Double3;
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockDirt;
-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 (!BetterFoliage.config.algaeEnabled) return false;
-		if (y >= 254 || !(block instanceof BlockDirt)) 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;
-		if (blockAccess.getBiomeGenForCoords(x, z).temperature < 0.4f) return false;
-		int terrainVariation = MathHelper.floor_double((noise.func_151605_a(x, z) + 1.0) * 32.0);
-		return terrainVariation < BetterFoliage.config.algaeChance.value;
-	}
-	
-	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 = BetterFoliage.config.algaeSize.value * 0.5;
-		double halfHeight = 0.5 * (BetterFoliage.config.algaeHeightMin.value + pRand[heightVariation] * (BetterFoliage.config.algaeHeightMax.value - BetterFoliage.config.algaeHeightMin.value));
-		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], BetterFoliage.config.algaeHOffset.value, 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

@@ -1,92 +0,0 @@
-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.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");
-	
-	public static ForgeDirection[] cactusDirections = new ForgeDirection[] { ForgeDirection.NORTH, ForgeDirection.SOUTH, ForgeDirection.EAST, ForgeDirection.WEST};
-	public static double cactusRadius = 0.4375;
-	
-	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
-		return BetterFoliage.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);
-		
-		Double3 blockCenter = new Double3(x + 0.5, y + 0.5, z + 0.5);
-		renderStandardBlock(block, x, y, z);
-		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

@@ -1,105 +0,0 @@
-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.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 (!BetterFoliage.config.coralEnabled) return false;
-		if (block != Blocks.sand) return false;
-		int terrainVariation = MathHelper.floor_double((noise.func_151605_a(x * 0.1, z * 0.1) + 1.0) * 32.0);
-		return terrainVariation < BetterFoliage.config.coralPopulation.value;
-	}
-	
-	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 sand block
-		setPassCounters(1);
-		setRenderBoundsFromBlock(block);
-		renderStandardBlock(block, x, y, z);
-		
-		Double3 blockCenter = new Double3(x + 0.5, y + 0.5, z + 0.5);
-		double offset = pRand[getSemiRandomFromPos(x, y, z, 6)] * BetterFoliage.config.coralVOffset.value;
-		double halfSize = BetterFoliage.config.coralSize.value * 0.5;
-		double halfCrustSize = BetterFoliage.config.coralCrustSize.value * 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 < BetterFoliage.config.coralChance.value) {
-				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], BetterFoliage.config.coralHOffset.value,
-														      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

@@ -1,100 +0,0 @@
-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.util.Double3;
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockGrass;
-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 IconSet myceliumIcons = new IconSet("bettergrassandleaves", "better_mycel_%d");
-	public IIcon grassGenIcon;
-	public IIcon snowGrassGenIcon;
-	
-	public boolean isBlockAccepted(IBlockAccess blockAccess, int x, int y, int z, Block block, int original) {
-		if (!BetterFoliage.config.grassEnabled) return false;
-		if (!((block instanceof BlockGrass || 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) {
-		// 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 grass block
-		setPassCounters(1);
-		setRenderBoundsFromBlock(block);
-		renderStandardBlock(block, x, y, z);
-		
-		int variation = getSemiRandomFromPos(x, y, z, 0);
-		int heightVariation = getSemiRandomFromPos(x, y, z, 1);
-		boolean isSnowed = blockAccess.getBlock(x, y + 1, z) == Blocks.snow_layer;
-		
-		IIcon renderIcon = null;
-		if (block instanceof BlockGrass) {
-			if (BetterFoliage.config.grassUseGenerated) {
-				renderIcon = isSnowed ? snowGrassGenIcon : grassGenIcon;
-			} else {
-				renderIcon = isSnowed ? snowGrassIcons.get(variation) : grassIcons.get(variation);
-			}
-		} else if (block == Blocks.mycelium && !isSnowed) {
-			renderIcon = myceliumIcons.get(variation);
-		}
-		if (renderIcon == null) return true;
-		
-		double scale = BetterFoliage.config.grassSize.value * 0.5;
-		double halfHeight = 0.5 * (BetterFoliage.config.grassHeightMin.value + pRand[heightVariation] * (BetterFoliage.config.grassHeightMax.value - BetterFoliage.config.grassHeightMin.value));
-		
-		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 short grass
-		ShadersModIntegration.startGrassQuads();
-		Tessellator.instance.setBrightness(getBrightness(block, x, y + 1, z));
-		renderCrossedSideQuads(new Double3(x + 0.5, y + 1.0 + (isSnowed ? 0.0625 : 0.0), z + 0.5), ForgeDirection.UP, scale, halfHeight, pRot[variation], BetterFoliage.config.grassHOffset.value, renderIcon, 0, false);
-		
-		return true;
-	}
-
-	@SubscribeEvent
-	public void handleTextureReload(TextureStitchEvent.Pre event) {
-		if (event.map.getTextureType() != 0) return;
-		
-		grassIcons.registerIcons(event.map);
-		snowGrassIcons.registerIcons(event.map);
-		myceliumIcons.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));
-		BetterFoliage.log.info(String.format("Found %d mycelium textures", myceliumIcons.numLoaded));
-	}
-
-}

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

@@ -1,97 +0,0 @@
-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.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.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.util.IIcon;
-import net.minecraft.world.IBlockAccess;
-import net.minecraftforge.common.util.ForgeDirection;
-import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
-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 (!BetterFoliage.config.leavesEnabled) return false;
-		if (original > 0 && original < 42) return false;
-		return BetterFoliageClient.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) {
-		// 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 leaves center
-		setPassCounters(1);
-		setRenderBoundsFromBlock(block);
-		if (block.getRenderType() == 0) {
-			renderStandardBlock(block, x, y, z);
-		} else {
-			ISimpleBlockRenderingHandler handler = Utils.getRenderingHandler(block.getRenderType());
-			handler.renderWorldBlock(world, x, y, z, block, block.getRenderType(), this);
-		}
-
-		// find generated texture to render with, assume the
-		// "true" texture of the block is the one on the north size
-		TextureAtlasSprite blockLeafIcon = (TextureAtlasSprite) block.getIcon(world, x, y, z, ForgeDirection.NORTH.ordinal());
-		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 * BetterFoliage.config.leavesSize.value;
-		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 (BetterFoliage.config.leavesSkew) {
-			renderCrossedBlockQuadsSkew(new Double3(x + 0.5, y + 0.5, z + 0.5), halfSize, 
-										pRot[offsetVariation].scaleAxes(BetterFoliage.config.leavesHOffset.value, BetterFoliage.config.leavesVOffset.value, BetterFoliage.config.leavesHOffset.value),
-										pRot[(offsetVariation + 1) & 63].scaleAxes(BetterFoliage.config.leavesHOffset.value, BetterFoliage.config.leavesVOffset.value, BetterFoliage.config.leavesHOffset.value),
-										crossLeafIcon, uvVariation, isAirTop, isAirBottom);
-		} else {
-			renderCrossedBlockQuadsTranslate(new Double3(x + 0.5, y + 0.5, z + 0.5), halfSize, 
-											 pRot[offsetVariation].scaleAxes(BetterFoliage.config.leavesHOffset.value, BetterFoliage.config.leavesVOffset.value, BetterFoliage.config.leavesHOffset.value),
-											 crossLeafIcon, uvVariation, isAirTop, isAirBottom);
-		}
-
-
-		return true;
-	}
-
-	protected boolean isBlockSurrounded(IBlockAccess blockAccess, int x, int y, int z) {
-		if (blockAccess.isAirBlock(x + 1, y, z)) return false;
-		if (blockAccess.isAirBlock(x - 1, y, z)) return false;
-		if (blockAccess.isAirBlock(x, y, z + 1)) return false;
-		if (blockAccess.isAirBlock(x, y, z - 1)) return false;
-		if (y == 255 || blockAccess.isAirBlock(x, y + 1, z)) return false;
-		if (y == 0 || blockAccess.isAirBlock(x, y - 1, z)) return false;
-		return true;
-	}
-	
-}

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

@@ -1,73 +0,0 @@
-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.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 BetterFoliage.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 < BetterFoliage.config.lilypadChance.value && lilypadFlowers.hasIcons())
-			renderCrossedSideQuads(new Double3(x + 0.5, y + 0.02, z + 0.5), ForgeDirection.UP,
-					 			   0.2, 0.3, 
-					 			   pRot[offsetVariation], BetterFoliage.config.lilypadHOffset.value, 
-					 			   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/RenderBlockBetterReed.java

@@ -1,93 +0,0 @@
-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.util.Double3;
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockDirt;
-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 (!BetterFoliage.config.reedEnabled) return false;
-		if (y >= 254 || !(block instanceof BlockDirt)) return false;
-		if (blockAccess.getBlock(x, y + 1, z).getMaterial() != Material.water) return false;
-		if (!blockAccess.isAirBlock(x, y + 2, z)) return false;
-		if (blockAccess.getBiomeGenForCoords(x, z).temperature < 0.4f || blockAccess.getBiomeGenForCoords(x, z).rainfall < 0.4f) return false;
-		int terrainVariation = MathHelper.floor_double((noise.func_151605_a(x, z) + 1.0) * 32.0);
-		return terrainVariation < BetterFoliage.config.reedChance.value;
-	}
-	
-	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 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 * (BetterFoliage.config.reedHeightMin.value + pRand[heightVariation] * (BetterFoliage.config.reedHeightMax.value - BetterFoliage.config.reedHeightMin.value));
-		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], BetterFoliage.config.reedHOffset.value, 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], BetterFoliage.config.reedHOffset.value, 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/resource/BlockTextureGenerator.java

@@ -1,88 +0,0 @@
-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;
-
-@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 & 0xFF) * weightOrig + (rgbBlend & 0xFF) * weightBlend) / (weightOrig + weightBlend);
-		int g = (((rgbOrig >> 8) & 0xFF) * weightOrig + ((rgbBlend >> 8) & 0xFF) * weightBlend) / (weightOrig + weightBlend);
-		int b = (((rgbOrig >> 16) & 0xFF) * weightOrig + ((rgbBlend >> 16) & 0xFF) * weightBlend) / (weightOrig + weightBlend);
-		int a = (rgbOrig >> 24) & 0xFF;
-		int result = (int) (a << 24 | b << 16 | g << 8 | r);
-		return result;
-	}
-}

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

@@ -1,44 +0,0 @@
-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 net.minecraft.client.resources.IResource;
-import net.minecraft.client.resources.data.IMetadataSection;
-
-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

@@ -1,130 +0,0 @@
-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.common.eventhandler.SubscribeEvent;
-
-import mods.betterfoliage.BetterFoliage;
-import mods.betterfoliage.client.ShadersModIntegration;
-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.Post;
-import net.minecraftforge.client.event.TextureStitchEvent.Pre;
-
-public class LeafGenerator extends BlockTextureGenerator {
-
-	/** Resource domain name of pre-drawn textures */
-	public String nonGeneratedDomain = "betterfoliage";
-	
-	/** 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;
-	
-	/** Name of the default alpha mask to use */
-	public static String defaultMask = "rough";
-	
-	public LeafGenerator(String domainName, ResourceLocation missingResource) {
-		super(domainName, missingResource);
-	}
-
-	@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("textures/blocks/%s/%s", originalNoDirs.getResourceDomain(), originalNoDirs.getResourcePath())); 
-		if (Utils.resourceExists(handDrawnLocation)) {
-			drawnCounter++;
-			return resourceManager.getResource(handDrawnLocation);
-		}
-		
-		// generate our own
-		if (!Utils.resourceExists(originalWithDirs)) return getMissingResource();
-		
-		// load normal leaf texture
-		BufferedImage origImage = ImageIO.read(resourceManager.getResource(originalWithDirs).getInputStream());
-		if (origImage.getWidth() != origImage.getHeight()) return getMissingResource();
-		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));
-				}
-			}
-		}
-		
-		generatedCounter++;
-		return new BufferedImageResource(overlayIcon);
-	}
-	
-	/** 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 >= 16) {
-			try {
-				maskResource = resourceManager.getResource(new ResourceLocation(String.format("betterfoliage:textures/blocks/leafmask_%d_%s.png", 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;
-	}
-
-	@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("Found %d leaf textures", generatedCounter));
-	}
-
-	
-}

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

@@ -1,92 +0,0 @@
-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.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.minecraft.util.ResourceLocation;
-import net.minecraftforge.client.event.TextureStitchEvent;
-
-import com.google.common.collect.Sets;
-
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
-
-public class LeafTextureEnumerator implements IIconRegister {
-
-	/** Resource domain name of generated textures */
-	public String domainName;
-	
-	/** Texture atlas for block textures used in the current run */
-	public TextureMap blockTextures;
-	
-	public LeafTextureEnumerator(String domainName) {
-		this.domainName = domainName;
-	}
-	
-	/** Leaf blocks register their textures here. An extra texture will be registered in the atlas
-	 *  for each, with the resource domain of this generator.
-	 *  @return the originally registered {@link IIcon} already in the atlas
-	 */
-	public IIcon registerIcon(String resourceLocation) {
-		IIcon original = blockTextures.getTextureExtry(resourceLocation);
-		blockTextures.registerIcon(new ResourceLocation(domainName, resourceLocation).toString());
-		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
-	@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 (BetterFoliageClient.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<String> foundLeafTextures = Sets.newHashSet();
-			for (TextureAtlasSprite icon : mapAtlas.values())
-				if (BetterFoliageClient.isLeafTexture(icon))
-					foundLeafTextures.add(icon.getIconName());
-			for (String resourceLocation : foundLeafTextures) {
-				BetterFoliage.log.debug(String.format("Found non-block-registered leaf texture: %s", resourceLocation));
-				blockTextures.registerIcon(new ResourceLocation(domainName, resourceLocation).toString());
-			}
-		}
-	}
-	
-	@SubscribeEvent
-	public void endTextureReload(TextureStitchEvent.Post event) {
-		if (event.map.getTextureType() != 0) return;
-		blockTextures = null;
-	}
-	
-}

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

@@ -1,40 +0,0 @@
-package mods.betterfoliage.client.resource;
-
-import java.awt.Graphics2D;
-import java.awt.image.BufferedImage;
-import java.io.IOException;
-
-import javax.imageio.ImageIO;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.resources.IResource;
-import net.minecraft.client.resources.IResourceManager;
-import net.minecraft.util.ResourceLocation;
-
-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

@@ -1,52 +0,0 @@
-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.client.ShadersModIntegration;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.resources.IResource;
-import net.minecraft.client.resources.IResourceManager;
-import net.minecraft.util.ResourceLocation;
-
-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/BetterFoliageConfig.java

@@ -1,106 +0,0 @@
-package mods.betterfoliage.common.config;
-
-public class BetterFoliageConfig extends ConfigBase {
-	
-	@CfgElement(category="leaves", key="enabled") 
-	public boolean leavesEnabled = true;
-	
-	@CfgElement(category="leaves", key="skewMode")
-	public boolean leavesSkew = false;
-	
-	@CfgElement(category="grass", key="enabled")
-	public boolean grassEnabled = true;
-	
-	@CfgElement(category="grass", key="useGenerated")
-	public boolean grassUseGenerated = false;
-	
-	@CfgElement(category="cactus", key="enabled")
-	public boolean cactusEnabled = true;
-	
-	@CfgElement(category="lilypad", key="enabled")
-	public boolean lilypadEnabled = true;
-	
-	@CfgElement(category="reed", key="enabled")
-	public boolean reedEnabled = true;
-	
-	@CfgElement(category="algae", key="enabled")
-	public boolean algaeEnabled = true;
-	
-	@CfgElement(category="coral", key="enabled")
-	public boolean coralEnabled = true;
-	
-	@CfgElement(category="leaves", key="horizontalOffset")
-	public OptionDouble leavesHOffset = new OptionDouble(0.0, 0.4, 0.025, 0.2);
-	
-	@CfgElement(category="leaves", key="verticalOffset")
-	public OptionDouble leavesVOffset = new OptionDouble(0.0, 0.4, 0.025, 0.1);
-	
-	@CfgElement(category="leaves", key="size")
-	public OptionDouble leavesSize = new OptionDouble(0.75, 1.8, 0.05, 1.4);
-			
-	@CfgElement(category="grass", key="horizontalOffset")
-	public OptionDouble grassHOffset = new OptionDouble(0.0, 0.4, 0.025, 0.2);
-	
-	@CfgElement(category="grass", key="heightMin")
-	@Limit(max="grassHeightMax")
-	public OptionDouble grassHeightMin = new OptionDouble(0.1, 1.5, 0.05, 0.5);
-	
-	@CfgElement(category="grass", key="heightMax") 
-	public OptionDouble grassHeightMax = new OptionDouble(0.1, 1.5, 0.05, 1.0);
-	
-	@CfgElement(category="grass", key="size")
-	public OptionDouble grassSize = new OptionDouble(0.5, 1.5, 0.05, 1.0);
-	
-	@CfgElement(category="lilypad", key="horizontalOffset")
-	public OptionDouble lilypadHOffset = new OptionDouble(0.0, 0.25, 0.025, 0.1);
-	
-	@CfgElement(category="lilypad", key="chance")
-	public OptionInteger lilypadChance = new OptionInteger(0, 64, 1, 16);
-	
-	@CfgElement(category="reed", key="horizontalOffset")
-	public OptionDouble reedHOffset = new OptionDouble(0.0, 0.25, 0.025, 0.1);
-	
-	@CfgElement(category="reed", key="heightMin")
-	@Limit(max="reedHeightMax")
-	public OptionDouble reedHeightMin = new OptionDouble(1.5, 3.5, 0.1, 2.0);
-	
-	@CfgElement(category="reed", key="heightMax")
-	public OptionDouble reedHeightMax = new OptionDouble(1.5, 3.5, 0.1, 2.5);
-	
-	@CfgElement(category="reed", key="chance")
-	public OptionInteger reedChance = new OptionInteger(0, 64, 1, 32);
-	
-	@CfgElement(category="algae", key="horizontalOffset")
-	public OptionDouble algaeHOffset = new OptionDouble(0.0, 0.25, 0.025, 0.1);
-	
-	@CfgElement(category="algae", key="size")
-	public OptionDouble algaeSize = new OptionDouble(0.5, 1.5, 0.05, 1.0);
-	
-	@CfgElement(category="algae", key="heightMin")
-	@Limit(max="algaeHeightMax")
-	public OptionDouble algaeHeightMin = new OptionDouble(0.1, 1.5, 0.05, 0.5);
-	
-	@CfgElement(category="algae", key="heightMax")
-	public OptionDouble algaeHeightMax = new OptionDouble(0.1, 1.5, 0.05, 1.0);
-	
-	@CfgElement(category="algae", key="chance")
-	public OptionInteger algaeChance = new OptionInteger(0, 64, 1, 48);
-	
-	@CfgElement(category="coral", key="population")
-	public OptionInteger coralPopulation = new OptionInteger(0, 64, 1, 32);
-	
-	@CfgElement(category="coral", key="chance")
-	public OptionInteger coralChance = new OptionInteger(0, 64, 1, 32);
-	
-	@CfgElement(category="coral", key="verticalOffset")
-	public OptionDouble coralVOffset = new OptionDouble(0.0, 0.25, 0.025, 0.1);
-	
-	@CfgElement(category="coral", key="horizontalOffset")
-	public OptionDouble coralHOffset = new OptionDouble(0.0, 0.4, 0.025, 0.2);
-	
-	@CfgElement(category="coral", key="crustSize")
-	public OptionDouble coralCrustSize = new OptionDouble(0.75, 1.75, 0.05, 1.4);
-	
-	@CfgElement(category="coral", key="size")
-	public OptionDouble coralSize = new OptionDouble(0.25, 1.0, 0.05, 0.7);
-}

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

@@ -1,128 +0,0 @@
-package mods.betterfoliage.common.config;
-
-import java.io.File;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.lang.reflect.Field;
-
-import net.minecraftforge.common.config.Configuration;
-import net.minecraftforge.common.config.Property;
-
-public class ConfigBase {
-
-	@Target(ElementType.FIELD)
-	@Retention(RetentionPolicy.RUNTIME)
-	public static @interface CfgElement {
-		String category();
-		String key();
-		String comment() default "";
-	}
-	
-	@Target(ElementType.FIELD)
-	@Retention(RetentionPolicy.RUNTIME)
-	public static @interface Limit {
-		String min() default "";
-		String max() default "";
-	}
-	
-	protected Configuration config;
-	
-	public void load(File configFile) {
-		config = new Configuration(configFile);
-		config.load();
-		
-		for (Field field : getClass().getDeclaredFields()) {
-			CfgElement annot = field.getAnnotation(CfgElement.class);
-			if (annot == null) continue;
-			
-			field.setAccessible(true);
-			if (field.getType().equals(boolean.class) || field.getType().equals(Boolean.class)) {
-				try {
-					Property prop = config.get(annot.category(), annot.key(), field.getBoolean(this));
-					field.setBoolean(this, prop.getBoolean(field.getBoolean(this)));
-				} catch (Exception e) {
-				}
-			} else if (field.getType().equals(OptionInteger.class)) {
-				try {
-					OptionInteger option = (OptionInteger) field.get(this);
-					Property prop =  config.get(annot.category(), annot.key(), option.value);
-					option.value = prop.getInt(option.value);
-				} catch (Exception e) {
-				}
-			} else if (field.getType().equals(OptionDouble.class)) {
-				try {
-					OptionDouble option = (OptionDouble) field.get(this);
-					Property prop =  config.get(annot.category(), annot.key(), option.value);
-					option.value = prop.getDouble(option.value);
-				} catch (Exception e) {
-				}
-			}
-		}
-		
-		validateLimits();
-		if (config.hasChanged()) config.save();
-	}
-	
-	protected void validateLimits() {
-		for (Field fieldThis : getClass().getDeclaredFields()) {
-			Limit annot = fieldThis.getAnnotation(Limit.class);
-			if (annot == null) continue;
-			
-			try {
-				Field fieldMin = annot.min().isEmpty() ? null : getClass().getDeclaredField(annot.min());
-				Field fieldMax = annot.max().isEmpty() ? null : getClass().getDeclaredField(annot.max());
-				fieldThis.setAccessible(true);
-				fieldMin.setAccessible(true);
-				fieldMax.setAccessible(true);
-				
-				if (fieldThis.getType().equals(OptionInteger.class)) {
-					OptionInteger optionThis = (OptionInteger) fieldThis.get(this);
-					OptionInteger optionMin = fieldMin == null ? null : (OptionInteger) fieldMin.get(this);
-					OptionInteger optionMax = fieldMax == null ? null : (OptionInteger) fieldMax.get(this);
-					if (optionMin != null) optionThis.value = Math.max(optionThis.value, optionMin.value);
-					if (optionMax != null) optionThis.value = Math.min(optionThis.value, optionMax.value);
-				} else if (fieldThis.getType().equals(OptionDouble.class)) {
-					OptionDouble optionThis = (OptionDouble) fieldThis.get(this);
-					OptionDouble optionMin = fieldMin == null ? null : (OptionDouble) fieldMin.get(this);
-					OptionDouble optionMax = fieldMax == null ? null : (OptionDouble) fieldMax.get(this);
-					if (optionMin != null) optionThis.value = Math.max(optionThis.value, optionMin.value);
-					if (optionMax != null) optionThis.value = Math.min(optionThis.value, optionMax.value);
-				}
-			} catch (Exception e) {}
-		}
-	}
-	
-	public void save() {
-		for (Field field : getClass().getDeclaredFields()) {
-			CfgElement annot = field.getAnnotation(CfgElement.class);
-			if (annot == null) continue;
-			
-			field.setAccessible(true);
-			if (field.getType().equals(boolean.class) || field.getType().equals(Boolean.class)) {
-				try {
-					Property prop = config.get(annot.category(), annot.key(), field.getBoolean(this));
-					prop.set(field.getBoolean(this));
-				} catch (Exception e) {
-				}
-			} else if (field.getType().equals(OptionInteger.class)) {
-				try {
-					OptionInteger option = (OptionInteger) field.get(this);
-					Property prop =  config.get(annot.category(), annot.key(), option.value);
-					prop.set(option.value);
-				} catch (Exception e) {
-				}
-			} else if (field.getType().equals(OptionDouble.class)) {
-				try {
-					OptionDouble option = (OptionDouble) field.get(this);
-					Property prop =  config.get(annot.category(), annot.key(), option.value);
-					prop.set(option.value);
-				} catch (Exception e) {
-				}
-			}
-		}
-		
-		config.save();
-	}
-}

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

@@ -1,26 +0,0 @@
-package mods.betterfoliage.common.config;
-
-public class OptionDouble {
-
-	public double min;
-	public double max;
-	public double step;
-	public double value;
-	
-	public OptionDouble(double min, double max, double step, double value) {
-		this.min = min;
-		this.max = max;
-		this.step = step;
-		this.value = value;
-	}
-	
-	public void increment() {
-		value += step;
-		if (value > max) value = max;
-	}
-	
-	public void decrement() {
-		value -= step;
-		if (value < min) value = min;
-	}
-}

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

@@ -1,26 +0,0 @@
-package mods.betterfoliage.common.config;
-
-public class OptionInteger {
-
-	public int min;
-	public int max;
-	public int step;
-	public int value;
-	
-	public OptionInteger(int min, int max, int step, int value) {
-		this.min = min;
-		this.max = max;
-		this.step = step;
-		this.value = value;
-	}
-	
-	public void increment() {
-		value += step;
-		if (value > max) value = max;
-	}
-	
-	public void decrement() {
-		value -= step;
-		if (value < min) value = min;
-	}
-}

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

@@ -1,42 +0,0 @@
-package mods.betterfoliage.common.util;
-
-import net.minecraftforge.common.util.ForgeDirection;
-
-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 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/Utils.java

@@ -1,94 +0,0 @@
-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.Map;
-
-import com.google.common.base.Charsets;
-
-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.util.ResourceLocation;
-import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
-import cpw.mods.fml.client.registry.RenderingRegistry;
-
-public class Utils {
-
-	private Utils() {}
-	
-	@SuppressWarnings("unchecked")
-	public static Map<String, IResourceManager> getDomainResourceManagers() {
-		IResourceManager manager = Minecraft.getMinecraft().getResourceManager();
-		Map<String, IResourceManager> result = getField(manager, "domainResourceManagers", Map.class);
-		if (result == null) result = getField(manager, DeobfHelper.transformElementSearge("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;
-		}
-	}
-	
-	@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;
-		}
-	}
-	
-	public static boolean resourceExists(ResourceLocation resourceLocation) {
-		try {
-			IResource resource = Minecraft.getMinecraft().getResourceManager().getResource(resourceLocation);
-			if (resource != null) return true;
-		} catch (IOException e) {
-		}
-		return false;
-	}
-	
-	public static void copyFromTextResource(ResourceLocation resourceLocation, File target) {
-		try {
-			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();
-		} catch(IOException e) {
-		}
-	}
-}

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

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

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

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

@@ -1,62 +0,0 @@
-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");
-			
-			obfElements.put("blockAccess", "a");
-			obfElements.put("renderBlockByRenderType", "b");
-			obfElements.put("mapRegisteredSprites", "bpr");
-		} 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");
-			
-			obfElements.put("blockAccess", "a");
-			obfElements.put("renderBlockByRenderType", "b");
-			obfElements.put("mapRegisteredSprites", "bpr");
-		}
-	}
-	
-	public static String transformClassName(String className) {
-		return obfClasses.containsKey(className) ? obfClasses.get(className) : className;
-	}
-	
-	public static String transformElementName(String elementName) {
-		return obfElements.containsKey(elementName) ? obfElements.get(elementName) : elementName;
-	}
-	
-	public static String transformElementSearge(String elementName) {
-		return srgElements.containsKey(elementName) ? srgElements.get(elementName) : elementName;
-	}
-	
-	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

@@ -1,72 +0,0 @@
-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;
-
-public abstract class MethodTransformerBase {
-
-	public static interface IInstructionMatch {
-		public boolean matches(AbstractInsnNode node);
-	}
-	
-	public abstract String getClassName();
-	public abstract String getMethodName();
-	public abstract String getSignature();
-	public abstract String getLogMessage();
-	
-	public abstract void transform(MethodNode method, boolean obf);
-	
-	protected static String className(String className, boolean isObfuscated) {
-		return isObfuscated ? DeobfHelper.transformClassName(className) : className;
-	}
-	
-	protected static String element(String fieldName, boolean isObfuscated) {
-		return isObfuscated ? DeobfHelper.transformElementName(fieldName) : fieldName;
-	}
-	
-	protected static String signature(String signature, boolean isObfuscated) {
-		return isObfuscated ? DeobfHelper.transformSignature(signature) : signature;
-	}
-	
-	protected AbstractInsnNode findNext(AbstractInsnNode start, IInstructionMatch match) {
-		AbstractInsnNode current = start;
-		while(current != null) {
-			if (match.matches(current)) break;
-			current = current.getNext();
-		}
-		return current;
-	}
-	
-	protected AbstractInsnNode findPrevious(AbstractInsnNode start, IInstructionMatch match) {
-		AbstractInsnNode current = start;
-		while(current != null) {
-			if (match.matches(current)) break;
-			current = current.getPrevious();
-		}
-		return current;
-	}
-	
-	protected IInstructionMatch matchInvokeAny() {
-		return new IInstructionMatch() {
-			public boolean matches(AbstractInsnNode node) {
-				return node instanceof MethodInsnNode;
-			}
-		};
-	}
-	
-	protected IInstructionMatch matchOpcode(final int opcode) {
-		return new IInstructionMatch() {
-			public boolean matches(AbstractInsnNode node) {
-				return node.getOpcode() == opcode;
-			}
-		};
-	}
-	
-	protected void insertAfter(InsnList insnList, AbstractInsnNode node, AbstractInsnNode... added) {
-		InsnList listAdd = new InsnList();
-		for (AbstractInsnNode inst : added) listAdd.add(inst);
-		insnList.insert(node, listAdd);
-	}
-}

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

@@ -1,49 +0,0 @@
-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 ovverride";
-	}
-
-	@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

@@ -1,40 +0,0 @@
-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 ovverride";
-	}
-
-	@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/optifine/OptifineTransformerDevWrapper.java

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

src/main/java/optifine/OptifineTweakerDevWrapper.java

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,190 @@
+package mods.betterfoliage.client.render.column
+
+import mods.betterfoliage.client.chunk.ChunkOverlayLayer
+import mods.betterfoliage.client.chunk.ChunkOverlayManager
+import mods.betterfoliage.client.config.Config
+import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.BlockType.*
+import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.QuadrantType
+import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.QuadrantType.*
+import mods.betterfoliage.client.render.rotationFromUp
+import mods.octarinecore.client.render.BlockContext
+import mods.octarinecore.client.resource.ModelRenderRegistry
+import mods.octarinecore.common.Int3
+import mods.octarinecore.common.Rotation
+import mods.octarinecore.common.face
+import mods.octarinecore.common.plus
+import net.minecraft.block.state.IBlockState
+import net.minecraft.util.EnumFacing
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockAccess
+import net.minecraftforge.fml.relauncher.Side
+import net.minecraftforge.fml.relauncher.SideOnly
+
+/** 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
+
+/**
+ * Sealed class hierarchy for all possible render outcomes
+ */
+@SideOnly(Side.CLIENT)
+sealed class ColumnLayerData {
+    /**
+     * Data structure to cache texture and world neighborhood data relevant to column rendering
+     */
+    @Suppress("ArrayInDataClass") // not used in comparisons anywhere
+    @SideOnly(Side.CLIENT)
+    data class SpecialRender(
+        val column: ColumnTextureInfo,
+        val 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 }
+    }
+
+    /** Column block should not be rendered at all */
+    @SideOnly(Side.CLIENT)
+    object SkipRender : ColumnLayerData()
+
+    /** Column block must be rendered normally */
+    @SideOnly(Side.CLIENT)
+    object NormalRender : ColumnLayerData()
+
+    /** Error while resolving render data, column block must be rendered normally */
+    @SideOnly(Side.CLIENT)
+    object ResolveError : ColumnLayerData()
+}
+
+
+abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {
+
+    abstract val registry: ModelRenderRegistry<ColumnTextureInfo>
+    abstract val blockPredicate: (IBlockState)->Boolean
+    abstract val surroundPredicate: (IBlockState) -> Boolean
+    abstract val connectSolids: Boolean
+    abstract val lenientConnect: Boolean
+    abstract val defaultToY: Boolean
+
+    val allNeighborOffsets = (-1..1).flatMap { offsetX -> (-1..1).flatMap { offsetY -> (-1..1).map { offsetZ -> Int3(offsetX, offsetY, offsetZ) }}}
+
+    override fun onBlockUpdate(world: IBlockAccess, pos: BlockPos) {
+        allNeighborOffsets.forEach { offset -> ChunkOverlayManager.clear(this, pos + offset) }
+    }
+
+    override fun calculate(world: IBlockAccess, pos: BlockPos) = calculate(BlockContext(world, pos))
+
+    fun calculate(ctx: BlockContext): ColumnLayerData {
+        if (ctx.isSurroundedBy(surroundPredicate)) return ColumnLayerData.SkipRender
+        val columnTextures = registry[ctx] ?: return ColumnLayerData.ResolveError
+
+        // if log axis is not defined and "Default to vertical" config option is not set, render normally
+        val logAxis = columnTextures.axis ?: if (defaultToY) EnumFacing.Axis.Y else return ColumnLayerData.NormalRender
+
+        // check log neighborhood
+        val baseRotation = rotationFromUp[(logAxis to EnumFacing.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: BlockContext, rotation: Rotation, logAxis: EnumFacing.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 BlockContext.blockType(rotation: Rotation, axis: EnumFacing.Axis, offset: Int3): ColumnLayerData.SpecialRender.BlockType {
+        val offsetRot = offset.rotate(rotation)
+        val state = blockState(offsetRot)
+        return if (!blockPredicate(state)) {
+            if (state.isOpaqueCube) SOLID else NONSOLID
+        } else {
+            (registry[state, world!!, pos + offsetRot]?.axis ?: if (Config.roundLogs.defaultY) EnumFacing.Axis.Y else null)?.let {
+                if (it == axis) PARALLEL else PERPENDICULAR
+            } ?: SOLID
+        }
+    }
+}

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

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

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

@@ -0,0 +1,50 @@
+package mods.betterfoliage.client.texture
+
+import mods.octarinecore.client.resource.*
+import net.minecraft.util.ResourceLocation
+import java.awt.image.BufferedImage
+
+/**
+ * Generate Short Grass textures from [Blocks.tallgrass] block textures.
+ * The bottom 3/8 of the base texture is chopped off.
+ *
+ * @param[domain] Resource domain of generator
+ */
+class GrassGenerator(domain: String) : TextureGenerator(domain) {
+
+    override fun generate(params: ParameterList): BufferedImage? {
+        val target = targetResource(params)!!
+        val isSnowed = params["snowed"]?.toBoolean() ?: false
+
+        val baseTexture = resourceManager[target.second]?.loadImage() ?: return null
+
+        val result = BufferedImage(baseTexture.width, baseTexture.height, BufferedImage.TYPE_4BYTE_ABGR)
+        val graphics = result.createGraphics()
+
+        val size = baseTexture.width
+        val frames = baseTexture.height / size
+
+        // iterate all frames
+        for (frame in 0 .. frames - 1) {
+            val baseFrame = baseTexture.getSubimage(0, size * frame, size, size)
+            val grassFrame = BufferedImage(size, size, BufferedImage.TYPE_4BYTE_ABGR)
+
+            // draw bottom half of texture
+            grassFrame.createGraphics().apply {
+                drawImage(baseFrame, 0, 3 * size / 8, null)
+            }
+
+            // add to animated png
+            graphics.drawImage(grassFrame, 0, size * frame, null)
+        }
+
+        // blend with white if snowed
+        if (isSnowed && target.first == ResourceType.COLOR) {
+            for (x in 0..result.width - 1) for (y in 0..result.height - 1) {
+                result[x, y] = blendRGB(result[x, y], 16777215, 2, 3)
+            }
+        }
+
+        return result
+    }
+}

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

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

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

@@ -0,0 +1,77 @@
+package mods.betterfoliage.client.texture
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.octarinecore.client.resource.*
+import mods.octarinecore.stripStart
+import net.minecraft.util.ResourceLocation
+import java.awt.image.BufferedImage
+
+/**
+ * Generate round leaf textures from leaf block textures.
+ * The base texture is tiled 2x2, then parts of it are made transparent by applying a mask to the alpha channel.
+ *
+ * Generator parameter _type_: Leaf type (configurable by user). Different leaf types may have their own alpha mask.
+ *
+ * @param[domain] Resource domain of generator
+ */
+class LeafGenerator(domain: String) : TextureGenerator(domain) {
+
+    override fun generate(params: ParameterList): BufferedImage? {
+        val target = targetResource(params)!!
+        val leafType = params["type"] ?: "default"
+
+        val handDrawnLoc = target.second.stripStart("textures/").stripStart("blocks/").let {
+            ResourceLocation(BetterFoliageMod.DOMAIN, "${it.namespace}/textures/blocks/${it.path}")
+        }
+        resourceManager[handDrawnLoc]?.loadImage()?.let { return it }
+
+        val baseTexture = resourceManager[target.second]?.loadImage() ?: return null
+        val size = baseTexture.width
+        val frames = baseTexture.height / size
+
+        val maskTexture = (getLeafMask(leafType, size * 2) ?: getLeafMask("default", size * 2))?.loadImage()
+        fun scale(i: Int) = i * maskTexture!!.width / (size * 2)
+
+        val leafTexture = BufferedImage(size * 2, size * 2 * frames, BufferedImage.TYPE_4BYTE_ABGR)
+        val graphics = leafTexture.createGraphics()
+
+        // iterate all frames
+        for (frame in 0 .. frames - 1) {
+            val baseFrame = baseTexture.getSubimage(0, size * frame, size, size)
+            val leafFrame = BufferedImage(size * 2, size * 2, BufferedImage.TYPE_4BYTE_ABGR)
+
+            // tile leaf texture 2x2
+            leafFrame.createGraphics().apply {
+                drawImage(baseFrame, 0, 0, null)
+                drawImage(baseFrame, 0, size, null)
+                drawImage(baseFrame, size, 0, null)
+                drawImage(baseFrame, size, size, null)
+            }
+
+            // overlay alpha mask
+            if (target.first == ResourceType.COLOR && maskTexture != null) {
+                for (x in 0 .. size * 2 - 1) for (y in 0 .. size * 2 - 1) {
+                    val basePixel = leafFrame[x, y].toLong() and 0xFFFFFFFFL
+                    val maskPixel = maskTexture[scale(x), scale(y)].toLong() and 0xFF000000L or 0xFFFFFFL
+                    leafFrame[x, y] = (basePixel and maskPixel).toInt()
+                }
+            }
+
+            // add to animated png
+            graphics.drawImage(leafFrame, 0, size * frame * 2, null)
+        }
+
+        return leafTexture
+    }
+
+    /**
+     * Get the alpha mask to use
+     *
+     * @param[type] Alpha mask type.
+     * @param[maxSize] Preferred mask size.
+     */
+    fun getLeafMask(type: String, maxSize: Int) = getMultisizeTexture(maxSize) { size ->
+        ResourceLocation(BetterFoliageMod.DOMAIN, "textures/blocks/leafmask_${size}_${type}.png")
+    }
+
+}

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

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

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

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

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

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

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

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

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

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

src/main/kotlin/mods/octarinecore/Utils.kt

@@ -0,0 +1,120 @@
+@file:JvmName("Utils")
+@file:Suppress("NOTHING_TO_INLINE")
+package mods.octarinecore
+
+import mods.betterfoliage.loader.Refs
+import net.minecraft.tileentity.TileEntity
+import net.minecraft.util.ResourceLocation
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.ChunkCache
+import net.minecraft.world.IBlockAccess
+import net.minecraft.world.World
+import kotlin.reflect.KProperty
+import java.lang.Math.*
+
+const val PI2 = 2.0 * PI
+
+/** Strip the given prefix off the start of the string, if present */
+inline fun String.stripStart(str: String) = if (startsWith(str)) substring(str.length) else this
+
+/** Strip the given prefix off the start of the resource path, if present */
+inline fun ResourceLocation.stripStart(str: String) = ResourceLocation(namespace, path.stripStart(str))
+
+/** Mutating version of _map_. Replace each element of the list with the result of the given transformation. */
+inline fun <reified T> MutableList<T>.replace(transform: (T) -> T) = forEachIndexed { idx, value -> this[idx] = transform(value) }
+
+/** Exchange the two elements of the list with the given indices */
+inline fun <T> MutableList<T>.exchange(idx1: Int, idx2: Int) {
+    val e = this[idx1]
+    this[idx1] = this[idx2]
+    this[idx2] = e
+}
+
+/** Cross product of this [Iterable] with the parameter. */
+fun <A, B> Iterable<A>.cross(other: Iterable<B>) = flatMap { a -> other.map { b -> a to b } }
+
+inline fun <C, R, T> Iterable<T>.mapAs(transform: (C) -> R) = map { transform(it as C) }
+
+inline fun <T1, T2> forEachNested(list1: Iterable<T1>, list2: Iterable<T2>, func: (T1, T2)-> Unit) =
+    list1.forEach { e1 ->
+        list2.forEach { e2 ->
+            func(e1, e2)
+        }
+    }
+
+@Suppress("UNCHECKED_CAST")
+inline fun <K, V> Map<K, V?>.filterValuesNotNull() = filterValues { it != null } as Map<K, V>
+
+inline fun <reified T, R> Iterable<T>.findFirst(func: (T)->R?): R? {
+    forEach { func(it)?.let { return it } }
+    return null
+}
+
+/**
+ * Property-level delegate backed by a [ThreadLocal].
+ *
+ * @param[init] Lambda to get initial value
+ */
+class ThreadLocalDelegate<T>(init: () -> T) {
+    var tlVal = ThreadLocal.withInitial(init)
+    operator fun getValue(thisRef: Any?, property: KProperty<*>): T = tlVal.get()
+    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) { tlVal.set(value) }
+}
+
+/**
+ * Starting with the second element of this [Iterable] until the last, call the supplied lambda with
+ * the parameters (index, element, previous element).
+ */
+inline fun <reified T> Iterable<T>.forEachPairIndexed(func: (Int, T, T)->Unit) {
+    var previous: T? = null
+    forEachIndexed { idx, current ->
+        if (previous != null) func(idx, current, previous!!)
+        previous = current
+    }
+}
+
+/** Call the supplied lambda and return its result, or the given default value if an exception is thrown. */
+fun <T> tryDefault(default: T, work: ()->T) = try { work() } catch (e: Throwable) { default }
+
+/** Return a random [Double] value between the given two limits (inclusive min, exclusive max). */
+fun random(min: Double, max: Double) = Math.random().let { min + (max - min) * it }
+
+fun semiRandom(x: Int, y: Int, z: Int, seed: Int): Int {
+    var value = (x * x + y * y + z * z + x * y + y * z + z * x + (seed * seed)) and 63
+    value = (3 * x * value + 5 * y * value + 7 * z * value + (11 * seed)) and 63
+    return value
+}
+/**
+ * Return this [Double] value if it lies between the two limits. If outside, return the
+ * minimum/maximum value correspondingly.
+ */
+fun Double.minmax(minVal: Double, maxVal: Double) = min(max(this, minVal), maxVal)
+
+/**
+ * Return this [Int] value if it lies between the two limits. If outside, return the
+ * minimum/maximum value correspondingly.
+ */
+fun Int.minmax(minVal: Int, maxVal: Int) = min(max(this, minVal), maxVal)
+
+fun nextPowerOf2(x: Int): Int {
+    return 1 shl (if (x == 0) 0 else 32 - Integer.numberOfLeadingZeros(x - 1))
+}
+
+/**
+ * Check if the Chunk containing the given [BlockPos] is loaded.
+ * Works for both [World] and [ChunkCache] (vanilla and OptiFine) instances.
+ */
+fun IBlockAccess.isBlockLoaded(pos: BlockPos) = when {
+    this is World -> isBlockLoaded(pos, false)
+    this is ChunkCache -> world.isBlockLoaded(pos, false)
+    Refs.OptifineChunkCache.isInstance(this) -> (Refs.CCOFChunkCache.get(this) as ChunkCache).world.isBlockLoaded(pos, false)
+    else -> false
+}
+
+/**
+ * Get the [TileEntity] at the given position, suppressing exceptions.
+ * Also returns null if the chunk is unloaded, which can happen because of multithreaded rendering.
+ */
+fun IBlockAccess.getTileEntitySafe(pos: BlockPos): TileEntity? = tryDefault(null as TileEntity?) {
+    if (isBlockLoaded(pos)) getTileEntity(pos) else null
+}

src/main/kotlin/mods/octarinecore/client/KeyHandler.kt

@@ -0,0 +1,22 @@
+package mods.octarinecore.client
+
+import net.minecraft.client.settings.KeyBinding
+import net.minecraftforge.fml.client.registry.ClientRegistry
+import net.minecraftforge.fml.common.FMLCommonHandler
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+import net.minecraftforge.fml.common.gameevent.InputEvent
+
+class KeyHandler(val modId: String, val defaultKey: Int, val lang: String, val action: (InputEvent.KeyInputEvent)->Unit) {
+
+    val keyBinding = KeyBinding(lang, defaultKey, modId)
+
+    init {
+        ClientRegistry.registerKeyBinding(keyBinding)
+        FMLCommonHandler.instance().bus().register(this)
+    }
+
+    @SubscribeEvent
+    fun handleKeyPress(event: InputEvent.KeyInputEvent) {
+        if (keyBinding.isPressed) action(event)
+    }
+}

src/main/kotlin/mods/octarinecore/client/gui/IdListConfigEntry.kt

@@ -0,0 +1,61 @@
+package mods.octarinecore.client.gui
+
+import net.minecraft.client.gui.GuiScreen
+import net.minecraft.client.resources.I18n
+import net.minecraft.util.text.TextFormatting.*
+import net.minecraftforge.fml.client.config.*
+
+/**
+ * Base class for a config GUI element.
+ * The GUI representation is a list of toggleable objects.
+ * The config representation is an integer list of the selected objects' IDs.
+ */
+abstract class IdListConfigEntry<T>(
+    owningScreen: GuiConfig,
+    owningEntryList: GuiConfigEntries,
+    configElement: IConfigElement
+) : GuiConfigEntries.CategoryEntry(owningScreen, owningEntryList, configElement) {
+
+    /** Create the child GUI elements. */
+    fun createChildren() = baseSet.map {
+        ItemWrapperElement(it, it.itemId in configElement.list, it.itemId in configElement.defaults)
+    }
+
+    init { stripTooltipDefaultText(toolTip as MutableList<String>) }
+
+    override fun buildChildScreen(): GuiScreen {
+        return GuiConfig(
+            this.owningScreen,
+            createChildren(),
+            this.owningScreen.modID,
+            owningScreen.allRequireWorldRestart || this.configElement.requiresWorldRestart(),
+            owningScreen.allRequireMcRestart || this.configElement.requiresMcRestart(),
+            this.owningScreen.title,
+            (if (this.owningScreen.titleLine2 == null) "" else this.owningScreen.titleLine2) + " > " + this.name)
+    }
+
+    override fun saveConfigElement(): Boolean {
+        val requiresRestart = (childScreen as GuiConfig).entryList.saveConfigElements()
+        val children = (childScreen as GuiConfig).configElements as List<ItemWrapperElement>
+        val ids = children.filter { it.booleanValue == true }.map { it.item.itemId }
+        configElement.set(ids.sorted().toTypedArray())
+        return requiresRestart
+    }
+
+    abstract val baseSet: List<T>
+    abstract val T.itemId: Int
+    abstract val T.itemName: String
+
+    /** Child config GUI element of a single toggleable object. */
+    inner class ItemWrapperElement(val item: T, value: Boolean, val default: Boolean) :
+            DummyConfigElement(item.itemName, default, ConfigGuiType.BOOLEAN, item.itemName) {
+
+        init {
+            this.value = value
+            this.defaultValue = default
+        }
+
+        override fun getComment() = I18n.format("${configElement.languageKey}.tooltip.element", "${GOLD}${item.itemName}${YELLOW}")
+        val booleanValue: Boolean get() = defaultValue as Boolean
+    }
+}