[WIP] start 1.15 port

reorganize packages to match Fabric version use util classes from Fabric version
2021-05-01 13:52:21 +02:00
parent 9566ae8341
commit 09ccb83e8b
81 changed files with 1220 additions and 1011 deletions
--- a/src/main/kotlin/mods/betterfoliage/BetterFoliage.kt
+++ b/src/main/kotlin/mods/betterfoliage/BetterFoliage.kt
@@ -1,12 +1,9 @@
 package mods.betterfoliage

-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.render.RisingSoulTextures
-import mods.octarinecore.client.gui.textComponent
+import mods.betterfoliage.util.textComponent
 import mods.octarinecore.client.resource.AsnycSpriteProviderManager
-import mods.octarinecore.client.resource.AsyncSpriteProvider
-import mods.octarinecore.client.resource.Atlas
-import mods.octarinecore.client.resource.GeneratedBlockTexturePack
+import mods.betterfoliage.resource.generated.GeneratedBlockTexturePack
+import mods.betterfoliage.util.Atlas
 import net.minecraft.block.BlockState
 import net.minecraft.client.Minecraft
 import net.minecraft.client.particle.ParticleManager
--- a/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt
+++ b/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt
@@ -1,24 +1,12 @@
 package mods.betterfoliage

-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.resource.AsnycSpriteProviderManager
-import mods.octarinecore.client.resource.GeneratedBlockTexturePack
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
 import net.alexwells.kottle.FMLKotlinModLoadingContext
 import net.minecraft.client.Minecraft
-import net.minecraft.client.particle.ParticleManager
-import net.minecraft.client.renderer.model.ModelBakery
 import net.minecraftforge.fml.ModLoadingContext
 import net.minecraftforge.fml.common.Mod
 import net.minecraftforge.fml.config.ModConfig
-import org.apache.logging.log4j.Level.DEBUG
-import org.apache.logging.log4j.LogManager
-import org.apache.logging.log4j.simple.SimpleLogger
-import org.apache.logging.log4j.util.PropertiesUtil
-import java.io.File
-import java.io.PrintStream
-import java.util.*

@Mod(BetterFoliageMod.MOD_ID)
 object BetterFoliageMod {
--- a/src/main/kotlin/mods/betterfoliage/client/Client.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/Client.kt
@@ -1,30 +1,36 @@
-package mods.betterfoliage.client
+package mods.betterfoliage

-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.integration.*
-import mods.betterfoliage.client.render.*
-import mods.betterfoliage.client.texture.AsyncGrassDiscovery
-import mods.betterfoliage.client.texture.AsyncLeafDiscovery
-import mods.betterfoliage.client.texture.LeafParticleRegistry
-import mods.octarinecore.client.gui.textComponent
-import mods.octarinecore.client.render.RenderDecorator
-import mods.octarinecore.client.resource.IConfigChangeListener
+import mods.betterfoliage.chunk.ChunkOverlayManager
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.integration.*
+import mods.betterfoliage.render.*
+import mods.betterfoliage.render.block.vanillaold.AsyncCactusDiscovery
+import mods.betterfoliage.render.block.vanillaold.AsyncLogDiscovery
+import mods.betterfoliage.render.block.vanillaold.RenderAlgae
+import mods.betterfoliage.render.block.vanillaold.RenderCactus
+import mods.betterfoliage.render.block.vanillaold.RenderConnectedGrass
+import mods.betterfoliage.render.block.vanillaold.RenderConnectedGrassLog
+import mods.betterfoliage.render.block.vanillaold.RenderCoral
+import mods.betterfoliage.render.block.vanillaold.RenderGrass
+import mods.betterfoliage.render.block.vanillaold.RenderLeaves
+import mods.betterfoliage.render.block.vanillaold.RenderLilypad
+import mods.betterfoliage.render.block.vanillaold.RenderLog
+import mods.betterfoliage.render.block.vanillaold.RenderMycelium
+import mods.betterfoliage.render.block.vanillaold.RenderNetherrack
+import mods.betterfoliage.render.block.vanillaold.RenderReeds
+import mods.betterfoliage.texture.AsyncGrassDiscovery
+import mods.betterfoliage.texture.AsyncLeafDiscovery
+import mods.betterfoliage.texture.LeafParticleRegistry
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.resource.IConfigChangeListener
 import net.minecraft.block.BlockState
-import net.minecraft.client.Minecraft
-import net.minecraft.util.math.BlockPos
-import net.minecraft.util.text.TextFormatting
-import net.minecraft.util.text.TranslationTextComponent
-import net.minecraftforge.registries.ForgeRegistries
-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.
 */
 object Client {
-    var renderers= emptyList<RenderDecorator>()
+    var renderers = emptyList<RenderDecorator>()
    var configListeners = emptyList<IConfigChangeListener>()

    val suppressRenderErrors = mutableSetOf<BlockState>()
--- a/src/main/kotlin/mods/betterfoliage/CommonRefs.kt
+++ b/src/main/kotlin/mods/betterfoliage/CommonRefs.kt
@@ -0,0 +1,70 @@
+package mods.octarinecore
+
+import mods.betterfoliage.util.ClassRef
+import mods.betterfoliage.util.ClassRef.Companion.void
+import mods.betterfoliage.util.FieldRef
+import mods.betterfoliage.util.MethodRef
+import net.minecraft.block.Block
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.BlockRendererDispatcher
+import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.client.renderer.chunk.ChunkRenderCache
+import net.minecraft.client.renderer.model.BakedQuad
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.ResourceLocation
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockReader
+import net.minecraft.world.ILightReader
+import java.util.*
+
+// Java
+val String = ClassRef<String>("java.lang.String")
+val Map = ClassRef<Map<*, *>>("java.util.Map")
+val List = ClassRef<List<*>>("java.util.List")
+val Random = ClassRef<Random>("java.util.Random")
+
+// Minecraft
+val IBlockReader = ClassRef<IBlockReader>("net.minecraft.world.IBlockReader")
+val ILightReader = ClassRef<ILightReader>("net.minecraft.world.ILightReader")
+val BlockState = ClassRef<BlockState>("net.minecraft.block.BlockState")
+val BlockPos = ClassRef<BlockPos>("net.minecraft.util.math.BlockPos")
+val Block = ClassRef<Block>("net.minecraft.block.Block")
+
+val TextureAtlasSprite = ClassRef<TextureAtlasSprite>("net.minecraft.client.renderer.texture.TextureAtlasSprite")
+val BufferBuilder = ClassRef<BufferBuilder>("net.minecraft.client.renderer.BufferBuilder")
+val BufferBuilder_setSprite = MethodRef(BufferBuilder, "setSprite", void, TextureAtlasSprite)
+val BufferBuilder_sVertexBuilder = FieldRef(BufferBuilder, "sVertexBuilder", SVertexBuilder)
+val BlockRendererDispatcher = ClassRef<BlockRendererDispatcher>("net.minecraft.client.renderer.BlockRendererDispatcher")
+val ChunkRenderCache = ClassRef<ChunkRenderCache>("net.minecraft.client.renderer.chunk.ChunkRenderCache")
+val ResourceLocation = ClassRef<ResourceLocation>("net.minecraft.util.ResourceLocation")
+val BakedQuad = ClassRef<BakedQuad>("net.minecraft.client.renderer.model.BakedQuad")
+
+// Optifine
+val OptifineClassTransformer = ClassRef<Any>("optifine.OptiFineClassTransformer")
+val BlockPosM = ClassRef<Any>("net.optifine.BlockPosM")
+object ChunkCacheOF : ClassRef<Any>("net.optifine.override.ChunkCacheOF") {
+    val chunkCache = FieldRef(this, "chunkCache", ChunkRenderCache)
+}
+
+object RenderEnv : ClassRef<Any>("net.optifine.render.RenderEnv") {
+    val reset = MethodRef(this, "reset", void, BlockState, BlockPos)
+}
+
+// Optifine custom colors
+val IColorizer = ClassRef<Any>("net.optifine.CustomColors\$IColorizer")
+object CustomColors : ClassRef<Any>("net.optifine.CustomColors") {
+    val getColorMultiplier = MethodRef(this, "getColorMultiplier", int, BakedQuad, BlockState, ILightReader, BlockPos, RenderEnv)
+}
+
+// Optifine shaders
+object SVertexBuilder : ClassRef<Any>("net.optifine.shaders.SVertexBuilder") {
+    val pushState = MethodRef(this, "pushEntity", void, long)
+    val popState = MethodRef(this, "popEntity", void)
+}
+
+object BlockAliases : ClassRef<Any>("net.optifine.shaders.BlockAliases") {
+    val getAliasBlockId = MethodRef(this, "getAliasBlockId", int, BlockState)
+}
+
+
+
--- a/src/main/kotlin/mods/betterfoliage/client/Hooks.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/Hooks.kt
@@ -1,33 +1,42 @@
@file:JvmName("Hooks")
-package mods.betterfoliage.client
+package mods.betterfoliage

-import mods.betterfoliage.client.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.render.*
-import mods.octarinecore.ThreadLocalDelegate
-import mods.octarinecore.client.render.*
-import mods.octarinecore.client.render.lighting.DefaultLightingCtx
-import mods.octarinecore.common.plus
+import com.mojang.blaze3d.matrix.MatrixStack
+import com.mojang.blaze3d.vertex.IVertexBuilder
+import mods.betterfoliage.chunk.ChunkOverlayManager
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.EntityFallingLeavesFX
+import mods.betterfoliage.render.EntityRisingSoulFX
+import mods.betterfoliage.render.block.vanillaold.LogRegistry
+import mods.betterfoliage.render.canRenderInLayer
+import mods.betterfoliage.render.down1
+import mods.betterfoliage.render.isCutout
+import mods.betterfoliage.render.up1
+import mods.betterfoliage.render.old.BasicBlockCtx
+import mods.betterfoliage.render.old.CachedBlockCtx
+import mods.betterfoliage.render.old.NonNullWorld
+import mods.betterfoliage.render.old.RenderCtx
+import mods.betterfoliage.render.lighting.DefaultLightingCtx
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.util.ThreadLocalDelegate
+import mods.betterfoliage.util.plus
 import net.minecraft.block.Block
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.client.Minecraft
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.world.ClientWorld
-import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.BlockRenderLayer.CUTOUT
-import net.minecraft.util.BlockRenderLayer.CUTOUT_MIPPED
 import net.minecraft.util.Direction
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.shapes.VoxelShape
 import net.minecraft.util.math.shapes.VoxelShapes
 import net.minecraft.world.IBlockReader
-import net.minecraft.world.IEnviromentBlockReader
+import net.minecraft.world.ILightReader
 import net.minecraft.world.World
 import net.minecraftforge.client.model.data.IModelData
-import java.util.*
+import java.util.Random

 fun getAmbientOcclusionLightValueOverride(original: Float, state: BlockState): Float {
    if (Config.enabled && Config.roundLogs.enabled && BlockConfig.logBlocks.matchesClass(state.block)) return Config.roundLogs.dimming.toFloat();
@@ -62,27 +71,34 @@ fun onRandomDisplayTick(block: Block, state: BlockState, world: World, pos: Bloc

 fun getVoxelShapeOverride(state: BlockState, reader: IBlockReader, pos: BlockPos, dir: Direction): VoxelShape {
    if (LogRegistry[state, reader, pos] != null) return VoxelShapes.empty()
-    return state.func_215702_a(reader, pos, dir)
+    return state.getFaceOcclusionShape(reader, pos, dir)
 }

 val lightingCtx by ThreadLocalDelegate { DefaultLightingCtx(BasicBlockCtx(NonNullWorld, BlockPos.ZERO)) }
 fun renderWorldBlock(dispatcher: BlockRendererDispatcher,
                     state: BlockState,
                     pos: BlockPos,
-                     reader: IEnviromentBlockReader,
-                     buffer: BufferBuilder,
+                     reader: ILightReader,
+                     matrixStack: MatrixStack,
+                     buffer: IVertexBuilder,
+                     checkSides: Boolean,
                     random: Random,
                     modelData: IModelData,
-                     layer: BlockRenderLayer
+                     layer: RenderType
 ): Boolean {
    // build context
    val blockCtx = CachedBlockCtx(reader, pos)
-    val renderCtx = RenderCtx(dispatcher, buffer, layer, random, modelData)
+    val renderCtx = RenderCtx(dispatcher, buffer, matrixStack, layer, checkSides, random, modelData)
    lightingCtx.reset(blockCtx)
    val combinedCtx = CombinedContext(blockCtx, renderCtx, lightingCtx)

+    combinedCtx.render()
+    return combinedCtx.hasRendered
+
    // loop render decorators
-    val doBaseRender = state.canRenderInLayer(layer) || (layer == targetCutoutLayer && state.canRenderInLayer(otherCutoutLayer))
+    val doBaseRender = state.canRenderInLayer(layer) || (layer == targetCutoutLayer && state.canRenderInLayer(
+        otherCutoutLayer
+    ))
    Client.renderers.forEach { renderer ->
        if (renderer.isEligible(combinedCtx)) {
            // render on the block's default layer
@@ -103,10 +119,10 @@ fun renderWorldBlock(dispatcher: BlockRendererDispatcher,
    return combinedCtx.hasRendered
 }

-fun canRenderInLayerOverride(state: BlockState, layer: BlockRenderLayer) = state.canRenderInLayer(layer) || layer == targetCutoutLayer
+fun canRenderInLayerOverride(state: BlockState, layer: RenderType) = state.canRenderInLayer(layer) || layer == targetCutoutLayer

 fun canRenderInLayerOverrideOptifine(state: BlockState, optifineReflector: Any?, layerArray: Array<Any>) =
-    canRenderInLayerOverride(state, layerArray[0] as BlockRenderLayer)
+    canRenderInLayerOverride(state, layerArray[0] as RenderType)

-val targetCutoutLayer: BlockRenderLayer get() = if (Minecraft.getInstance().gameSettings.mipmapLevels > 0) CUTOUT_MIPPED else CUTOUT
-val otherCutoutLayer: BlockRenderLayer get() = if (Minecraft.getInstance().gameSettings.mipmapLevels > 0) CUTOUT else CUTOUT_MIPPED
+val targetCutoutLayer: RenderType get() = if (Minecraft.getInstance().gameSettings.mipmapLevels > 0) RenderType.getCutoutMipped() else RenderType.getCutout()
+val otherCutoutLayer: RenderType get() = if (Minecraft.getInstance().gameSettings.mipmapLevels > 0) RenderType.getCutout() else RenderType.getCutoutMipped()
--- a/src/main/kotlin/mods/betterfoliage/client/chunk/Overlay.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/chunk/Overlay.kt
@@ -1,14 +1,14 @@
-package mods.betterfoliage.client.chunk
+package mods.betterfoliage.chunk

 import mods.octarinecore.ChunkCacheOF
-import mods.octarinecore.client.render.BlockCtx
-import mods.octarinecore.metaprog.get
-import mods.octarinecore.metaprog.isInstance
+import mods.betterfoliage.render.old.BlockCtx
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.isInstance
 import net.minecraft.client.renderer.chunk.ChunkRenderCache
 import net.minecraft.client.world.ClientWorld
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.ChunkPos
-import net.minecraft.world.IEnviromentBlockReader
+import net.minecraft.world.ILightReader
 import net.minecraft.world.IWorldReader
 import net.minecraft.world.dimension.DimensionType
 import net.minecraftforge.common.MinecraftForge
@@ -24,7 +24,7 @@ import kotlin.collections.mutableListOf
 import kotlin.collections.mutableMapOf
 import kotlin.collections.set

-val IEnviromentBlockReader.dimType: DimensionType get() = when {
+val ILightReader.dimType: DimensionType get() = when {
    this is IWorldReader -> dimension.type
    this is ChunkRenderCache -> world.dimension.type
    this.isInstance(ChunkCacheOF) -> this[ChunkCacheOF.chunkCache].world.dimension.type
@@ -36,7 +36,7 @@ val IEnviromentBlockReader.dimType: DimensionType get() = when {
 */
 interface ChunkOverlayLayer<T> {
    fun calculate(ctx: BlockCtx): T
-    fun onBlockUpdate(world: IEnviromentBlockReader, pos: BlockPos)
+    fun onBlockUpdate(world: ILightReader, pos: BlockPos)
 }

 /**
--- a/src/main/kotlin/mods/betterfoliage/client/config/Config.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/config/Config.kt
@@ -1,9 +1,7 @@
-package mods.betterfoliage.client.config
+package mods.betterfoliage.config

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.octarinecore.common.config.*
 import net.minecraft.util.ResourceLocation
 import net.minecraftforge.eventbus.api.SubscribeEvent
 import net.minecraftforge.fml.config.ModConfig
--- a/src/main/kotlin/mods/betterfoliage/config/DelegatingConfig.kt
+++ b/src/main/kotlin/mods/betterfoliage/config/DelegatingConfig.kt
@@ -0,0 +1,89 @@
+@file:JvmName("DelegatingConfigKt")
+
+package mods.betterfoliage.config
+
+import mods.betterfoliage.util.reflectDelegates
+import mods.betterfoliage.util.reflectNestedObjects
+import net.minecraftforge.common.ForgeConfigSpec
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+open class DelegatingConfig(val modId: String, val langPrefix: String) {
+    fun build() = ForgeConfigSpec.Builder().apply { ConfigBuildContext(langPrefix, emptyList(), this).addCategory(this@DelegatingConfig) }.build()
+}
+
+class ConfigBuildContext(val langPrefix: String, val path: List<String>, val builder: ForgeConfigSpec.Builder) {
+
+    fun addCategory(configObj: Any) {
+        configObj.reflectNestedObjects.forEach { (name, category) ->
+            builder.push(name)
+            descend(name).addCategory(category)
+            builder.pop()
+        }
+        configObj.reflectDelegates(ConfigDelegate::class.java).forEach { (name, delegate) ->
+            descend(name).apply { delegate.addToBuilder(this) }
+        }
+    }
+
+    fun descend(pathName: String) = ConfigBuildContext(langPrefix, path + pathName, builder)
+}
+
+open class ConfigCategory(val comment: String? = null) {
+}
+
+abstract class ConfigDelegate<T> : ReadOnlyProperty<Any, T> {
+    lateinit var configValue: ForgeConfigSpec.ConfigValue<T>
+    var cachedValue: T? = null
+
+    override fun getValue(thisRef: Any, property: KProperty<*>): T {
+        if (cachedValue == null) cachedValue = configValue.get()
+        return cachedValue!!
+    }
+
+    abstract fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder): ForgeConfigSpec.ConfigValue<T>
+    fun addToBuilder(ctx: ConfigBuildContext) {
+        val langKey = ctx.langPrefix + "." + (langPrefixOverride ?: ctx.path.joinToString("."))
+        ctx.builder.translation(langKey)
+        configValue = getConfigValue(ctx.path.last(), ctx.builder)
+    }
+
+    var langPrefixOverride: String? = null
+    fun lang(prefix: String) = apply { langPrefixOverride = prefix }
+
+}
+
+class DelegatingBooleanValue(val defaultValue: Boolean) : ConfigDelegate<Boolean>() {
+    override fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder) = builder.define(name, defaultValue)
+}
+
+class DelegatingIntValue(
+    val minValue: Int = 0,
+    val maxValue: Int = 1,
+    val defaultValue: Int = 0
+) : ConfigDelegate<Int>() {
+    override fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder) = builder.defineInRange(name, defaultValue, minValue, maxValue)
+}
+
+class DelegatingLongValue(
+    val minValue: Long = 0,
+    val maxValue: Long = 1,
+    val defaultValue: Long = 0
+) : ConfigDelegate<Long>() {
+    override fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder) = builder.defineInRange(name, defaultValue, minValue, maxValue)
+}
+
+class DelegatingDoubleValue(
+    val minValue: Double = 0.0,
+    val maxValue: Double = 1.0,
+    val defaultValue: Double = 0.0
+) : ConfigDelegate<Double>() {
+    override fun getConfigValue(name: String, builder: ForgeConfigSpec.Builder) = builder.defineInRange(name, defaultValue, minValue, maxValue)
+}
+
+// ============================
+// Delegate factory methods
+// ============================
+fun double(min: Double = 0.0, max: Double = 1.0, default: Double) = DelegatingDoubleValue(min, max, default)
+fun int(min: Int = 0, max: Int, default: Int) = DelegatingIntValue(min, max, default)
+fun long(min: Long = 0, max: Long, default: Long) = DelegatingLongValue(min, max, default)
+fun boolean(default: Boolean) = DelegatingBooleanValue(default)
--- a/src/main/kotlin/mods/betterfoliage/config/Matchers.kt
+++ b/src/main/kotlin/mods/betterfoliage/config/Matchers.kt
@@ -0,0 +1,74 @@
+package mods.betterfoliage.config
+
+import mods.betterfoliage.util.getLines
+import mods.betterfoliage.util.resourceManager
+import mods.betterfoliage.util.getJavaClass
+import net.minecraft.block.Block
+import net.minecraft.util.ResourceLocation
+import org.apache.logging.log4j.Logger
+
+interface IBlockMatcher {
+    fun matchesClass(block: Block): Boolean
+    fun matchingClass(block: Block): Class<*>?
+}
+
+class SimpleBlockMatcher(vararg val classes: Class<*>) : IBlockMatcher {
+    override fun matchesClass(block: Block) = matchingClass(block) != null
+
+    override fun matchingClass(block: Block): Class<*>? {
+        val blockClass = block.javaClass
+        classes.forEach { if (it.isAssignableFrom(blockClass)) return it }
+        return null
+    }
+}
+
+class ConfigurableBlockMatcher(val logger: Logger, val location: ResourceLocation) : IBlockMatcher {
+
+    val blackList = mutableListOf<Class<*>>()
+    val whiteList = mutableListOf<Class<*>>()
+//    override fun convertValue(line: String) = getJavaClass(line)
+
+    override fun matchesClass(block: Block): Boolean {
+        val blockClass = block.javaClass
+        blackList.forEach { if (it.isAssignableFrom(blockClass)) return false }
+        whiteList.forEach { if (it.isAssignableFrom(blockClass)) return true }
+        return false
+    }
+
+    override fun matchingClass(block: Block): Class<*>? {
+        val blockClass = block.javaClass
+        blackList.forEach { if (it.isAssignableFrom(blockClass)) return null }
+        whiteList.forEach { if (it.isAssignableFrom(blockClass)) return it }
+        return null
+    }
+
+    fun readDefaults() {
+        blackList.clear()
+        whiteList.clear()
+        resourceManager.getAllResources(location).forEach { resource ->
+            logger.debug("Reading resource $location from pack ${resource.packName}")
+            resource.getLines().map{ it.trim() }.filter { !it.startsWith("//") && it.isNotEmpty() }.forEach { line ->
+                if (line.startsWith("-")) getJavaClass(line.substring(1))?.let { blackList.add(it) }
+                else getJavaClass(line)?.let { whiteList.add(it) }
+
+            }
+        }
+    }
+}
+
+data class ModelTextureList(val modelLocation: ResourceLocation, val textureNames: List<String>) {
+    constructor(vararg args: String) : this(ResourceLocation(args[0]), listOf(*args).drop(1))
+}
+
+class ModelTextureListConfiguration(val logger: Logger, val location: ResourceLocation) {
+    val modelList = mutableListOf<ModelTextureList>()
+    fun readDefaults() {
+        resourceManager.getAllResources(location).forEach { resource ->
+            logger.debug("Reading resource $location from pack ${resource.packName}")
+            resource.getLines().map{ it.trim() }.filter { !it.startsWith("//") && it.isNotEmpty() }.forEach { line ->
+                val elements = line.split(",")
+                modelList.add(ModelTextureList(ResourceLocation(elements.first()), elements.drop(1)))
+            }
+        }
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/client/integration/ForestryIntegration.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/ForestryIntegration.kt
@@ -1,20 +1,27 @@
-package mods.betterfoliage.client.integration
+package mods.betterfoliage.integration

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.render.AsyncLogDiscovery
-import mods.betterfoliage.client.render.column.ColumnTextureInfo
-import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.betterfoliage.client.resource.Identifier
-import mods.betterfoliage.client.texture.LeafInfo
-import mods.betterfoliage.client.texture.defaultRegisterLeaf
-import mods.octarinecore.HasLogger
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.render.block.vanillaold.AsyncLogDiscovery
+import mods.betterfoliage.render.column.ColumnTextureInfo
+import mods.betterfoliage.render.column.SimpleColumnInfo
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.discovery.ModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ModelRenderRegistry
+import mods.betterfoliage.texture.LeafInfo
+import mods.betterfoliage.texture.defaultRegisterLeaf
+import mods.betterfoliage.util.ClassRef
 import mods.octarinecore.Map
 import mods.octarinecore.ResourceLocation
 import mods.octarinecore.String
 import mods.octarinecore.client.resource.*
-import mods.octarinecore.metaprog.*
-import mods.octarinecore.metaprog.ClassRef.Companion.boolean
+import mods.betterfoliage.util.ClassRef.Companion.boolean
+import mods.betterfoliage.util.FieldRef
+import mods.betterfoliage.util.HasLogger
+import mods.betterfoliage.util.MethodRef
+import mods.betterfoliage.util.allAvailable
+import mods.betterfoliage.util.get
 import net.minecraft.block.BlockState
 import net.minecraft.client.Minecraft
 import net.minecraft.client.renderer.model.ModelBakery
--- a/src/main/kotlin/mods/betterfoliage/client/integration/OptifineCustomColors.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/OptifineCustomColors.kt
@@ -1,14 +1,14 @@
-package mods.betterfoliage.client.integration
+package mods.betterfoliage.integration

 import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.util.ThreadLocalDelegate
 import mods.octarinecore.*
-import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.metaprog.allAvailable
-import mods.octarinecore.metaprog.reflectField
+import mods.betterfoliage.util.allAvailable
+import mods.betterfoliage.util.reflectField
 import net.minecraft.block.BlockState
 import net.minecraft.client.Minecraft
 import net.minecraft.client.renderer.model.BakedQuad
-import net.minecraft.client.renderer.vertex.DefaultVertexFormats
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.math.BlockPos
 import org.apache.logging.log4j.Level
@@ -26,7 +26,7 @@ object OptifineCustomColors {
    }

    val renderEnv by ThreadLocalDelegate { OptifineRenderEnv() }
-    val fakeQuad = BakedQuad(IntArray(0), 1, UP, null, true, DefaultVertexFormats.BLOCK)
+    val fakeQuad = BakedQuad(IntArray(0), 1, UP, null, true)

    fun getBlockColor(ctx: CombinedContext): Int {
        val ofColor = if (isColorAvailable && Minecraft.getInstance().gameSettings.reflectField<Boolean>("ofCustomColors") == true) {
--- a/src/main/kotlin/mods/betterfoliage/client/integration/RubberIntegration.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/RubberIntegration.kt
@@ -1,23 +1,25 @@
-package mods.betterfoliage.client.integration
+package mods.betterfoliage.integration

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.client.render.LogRegistry
-import mods.betterfoliage.client.render.column.ColumnTextureInfo
-import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.betterfoliage.client.resource.Sprite
-import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.client.render.Quad
-import mods.octarinecore.client.render.lighting.QuadIconResolver
+import mods.betterfoliage.render.column.ColumnTextureInfo
+import mods.betterfoliage.render.column.SimpleColumnInfo
+import mods.betterfoliage.resource.Sprite
+import mods.betterfoliage.render.old.Quad
+import mods.betterfoliage.render.lighting.QuadIconResolver
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.resource.discovery.ModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.derivesFrom
 import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.rotate
-import mods.octarinecore.metaprog.ClassRef
-import mods.octarinecore.metaprog.allAvailable
+import mods.betterfoliage.util.rotate
+import mods.betterfoliage.util.ClassRef
+import mods.betterfoliage.util.allAvailable
 import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.client.renderer.texture.MissingTextureSprite
 import net.minecraft.util.Direction
 import net.minecraft.util.Direction.*
 import net.minecraft.util.ResourceLocation
 import net.minecraftforge.fml.ModList
-import org.apache.logging.log4j.Level
 import java.util.concurrent.CompletableFuture


@@ -86,8 +88,8 @@ object IC2LogDiscovery : ModelDiscovery<ColumnTextureInfo>() {
                "plain_z" -> Axis.Z
                else -> null
            }
-            val textureNames = listOf("end", "side").map { blockLoc.first.resolveTextureName(it) }
-            if (textureNames.any { it == "missingno" }) return null
+            val textureNames = listOf("end", "side").map { blockLoc.first.resolveTextureName(it).textureLocation }
+            if (textureNames.any { it == MissingTextureSprite.getLocation() }) return null
            log("IC2LogSupport: block state ${ctx.state.toString()}")
            log("IC2LogSupport:             axis=$axis, end=${textureNames[0]}, side=${textureNames[1]}")
            val endSprite = atlas.sprite(textureNames[0])
@@ -105,9 +107,9 @@ object IC2LogDiscovery : ModelDiscovery<ColumnTextureInfo>() {
            "dry_east", "wet_east" -> EAST
            else -> null
        }
-        val textureNames = listOf("up", "down", "north", "south").map { blockLoc.first.resolveTextureName(it) }
-        if (textureNames.any { it == "missingno" }) return null
-        log("IC2LogSupport: block state ${ctx.state.toString()}")
+        val textureNames = listOf("up", "down", "north", "south").map { blockLoc.first.resolveTextureName(it).textureLocation }
+        if (textureNames.any { it == MissingTextureSprite.getLocation() }) return null
+        log("IC2LogSupport: block state ${ctx.state}")
        log("IC2LogSupport:             spotDir=$spotDir, up=${textureNames[0]}, down=${textureNames[1]}, side=${textureNames[2]}, spot=${textureNames[3]}")
        val upSprite = atlas.sprite(textureNames[0])
        val downSprite = atlas.sprite(textureNames[1])
--- a/src/main/kotlin/mods/betterfoliage/client/integration/ShadersModIntegration.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/ShadersModIntegration.kt
@@ -1,18 +1,18 @@
-package mods.betterfoliage.client.integration
+package mods.betterfoliage.integration

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.texture.LeafRegistry
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.texture.LeafRegistry
 import mods.octarinecore.*
-import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.metaprog.allAvailable
-import mods.octarinecore.metaprog.get
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.util.allAvailable
+import mods.betterfoliage.util.get
 import net.minecraft.block.BlockRenderType
 import net.minecraft.block.BlockRenderType.MODEL
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IEnviromentBlockReader
+import net.minecraft.world.ILightReader
 import org.apache.logging.log4j.Level.INFO

 /**
@@ -29,7 +29,7 @@ object ShadersModIntegration {
     * Called from transformed ShadersMod code.
     * @see mods.betterfoliage.loader.BetterFoliageTransformer
     */
-    @JvmStatic fun getBlockStateOverride(state: BlockState, world: IEnviromentBlockReader, pos: BlockPos): BlockState {
+    @JvmStatic fun getBlockStateOverride(state: BlockState, world: ILightReader, pos: BlockPos): BlockState {
        if (LeafRegistry[state, world, pos] != null) return defaultLeaves
        if (BlockConfig.crops.matchesClass(state.block)) return defaultGrass
        return state
--- a/src/main/kotlin/mods/betterfoliage/client/render/EntityFallingLeavesFX.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/EntityFallingLeavesFX.kt
@@ -1,14 +1,14 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.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.lighting.HSB
-import mods.octarinecore.common.Double3
-import mods.octarinecore.minmax
-import mods.octarinecore.random
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.texture.LeafParticleRegistry
+import mods.betterfoliage.texture.LeafRegistry
+import mods.betterfoliage.render.old.AbstractEntityFX
+import mods.betterfoliage.render.lighting.HSB
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.PI2
+import mods.betterfoliage.util.minmax
+import mods.betterfoliage.util.randomD
 import net.minecraft.client.Minecraft
 import net.minecraft.client.renderer.BufferBuilder
 import net.minecraft.util.math.BlockPos
@@ -18,7 +18,6 @@ import net.minecraftforge.common.MinecraftForge
 import net.minecraftforge.event.TickEvent
 import net.minecraftforge.event.world.WorldEvent
 import net.minecraftforge.eventbus.api.SubscribeEvent
-import org.lwjgl.opengl.GL11
 import java.util.*
 import kotlin.math.abs
 import kotlin.math.cos
@@ -42,7 +41,7 @@ class EntityFallingLeavesFX(
    var wasCollided = false

    init {
-        maxAge = MathHelper.floor(random(0.6, 1.0) * Config.fallingLeaves.lifetime * 20.0)
+        maxAge = MathHelper.floor(randomD(0.6, 1.0) * Config.fallingLeaves.lifetime * 20.0)
        motionY = -Config.fallingLeaves.speed

        particleScale = Config.fallingLeaves.size.toFloat() * 0.1f
@@ -68,7 +67,7 @@ class EntityFallingLeavesFX(
        if (onGround || wasCollided) {
            velocity.setTo(0.0, 0.0, 0.0)
            if (!wasCollided) {
-                age = Math.max(age, maxAge - 20)
+                age = age.coerceAtLeast(maxAge - 20)
                wasCollided = true
            }
        } else {
@@ -80,8 +79,8 @@ class EntityFallingLeavesFX(
    }

    override fun render(worldRenderer: BufferBuilder, partialTickTime: Float) {
-        if (Config.fallingLeaves.opacityHack) GL11.glDepthMask(true)
-        renderParticleQuad(worldRenderer, partialTickTime, rotation = particleRot, isMirrored = isMirrored)
+//        if (Config.fallingLeaves.opacityHack) GL11.glDepthMask(true)
+//        renderParticleQuad(worldRenderer, partialTickTime, rotation = particleRot, isMirrored = isMirrored)
    }

    fun calculateParticleColor(textureAvgColor: Int, blockColor: Int) {
--- a/src/main/kotlin/mods/betterfoliage/client/render/EntityRisingSoulFX.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/EntityRisingSoulFX.kt
@@ -1,21 +1,17 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render

-import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.render.AbstractEntityFX
-import mods.octarinecore.client.resource.Atlas
-import mods.octarinecore.client.resource.ResourceHandler
-import mods.octarinecore.common.Double3
-import mods.octarinecore.forEachPairIndexed
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.render.old.AbstractEntityFX
+import mods.betterfoliage.resource.ResourceHandler
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.Double3
 import net.minecraft.client.renderer.BufferBuilder
 import net.minecraft.util.ResourceLocation
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.MathHelper
 import net.minecraft.world.World
-import org.apache.logging.log4j.Level.DEBUG
 import java.util.*

 class EntityRisingSoulFX(world: World, pos: BlockPos) :
@@ -44,26 +40,26 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.to
    }

    override fun render(worldRenderer: BufferBuilder, partialTickTime: Float) {
-        var alpha = Config.risingSoul.opacity.toFloat()
-        if (age > maxAge - 40) alpha *= (maxAge - age) / 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.toFloat()
-            if (idx % Config.risingSoul.trailDensity == 0) renderParticleQuad(worldRenderer, partialTickTime,
-                currentPos = current,
-                prevPos = previous,
-                size = scale,
-                alpha = alpha,
-                icon = RisingSoulTextures.trackIcon
-            )
-        }
+//        var alpha = Config.risingSoul.opacity.toFloat()
+//        if (age > maxAge - 40) alpha *= (maxAge - age) / 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.toFloat()
+//            if (idx % Config.risingSoul.trailDensity == 0) renderParticleQuad(worldRenderer, partialTickTime,
+//                currentPos = current,
+//                prevPos = previous,
+//                size = scale,
+//                alpha = alpha,
+//                icon = RisingSoulTextures.trackIcon
+//            )
+//        }
    }
 }

--- a/src/main/kotlin/mods/betterfoliage/client/render/ModelColumn.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/ModelColumn.kt
@@ -1,11 +1,22 @@
@file:JvmName("ModelColumn")
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render

-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.*
-import mods.octarinecore.client.render.lighting.*
-import mods.octarinecore.common.Double3
-import mods.octarinecore.exchange
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.lighting.CornerSingleFallback
+import mods.betterfoliage.render.lighting.EdgeInterpolateFallback
+import mods.betterfoliage.render.lighting.FaceCenter
+import mods.betterfoliage.render.lighting.FaceFlat
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerFlat
+import mods.betterfoliage.render.lighting.cornerInterpolate
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.render.lighting.faceOrientedInterpolate
+import mods.betterfoliage.render.old.Model
+import mods.betterfoliage.render.old.Quad
+import mods.betterfoliage.render.old.UV
+import mods.betterfoliage.render.old.Vertex
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.exchange
 import net.minecraft.util.Direction.*

 /** Weight of the same-side AO values on the outer edges of the 45deg chamfered column faces. */
@@ -37,7 +48,8 @@ fun Model.columnSide(radius: Double, yBottom: Double, yTop: Double, transform: (
        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.toFloat())))
+            faceOrientedAuto(overrideFace = EAST, corner = cornerInterpolate(Axis.Y, chamferAffinity, Config.roundLogs.dimming.toFloat()))
+        )
        .setAoShader(
            faceOrientedAuto(overrideFace = EAST, corner = cornerInterpolate(Axis.Y, 0.5f, Config.roundLogs.dimming.toFloat())),
            predicate = { v, vi -> vi == 0 || vi == 3}
@@ -79,7 +91,7 @@ fun Model.columnSideSquare(yBottom: Double, yTop: Double, transform: (Quad) -> Q
 * @param[radius] the chamfer radius
 * @param[transform] transformation to apply to the model
 */
-fun Model.columnLid(radius: Double, transform: (Quad)->Quad = { it }) {
+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))
--- a/src/main/kotlin/mods/betterfoliage/client/render/Utils.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/Utils.kt
@@ -1,19 +1,27 @@
@file:JvmName("Utils")
-package mods.betterfoliage.client.render

-import mods.octarinecore.PI2
-import mods.octarinecore.client.render.Model
-import mods.octarinecore.client.render.lighting.PostProcessLambda
-import mods.octarinecore.client.render.Quad
-import mods.octarinecore.common.Double3
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.Rotation
-import mods.octarinecore.common.times
+package mods.betterfoliage.render
+
+import mods.betterfoliage.render.lighting.PostProcessLambda
+import mods.betterfoliage.render.old.Model
+import mods.betterfoliage.render.old.Quad
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.PI2
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.times
 import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
 import net.minecraft.block.material.Material
-import net.minecraft.util.BlockRenderLayer
+import net.minecraft.client.renderer.RenderType
+import net.minecraft.client.renderer.RenderTypeLookup
 import net.minecraft.util.Direction
-import net.minecraft.util.Direction.*
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.Direction.EAST
+import net.minecraft.util.Direction.NORTH
+import net.minecraft.util.Direction.SOUTH
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.Direction.WEST
 import kotlin.math.cos
 import kotlin.math.sin

@@ -30,10 +38,13 @@ val greywash: PostProcessLambda = { _, _, _, _, _ -> setGrey(1.0f) }

 val BlockState.isSnow: Boolean get() = material.let { it == Material.SNOW }

-fun Quad.toCross(rotAxis: Direction, trans: (Quad)->Quad) =
+val DIRT_BLOCKS = listOf(Blocks.DIRT, Blocks.COARSE_DIRT)
+
+fun Quad.toCross(rotAxis: Direction, trans: (Quad) -> Quad) =
    (0..3).map { rotIdx ->
        trans(rotate(Rotation.rot90[rotAxis.ordinal] * rotIdx).mirrorUV(rotIdx > 1, false))
    }
+
 fun Quad.toCross(rotAxis: Direction) = toCross(rotAxis) { it }

 fun xzDisk(modelIdx: Int) = (PI2 * modelIdx / 64.0).let { Double3(cos(it), 0.0, sin(it)) }
@@ -47,7 +58,7 @@ val rotationFromUp = arrayOf(
    Rotation.rot90[NORTH.ordinal]
 )

-fun Model.mix(first: Model, second: Model, predicate: (Int)->Boolean) {
+fun Model.mix(first: Model, second: Model, predicate: (Int) -> Boolean) {
    first.quads.forEachIndexed { qi, quad ->
        val otherQuad = second.quads[qi]
        Quad(
@@ -59,7 +70,9 @@ fun Model.mix(first: Model, second: Model, predicate: (Int)->Boolean) {
    }
 }

-val BlockRenderLayer.isCutout: Boolean get() = (this == BlockRenderLayer.CUTOUT) || (this == BlockRenderLayer.CUTOUT_MIPPED)
+val RenderType.isCutout: Boolean get() = (this == RenderType.getCutout()) || (this == RenderType.getCutoutMipped())

-fun BlockState.canRenderInLayer(layer: BlockRenderLayer) = this.block.canRenderInLayer(this, layer)
-fun BlockState.canRenderInCutout() = this.block.canRenderInLayer(this, BlockRenderLayer.CUTOUT) || this.block.canRenderInLayer(this, BlockRenderLayer.CUTOUT_MIPPED)
+fun BlockState.canRenderInLayer(layer: RenderType) = RenderTypeLookup.canRenderInLayer(this, layer)
+fun BlockState.canRenderInCutout() =
+    RenderTypeLookup.canRenderInLayer(this, RenderType.getCutout()) ||
+    RenderTypeLookup.canRenderInLayer(this, RenderType.getCutoutMipped())
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderAlgae.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderAlgae.kt
@@ -1,17 +1,16 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

-import mods.betterfoliage.BetterFoliage
 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.CombinedContext
-import mods.octarinecore.client.render.RenderDecorator
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.render.DIRT_BLOCKS
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.up1
+import mods.betterfoliage.render.up2
+import mods.betterfoliage.render.old.RenderDecorator
 import net.minecraft.block.material.Material
-import net.minecraft.tags.BlockTags
 import net.minecraft.util.ResourceLocation
 import net.minecraft.world.biome.Biome
-import org.apache.logging.log4j.Level.DEBUG

 class RenderAlgae : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {

@@ -24,9 +23,10 @@ class RenderAlgae : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bu
        Config.enabled && Config.algae.enabled &&
        ctx.state(up2).material == Material.WATER &&
        ctx.state(up1).material == Material.WATER &&
-        BlockTags.DIRT_LIKE.contains(ctx.state.block) &&
-        ctx.biome.category.let { it == Biome.Category.OCEAN || it == Biome.Category.BEACH || it == Biome.Category.RIVER } &&
-        noise[ctx.pos] < Config.algae.population
+        DIRT_BLOCKS.contains(ctx.state.block) &&
+        ctx.biome?.category
+            .let { it == Biome.Category.OCEAN || it == Biome.Category.BEACH || it == Biome.Category.RIVER } &&
+            noise[ctx.pos] < Config.algae.population

    override fun render(ctx: CombinedContext) {
        ctx.render()
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderCactus.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderCactus.kt
@@ -1,29 +1,36 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.render.column.ColumnTextureInfo
-import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.render.*
-import mods.octarinecore.client.render.lighting.*
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.column.ColumnTextureInfo
+import mods.betterfoliage.render.column.SimpleColumnInfo
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerAoMaxGreen
+import mods.betterfoliage.render.lighting.edgeOrientedAuto
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
 import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.Rotation
-import mods.octarinecore.common.config.ModelTextureList
-import mods.octarinecore.common.config.SimpleBlockMatcher
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.config.ModelTextureList
+import mods.betterfoliage.config.SimpleBlockMatcher
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.old.Vertex
 import net.minecraft.block.BlockState
 import net.minecraft.block.CactusBlock
 import net.minecraft.util.Direction.*
-import org.apache.logging.log4j.Level.DEBUG
 import java.util.concurrent.CompletableFuture

 object AsyncCactusDiscovery : ConfigurableModelDiscovery<ColumnTextureInfo>() {
    override val logger = BetterFoliage.logDetail
    override val matchClasses = SimpleBlockMatcher(CactusBlock::class.java)
    override val modelTextures = listOf(ModelTextureList("block/cactus", "top", "bottom", "side"))
-    override fun processModel(state: BlockState, textures: List<String>, atlas: AtlasFuture): CompletableFuture<ColumnTextureInfo>? {
-        val sprites = textures.map { atlas.sprite(Identifier(it)) }
+    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: AtlasFuture): CompletableFuture<ColumnTextureInfo>? {
+        val sprites = textures.map { atlas.sprite(it) }
        return atlas.mapAfter {
            SimpleColumnInfo(
                Axis.Y,
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderConnectedGrass.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderConnectedGrass.kt
@@ -1,19 +1,22 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.texture.GrassRegistry
-import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.client.render.RenderDecorator
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.horizontalDirections
-import mods.octarinecore.common.offset
-import net.minecraft.tags.BlockTags
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.DIRT_BLOCKS
+import mods.betterfoliage.render.isSnow
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.up1
+import mods.betterfoliage.render.up2
+import mods.betterfoliage.texture.GrassRegistry
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.horizontalDirections
+import mods.betterfoliage.util.offset

 class RenderConnectedGrass : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
    override fun isEligible(ctx: CombinedContext) =
        Config.enabled && Config.connectedGrass.enabled &&
-        BlockTags.DIRT_LIKE.contains(ctx.state.block) &&
+        DIRT_BLOCKS.contains(ctx.state.block) &&
        GrassRegistry[ctx, up1] != null &&
        (Config.connectedGrass.snowEnabled || !ctx.state(up2).isSnow)

@@ -31,7 +34,7 @@ class RenderConnectedGrassLog : RenderDecorator(BetterFoliageMod.MOD_ID, BetterF

    override fun isEligible(ctx: CombinedContext) =
        Config.enabled && Config.roundLogs.enabled && Config.roundLogs.connectGrass &&
-        BlockTags.DIRT_LIKE.contains(ctx.state.block) &&
+                DIRT_BLOCKS.contains(ctx.state.block) &&
        LogRegistry[ctx, up1] != null

    override fun render(ctx: CombinedContext) {
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderCoral.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderCoral.kt
@@ -1,21 +1,25 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

-import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.*
-import mods.octarinecore.client.render.lighting.*
-import mods.octarinecore.common.allDirections
-import mods.octarinecore.random
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerFlat
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.rotationFromUp
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.up1
+import mods.betterfoliage.render.up2
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.randomD
 import net.minecraft.block.material.Material
 import net.minecraft.tags.BlockTags
 import net.minecraft.util.Direction.Axis
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
 import net.minecraft.world.biome.Biome
-import org.apache.logging.log4j.Level.DEBUG

 class RenderCoral : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {

@@ -28,7 +32,7 @@ class RenderCoral : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bu
        .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)
+        val separation = randomD(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()

@@ -43,8 +47,9 @@ class RenderCoral : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bu
        (ctx.state(up2).material == Material.WATER || Config.coral.shallowWater) &&
        ctx.state(up1).material == Material.WATER &&
        BlockTags.SAND.contains(ctx.state.block) &&
-        ctx.biome.category.let { it == Biome.Category.OCEAN || it == Biome.Category.BEACH } &&
-        noise[ctx.pos] < Config.coral.population
+        ctx.biome?.category
+            .let { it == Biome.Category.OCEAN || it == Biome.Category.BEACH } &&
+            noise[ctx.pos] < Config.coral.population

    override fun render(ctx: CombinedContext) {
        val baseRender = ctx.render()
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderGrass.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderGrass.kt
@@ -1,34 +1,37 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

 import mods.betterfoliage.BetterFoliage
 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.resource.Identifier
-import mods.betterfoliage.client.texture.GeneratedGrass
-import mods.betterfoliage.client.texture.GrassRegistry
-import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.client.render.Model
-import mods.octarinecore.client.render.RenderDecorator
-import mods.octarinecore.client.render.fullCube
-import mods.octarinecore.client.render.lighting.cornerAo
-import mods.octarinecore.client.render.lighting.cornerFlat
-import mods.octarinecore.client.render.lighting.faceOrientedAuto
-import mods.octarinecore.common.Double3
-import mods.octarinecore.common.allDirections
-import mods.octarinecore.random
-import net.minecraft.tags.BlockTags
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.OptifineCustomColors
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.render.DIRT_BLOCKS
+import mods.betterfoliage.render.down1
+import mods.betterfoliage.render.isSnow
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.generated.GeneratedGrass
+import mods.betterfoliage.texture.GrassRegistry
+import mods.betterfoliage.render.old.Model
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.old.fullCube
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerFlat
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.snowOffset
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.randomD
 import net.minecraft.util.Direction.*
-import org.apache.logging.log4j.Level.DEBUG

 class RenderGrass : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {

    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)
+                    yTop = 0.5 + randomD(heightMin, heightMax)
            )
            .setAoShader(faceOrientedAuto(overrideFace = UP, corner = cornerAo(Axis.Y)))
            .setFlatShader(faceOrientedAuto(overrideFace = UP, corner = cornerFlat))
@@ -53,7 +56,7 @@ class RenderGrass : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bu
    override val onlyOnCutout get() = true

    override fun render(ctx: CombinedContext) {
-        val isConnected = BlockTags.DIRT_LIKE.contains(ctx.state(DOWN).block) || GrassRegistry[ctx, down1] != null
+        val isConnected = DIRT_BLOCKS.contains(ctx.state(DOWN).block) || GrassRegistry[ctx, down1] != null
        val isSnowed = ctx.state(UP).isSnow
        val connectedGrass = isConnected && Config.connectedGrass.enabled && (!isSnowed || Config.connectedGrass.snowEnabled)

--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderLeaves.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderLeaves.kt
@@ -1,22 +1,27 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.OptifineCustomColors
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.betterfoliage.client.resource.Identifier
-import mods.betterfoliage.client.texture.LeafRegistry
-import mods.octarinecore.PI2
-import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.client.render.RenderDecorator
-import mods.octarinecore.client.render.lighting.FlatOffset
-import mods.octarinecore.client.render.lighting.cornerAoMaxGreen
-import mods.octarinecore.client.render.lighting.edgeOrientedAuto
-import mods.octarinecore.common.Double3
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.allDirections
-import mods.octarinecore.common.vec
-import mods.octarinecore.random
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.OptifineCustomColors
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.render.denseLeavesRot
+import mods.betterfoliage.render.isSnow
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.texture.LeafRegistry
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.lighting.FlatOffset
+import mods.betterfoliage.render.lighting.cornerAoMaxGreen
+import mods.betterfoliage.render.lighting.edgeOrientedAuto
+import mods.betterfoliage.render.normalLeavesRot
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.whitewash
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.PI2
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.vec
 import net.minecraft.util.Direction.UP
 import java.lang.Math.cos
 import java.lang.Math.sin
@@ -35,7 +40,7 @@ class RenderLeaves : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.b
    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
+            UP.vec * randomD(-1.0, 1.0) * Config.leaves.vOffset
    }

    override fun isEligible(ctx: CombinedContext) =
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderLilypad.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderLilypad.kt
@@ -1,19 +1,18 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

-import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.client.render.RenderDecorator
-import mods.octarinecore.client.render.lighting.FlatOffsetNoColor
-import mods.octarinecore.common.Int3
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.lighting.FlatOffsetNoColor
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.util.Int3
 import net.minecraft.util.Direction.DOWN
 import net.minecraft.util.Direction.UP
-import org.apache.logging.log4j.Level.DEBUG

 class RenderLilypad : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {

--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderLog.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderLog.kt
@@ -1,20 +1,23 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.config.BlockConfig
-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.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.render.CombinedContext
+import mods.betterfoliage.chunk.ChunkOverlayManager
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.column.AbstractRenderColumn
+import mods.betterfoliage.render.column.ColumnRenderLayer
+import mods.betterfoliage.render.column.ColumnTextureInfo
+import mods.betterfoliage.render.column.SimpleColumnInfo
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelRenderRegistry
+import mods.betterfoliage.resource.discovery.ModelRenderRegistryRoot
 import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.config.ConfigurableBlockMatcher
-import mods.octarinecore.common.config.ModelTextureList
-import mods.octarinecore.tryDefault
+import mods.betterfoliage.config.ConfigurableBlockMatcher
+import mods.betterfoliage.config.ModelTextureList
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.util.tryDefault
 import net.minecraft.block.BlockState
 import net.minecraft.block.LogBlock
 import net.minecraft.util.Direction.Axis
@@ -54,10 +57,10 @@ object AsyncLogDiscovery : ConfigurableModelDiscovery<ColumnTextureInfo>() {
    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.logBlocks
    override val modelTextures: List<ModelTextureList> get() = BlockConfig.logModels.modelList

-    override fun processModel(state: BlockState, textures: List<String>, atlas: AtlasFuture): CompletableFuture<ColumnTextureInfo> {
+    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: AtlasFuture): CompletableFuture<ColumnTextureInfo> {
        val axis = getAxis(state)
        logger.log(Level.DEBUG, "$logName:       axis $axis")
-        val spriteList = textures.map { atlas.sprite(Identifier(it)) }
+        val spriteList = textures.map { atlas.sprite(it) }
        return atlas.mapAfter {
            SimpleColumnInfo(
                axis,
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderMycelium.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderMycelium.kt
@@ -1,22 +1,25 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

-import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.client.render.RenderDecorator
-import mods.octarinecore.client.render.noPost
-import mods.octarinecore.common.Double3
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.isSnow
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.old.noPost
+import mods.betterfoliage.render.snowOffset
+import mods.betterfoliage.render.whitewash
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.util.Double3
 import net.minecraft.util.Direction.UP
-import org.apache.logging.log4j.Level.DEBUG

 class RenderMycelium : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {

    val myceliumIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_mycel_$idx") }
-    val myceliumModel = modelSet(64) { idx -> RenderGrass.grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax)(idx) }
+    val myceliumModel = modelSet(64) { idx -> RenderGrass.grassTopQuads(
+        Config.shortGrass.heightMin,
+        Config.shortGrass.heightMax
+    )(idx) }

    override fun isEligible(ctx: CombinedContext): Boolean {
        if (!Config.enabled || !Config.shortGrass.myceliumEnabled) return false
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderNetherrack.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderNetherrack.kt
@@ -1,25 +1,26 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

-import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.render.*
-import mods.octarinecore.client.render.lighting.*
-import mods.octarinecore.random
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerFlat
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.util.randomD
 import net.minecraft.block.Blocks
 import net.minecraft.util.Direction.Axis
 import net.minecraft.util.Direction.*
-import org.apache.logging.log4j.Level.DEBUG

 class RenderNetherrack : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {

    val netherrackIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_netherrack_$idx") }
    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))
+        yBottom = -0.5 - randomD(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()
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderReeds.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanillaold/RenderReeds.kt
@@ -1,20 +1,22 @@
-package mods.betterfoliage.client.render
+package mods.betterfoliage.render.block.vanillaold

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.client.render.RenderDecorator
-import mods.octarinecore.client.render.lighting.FlatOffsetNoColor
-import mods.octarinecore.client.resource.CenteredSprite
-import mods.octarinecore.random
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.render.DIRT_BLOCKS
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.lighting.FlatOffsetNoColor
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.up1
+import mods.betterfoliage.render.up2
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.resource.generated.CenteredSprite
+import mods.betterfoliage.util.randomD
 import net.minecraft.block.material.Material
-import net.minecraft.tags.BlockTags
 import net.minecraft.util.Direction.UP
-import org.apache.logging.log4j.Level.DEBUG

 class RenderReeds : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {

@@ -24,7 +26,7 @@ class RenderReeds : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bu
        register = { CenteredSprite(it).register(BetterFoliage.asyncPack) }
    )
    val reedModels = modelSet(64) { modelIdx ->
-        val height = random(Config.reed.heightMin, Config.reed.heightMax)
+        val height = randomD(Config.reed.heightMin, Config.reed.heightMax)
        val waterline = 0.875f
        val vCutLine = 0.5 - waterline / height
        listOf(
@@ -45,9 +47,10 @@ class RenderReeds : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bu
        Config.enabled && Config.reed.enabled &&
        ctx.state(up2).material == Material.AIR &&
        ctx.state(UP).material == Material.WATER &&
-        BlockTags.DIRT_LIKE.contains(ctx.state.block) &&
-        ctx.biome.let { it.downfall > Config.reed.minBiomeRainfall && it.defaultTemperature >= Config.reed.minBiomeTemp } &&
-        noise[ctx.pos] < Config.reed.population
+        DIRT_BLOCKS.contains(ctx.state.block) &&
+        ctx.biome
+            ?.let { it.downfall > Config.reed.minBiomeRainfall && it.defaultTemperature >= Config.reed.minBiomeTemp } ?: false &&
+            noise[ctx.pos] < Config.reed.population

    override val onlyOnCutout get() = false

--- a/src/main/kotlin/mods/betterfoliage/client/render/column/AbstractRenderer.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/column/AbstractRenderer.kt
@@ -1,20 +1,19 @@
-package mods.betterfoliage.client.render.column
+package mods.betterfoliage.render.column

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.chunk.ChunkOverlayManager
-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.CombinedContext
-import mods.octarinecore.client.render.Model
-import mods.octarinecore.client.render.RenderDecorator
-import mods.octarinecore.client.render.noPost
-import mods.octarinecore.common.Rotation
-import mods.octarinecore.common.face
-import mods.octarinecore.common.rot
+import mods.betterfoliage.chunk.ChunkOverlayManager
+import mods.betterfoliage.integration.ShadersModIntegration.renderAs
+import mods.betterfoliage.render.*
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.*
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.*
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.Model
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.old.noPost
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.face
+import mods.betterfoliage.util.rot
 import net.minecraft.block.BlockRenderType.MODEL
 import net.minecraft.util.Direction.*
 import net.minecraftforge.eventbus.api.IEventBus
--- a/src/main/kotlin/mods/betterfoliage/client/render/column/OverlayLayer.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/column/OverlayLayer.kt
@@ -1,22 +1,25 @@
-package mods.betterfoliage.client.render.column
+package mods.betterfoliage.render.column

-import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.client.chunk.ChunkOverlayLayer
-import mods.betterfoliage.client.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.chunk.dimType
-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.BlockCtx
-import mods.octarinecore.client.resource.ModelRenderRegistry
-import mods.octarinecore.common.*
+import mods.betterfoliage.chunk.ChunkOverlayLayer
+import mods.betterfoliage.chunk.ChunkOverlayManager
+import mods.betterfoliage.chunk.dimType
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.*
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.*
+import mods.betterfoliage.render.rotationFromUp
+import mods.betterfoliage.render.old.BlockCtx
+import mods.betterfoliage.resource.discovery.ModelRenderRegistry
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.face
+import mods.betterfoliage.util.plus
 import net.minecraft.block.BlockState
 import net.minecraft.util.Direction.Axis
 import net.minecraft.util.Direction.AxisDirection
 import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IEnviromentBlockReader
+import net.minecraft.world.ILightReader

 /** Index of SOUTH-EAST quadrant. */
 const val SE = 0
@@ -68,7 +71,7 @@ abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {

    val allNeighborOffsets = (-1..1).flatMap { offsetX -> (-1..1).flatMap { offsetY -> (-1..1).map { offsetZ -> Int3(offsetX, offsetY, offsetZ) }}}

-    override fun onBlockUpdate(world: IEnviromentBlockReader, pos: BlockPos) {
+    override fun onBlockUpdate(world: ILightReader, pos: BlockPos) {
        allNeighborOffsets.forEach { offset -> ChunkOverlayManager.clear(world.dimType, this, pos + offset) }
    }

--- a/src/main/kotlin/mods/betterfoliage/client/render/column/RenderData.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/column/RenderData.kt
@@ -1,7 +1,7 @@
-package mods.betterfoliage.client.render.column
+package mods.betterfoliage.render.column

-import mods.octarinecore.client.render.lighting.QuadIconResolver
-import mods.octarinecore.common.rotate
+import mods.betterfoliage.render.lighting.QuadIconResolver
+import mods.betterfoliage.util.rotate
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
 import net.minecraft.util.Direction.*

--- a/src/main/kotlin/mods/betterfoliage/render/lighting/Lighting.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/lighting/Lighting.kt
@@ -0,0 +1,158 @@
+package mods.betterfoliage.render.lighting
+
+import mods.betterfoliage.render.old.Quad
+import mods.betterfoliage.render.old.Vertex
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.axes
+import mods.betterfoliage.util.boxEdges
+import mods.betterfoliage.util.boxFaces
+import mods.betterfoliage.util.face
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.nearestAngle
+import mods.betterfoliage.util.nearestPosition
+import mods.betterfoliage.util.perpendiculars
+import mods.betterfoliage.util.vec
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.*
+import java.lang.Math.min
+
+typealias EdgeShaderFactory = (Direction, Direction) -> ModelLighter
+typealias CornerShaderFactory = (Direction, Direction, Direction) -> ModelLighter
+typealias ShaderFactory = (Quad, Vertex) -> ModelLighter
+
+/** Holds lighting values for block corners as calculated by vanilla Minecraft rendering. */
+class CornerLightData {
+    var valid = false
+    var brightness = 0
+    var red: Float = 0.0f
+    var green: Float = 0.0f
+    var blue: Float = 0.0f
+
+    fun reset() { valid = false }
+
+    fun set(brightness: Int, red: Float, green: Float, blue: Float) {
+        if (valid) return
+        this.valid = true
+        this.brightness = brightness
+        this.red = red
+        this.green = green
+        this.blue = blue
+    }
+
+    fun set(brightness: Int, colorMultiplier: Float) {
+        this.valid = true
+        this.brightness = brightness
+        this.red = colorMultiplier
+        this.green = colorMultiplier
+        this.blue = colorMultiplier
+    }
+
+    companion object {
+        val black: CornerLightData get() = CornerLightData()
+    }
+}
+
+/**
+ * Instances of this interface are associated with [Model] vertices, and used to apply brightness and color
+ * values to a [RenderVertex].
+ */
+interface ModelLighter {
+    /**
+     * Set shading values of a [RenderVertex]
+     *
+     * @param[context] context that can be queried for lighting data in a [Model]-relative frame of reference
+     * @param[vertex] the [RenderVertex] to manipulate
+     */
+    fun shade(context: LightingCtx, vertex: RenderVertex)
+
+    /**
+     * Return a new rotated version of this [ModelLighter]. Used during [Model] setup when rotating the model itself.
+     */
+    fun rotate(rot: Rotation): ModelLighter
+
+    /** Set all lighting values on the [RenderVertex] to match the given [CornerLightData]. */
+    fun RenderVertex.shade(shading: CornerLightData) {
+        brightness = shading.brightness; red = shading.red; green = shading.green; blue = shading.blue
+    }
+
+    /** Set the lighting values on the [RenderVertex] to a weighted average of the two [CornerLightData] instances. */
+    fun RenderVertex.shade(shading1: CornerLightData, shading2: CornerLightData, weight1: Float = 0.5f, weight2: Float = 0.5f) {
+        red = min(shading1.red * weight1 + shading2.red * weight2, 1.0f)
+        green = min(shading1.green * weight1 + shading2.green * weight2, 1.0f)
+        blue = min(shading1.blue * weight1 + shading2.blue * weight2, 1.0f)
+        brightness = brWeighted(shading1.brightness, weight1, shading2.brightness, weight2)
+    }
+
+    /**
+     * Set the lighting values on the [RenderVertex] directly.
+     *
+     * @param[brightness] packed brightness value
+     * @param[color] packed color value
+     */
+    fun RenderVertex.shade(brightness: Int, color: Int) {
+        this.brightness = brightness; setColor(color)
+    }
+}
+
+/**
+ * Returns a [ModelLighter] resolver for quads that point towards one of the 6 block faces.
+ * The resolver works the following way:
+ *   - determines which face the _quad_ normal points towards (if not overridden)
+ *   - determines the distance of the _vertex_ to the corners and edge midpoints on that block face
+ *   - if _corner_ is given, and the _vertex_ is closest to a block corner, returns the [ModelLighter] created by _corner_
+ *   - if _edge_ is given, and the _vertex_ is closest to an edge midpoint, returns the [ModelLighter] created by _edge_
+ *
+ * @param[overrideFace] assume the given face instead of going by the _quad_ normal
+ * @param[corner] [ModelLighter] instantiation lambda for corner vertices
+ * @param[edge] [ModelLighter] instantiation lambda for edge midpoint vertices
+ */
+fun faceOrientedAuto(overrideFace: Direction? = null,
+                     corner: CornerShaderFactory? = null,
+                     edge: EdgeShaderFactory? = null) =
+    fun(quad: Quad, vertex: Vertex): ModelLighter {
+        val quadFace = overrideFace ?: quad.normal.nearestCardinal
+        val nearestCorner = nearestPosition(vertex.xyz, boxFaces[quadFace].allCorners) {
+            (quadFace.vec + it.first.vec + it.second.vec) * 0.5
+        }
+        val nearestEdge = nearestPosition(vertex.xyz, quadFace.perpendiculars) {
+            (quadFace.vec + it.vec) * 0.5
+        }
+        if (edge != null && (nearestEdge.second < nearestCorner.second || corner == null))
+            return edge(quadFace, nearestEdge.first)
+        else return corner!!(quadFace, nearestCorner.first.first, nearestCorner.first.second)
+    }
+
+/**
+ * Returns a ModelLighter resolver for quads that point towards one of the 12 block edges.
+ * The resolver works the following way:
+ *   - determines which edge the _quad_ normal points towards (if not overridden)
+ *   - determines which face midpoint the _vertex_ is closest to, of the 2 block faces that share this edge
+ *   - determines which block corner _of this face_ the _vertex_ is closest to
+ *   - returns the [ModelLighter] created by _corner_
+ *
+ * @param[overrideEdge] assume the given edge instead of going by the _quad_ normal
+ * @param[corner] ModelLighter instantiation lambda
+ */
+fun edgeOrientedAuto(overrideEdge: Pair<Direction, Direction>? = null,
+                     corner: CornerShaderFactory
+) =
+    fun(quad: Quad, vertex: Vertex): ModelLighter {
+        val edgeDir = overrideEdge ?: nearestAngle(quad.normal, boxEdges) { it.first.vec + it.second.vec }.first
+        val nearestFace = nearestPosition(vertex.xyz, edgeDir.toList()) { it.vec }.first
+        val nearestCorner = nearestPosition(vertex.xyz, boxFaces[nearestFace].allCorners) {
+            (nearestFace.vec + it.first.vec + it.second.vec) * 0.5
+        }.first
+        return corner(nearestFace, nearestCorner.first, nearestCorner.second)
+    }
+
+fun faceOrientedInterpolate(overrideFace: Direction? = null) =
+    fun(quad: Quad, vertex: Vertex): ModelLighter {
+        val resolver = faceOrientedAuto(overrideFace, edge = { face, edgeDir ->
+            val axis = axes.find { it != face.axis && it != edgeDir.axis }!!
+            val vec = Double3((axis to AxisDirection.POSITIVE).face)
+            val pos = vertex.xyz.dot(vec)
+            EdgeInterpolateFallback(face, edgeDir, pos)
+        })
+        return resolver(quad, vertex)
+    }
--- a/src/main/kotlin/mods/betterfoliage/render/lighting/LightingContext.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/lighting/LightingContext.kt
@@ -0,0 +1,118 @@
+package mods.betterfoliage.render.lighting
+
+import mods.betterfoliage.render.old.BlockCtx
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.boxFaces
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.offset
+import mods.betterfoliage.util.plus
+import mods.betterfoliage.util.rotate
+import net.minecraft.client.Minecraft
+import net.minecraft.client.renderer.BlockModelRenderer
+import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.util.Direction
+import java.util.*
+
+val Direction.aoMultiplier: Float get() = when(this) {
+    Direction.UP -> 1.0f
+    Direction.DOWN -> 0.5f
+    Direction.NORTH, Direction.SOUTH -> 0.8f
+    Direction.EAST, Direction.WEST -> 0.6f
+}
+
+interface LightingCtx {
+    val modelRotation: Rotation
+    val blockContext: BlockCtx
+    val aoEnabled: Boolean
+
+    val brightness get() = brightness(Int3.zero)
+    val color get() = color(Int3.zero)
+    fun brightness(face: Direction) = brightness(face.offset)
+    fun color(face: Direction) = color(face.offset)
+
+    fun brightness(offset: Int3) = offset.rotate(modelRotation).let {
+        WorldRenderer.getCombinedLight(blockContext.world, blockContext.pos + it)
+    }
+    fun color(offset: Int3) = blockContext.offset(offset.rotate(modelRotation)).let { Minecraft.getInstance().blockColors.getColor(it.state, it.world, it.pos, 0) }
+
+    fun lighting(face: Direction, corner1: Direction, corner2: Direction): CornerLightData
+}
+
+class DefaultLightingCtx(blockContext: BlockCtx) : LightingCtx {
+    override var modelRotation = Rotation.identity
+
+    override var aoEnabled = false
+        protected set
+    override var blockContext: BlockCtx = blockContext
+        protected set
+    override var brightness = brightness(Int3.zero)
+        protected set
+    override var color = color(Int3.zero)
+        protected set
+
+    override fun brightness(face: Direction) = brightness(face.offset)
+    override fun color(face: Direction) = color(face.offset)
+
+    // smooth lighting stuff
+    val lightingData = Array(6) { FaceLightData(allDirections[it]) }
+    override fun lighting(face: Direction, corner1: Direction, corner2: Direction): CornerLightData = lightingData[face.rotate(modelRotation)].let { faceData ->
+        if (!faceData.isValid) faceData.update(blockContext, faceData.face.aoMultiplier)
+        return faceData[corner1.rotate(modelRotation), corner2.rotate(modelRotation)]
+    }
+
+    fun reset(blockContext: BlockCtx) {
+        this.blockContext = blockContext
+        brightness = brightness(Int3.zero)
+        color = color(Int3.zero)
+        modelRotation = Rotation.identity
+        lightingData.forEach { it.isValid = false }
+        aoEnabled = Minecraft.isAmbientOcclusionEnabled()
+//        allDirections.forEach { lightingData[it].update(blockContext, it.aoMultiplier) }
+    }
+}
+
+private val vanillaAOFactory = BlockModelRenderer.AmbientOcclusionFace::class.java.let {
+    it.getDeclaredConstructor(BlockModelRenderer::class.java).apply { isAccessible = true }
+}.let { ctor -> { ctor.newInstance(Minecraft.getInstance().blockRendererDispatcher.blockModelRenderer) } }
+
+class FaceLightData(val face: Direction) {
+    val topDir = boxFaces[face].top
+    val leftDir = boxFaces[face].left
+
+    val topLeft = CornerLightData()
+    val topRight = CornerLightData()
+    val bottomLeft = CornerLightData()
+    val bottomRight = CornerLightData()
+
+    val vanillaOrdered = when(face) {
+        Direction.DOWN -> listOf(topLeft, bottomLeft, bottomRight, topRight)
+        Direction.UP -> listOf(bottomRight, topRight, topLeft, bottomLeft)
+        Direction.NORTH -> listOf(bottomLeft, bottomRight, topRight, topLeft)
+        Direction.SOUTH -> listOf(topLeft, bottomLeft, bottomRight, topRight)
+        Direction.WEST -> listOf(bottomLeft, bottomRight, topRight, topLeft)
+        Direction.EAST -> listOf(topRight, topLeft, bottomLeft, bottomRight)
+    }
+
+    val delegate = vanillaAOFactory()
+    var isValid = false
+
+    fun update(blockCtx: BlockCtx, multiplier: Float) {
+        val quadBounds = FloatArray(12)
+        val flags = BitSet(3).apply { set(0) }
+//        delegate.updateVertexBrightness(blockCtx.world, blockCtx.state, blockCtx.pos, face, quadBounds, flags)
+        vanillaOrdered.forEachIndexed { idx, corner -> corner.set(delegate.vertexBrightness[idx], delegate.vertexColorMultiplier[idx] * multiplier) }
+        isValid = true
+    }
+
+    operator fun get(dir1: Direction, dir2: Direction): CornerLightData {
+        val isTop = topDir == dir1 || topDir == dir2
+        val isLeft = leftDir == dir1 || leftDir == dir2
+        return if (isTop) {
+            if (isLeft) topLeft else topRight
+        } else {
+            if (isLeft) bottomLeft else bottomRight
+        }
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/render/lighting/ModelLighters.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/lighting/ModelLighters.kt
@@ -0,0 +1,162 @@
+package mods.betterfoliage.render.lighting
+
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.axes
+import mods.betterfoliage.util.boxFaces
+import mods.betterfoliage.util.face
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.offset
+import mods.betterfoliage.util.rotate
+import net.minecraft.util.Direction
+
+
+const val defaultCornerDimming = 0.5f
+const val defaultEdgeDimming = 0.8f
+
+// ================================
+// Shader instantiation lambdas
+// ================================
+fun cornerAo(fallbackAxis: Direction.Axis): CornerShaderFactory = { face, dir1, dir2 ->
+    val fallbackDir = listOf(face, dir1, dir2).find { it.axis == fallbackAxis }!!
+    CornerSingleFallback(face, dir1, dir2, fallbackDir)
+}
+val cornerFlat = { face: Direction, dir1: Direction, dir2: Direction -> FaceFlat(face) }
+fun cornerAoTri(func: (CornerLightData, CornerLightData)-> CornerLightData) = { face: Direction, dir1: Direction, dir2: Direction ->
+    CornerTri(face, dir1, dir2, func)
+}
+val cornerAoMaxGreen = cornerAoTri { s1, s2 -> if (s1.green > s2.green) s1 else s2 }
+
+fun cornerInterpolate(edgeAxis: Direction.Axis, weight: Float, dimming: Float): CornerShaderFactory = { dir1, dir2, dir3 ->
+    val edgeDir = listOf(dir1, dir2, dir3).find { it.axis == edgeAxis }!!
+    val faceDirs = listOf(dir1, dir2, dir3).filter { it.axis != edgeAxis }
+    CornerInterpolateDimming(faceDirs[0], faceDirs[1], edgeDir, weight, dimming)
+}
+
+// ================================
+// Shaders
+// ================================
+object NoLighting : ModelLighter {
+    override fun shade(context: LightingCtx, vertex: RenderVertex) = vertex.shade(CornerLightData.black)
+    override fun rotate(rot: Rotation) = this
+}
+
+class CornerSingleFallback(val face: Direction, val dir1: Direction, val dir2: Direction, val fallbackDir: Direction, val fallbackDimming: Float = defaultCornerDimming) :
+    ModelLighter {
+    val offset = Int3(fallbackDir)
+    override fun shade(context: LightingCtx, vertex: RenderVertex) {
+        val shading = context.lighting(face, dir1, dir2)
+        if (shading.valid)
+            vertex.shade(shading)
+        else {
+            vertex.shade(context.brightness(offset) brMul fallbackDimming, context.color(offset) colorMul fallbackDimming)
+        }
+    }
+    override fun rotate(rot: Rotation) = CornerSingleFallback(face.rotate(rot), dir1.rotate(rot), dir2.rotate(rot), fallbackDir.rotate(rot), fallbackDimming)
+}
+
+inline fun accumulate(v1: CornerLightData?, v2: CornerLightData?, func: ((CornerLightData, CornerLightData)-> CornerLightData)): CornerLightData? {
+    val v1ok = v1 != null && v1.valid
+    val v2ok = v2 != null && v2.valid
+    if (v1ok && v2ok) return func(v1!!, v2!!)
+    if (v1ok) return v1
+    if (v2ok) return v2
+    return null
+}
+
+class CornerTri(val face: Direction, val dir1: Direction, val dir2: Direction,
+                val func: ((CornerLightData, CornerLightData)-> CornerLightData)) : ModelLighter {
+    override fun shade(context: LightingCtx, vertex: RenderVertex) {
+        var acc = accumulate(
+            context.lighting(face, dir1, dir2),
+            context.lighting(dir1, face, dir2),
+            func)
+        acc = accumulate(
+            acc,
+            context.lighting(dir2, face, dir1),
+            func)
+        vertex.shade(acc ?: CornerLightData.black)
+    }
+    override fun rotate(rot: Rotation) = CornerTri(face.rotate(rot), dir1.rotate(rot), dir2.rotate(rot), func)
+}
+
+class EdgeInterpolateFallback(val face: Direction, val edgeDir: Direction, val pos: Double, val fallbackDimming: Float = defaultEdgeDimming):
+    ModelLighter {
+    val offset = Int3(edgeDir)
+    val edgeAxis = axes.find { it != face.axis && it != edgeDir.axis }!!
+    val weightN = (0.5 - pos).toFloat()
+    val weightP = (0.5 + pos).toFloat()
+
+    override fun shade(context: LightingCtx, vertex: RenderVertex) {
+        val shadingP = context.lighting(face, edgeDir, (edgeAxis to Direction.AxisDirection.POSITIVE).face)
+        val shadingN = context.lighting(face, edgeDir, (edgeAxis to Direction.AxisDirection.NEGATIVE).face)
+        if (!shadingP.valid && !shadingN.valid)  {
+            return vertex.shade(context.brightness(offset) brMul fallbackDimming, context.color(offset) colorMul fallbackDimming)
+        }
+        if (!shadingP.valid) return vertex.shade(shadingN)
+        if (!shadingN.valid) return vertex.shade(shadingP)
+        vertex.shade(shadingP, shadingN, weightP, weightN)
+    }
+    override fun rotate(rot: Rotation) = EdgeInterpolateFallback(face.rotate(rot), edgeDir.rotate(rot), pos)
+}
+
+class CornerInterpolateDimming(val face1: Direction, val face2: Direction, val edgeDir: Direction,
+                               val weight: Float, val dimming: Float, val fallbackDimming: Float = defaultCornerDimming
+) : ModelLighter {
+    val offset = Int3(edgeDir)
+    override fun shade(context: LightingCtx, vertex: RenderVertex) {
+        var shading1 = context.lighting(face1, edgeDir, face2)
+        var shading2 = context.lighting(face2, edgeDir, face1)
+        var weight1 = weight
+        var weight2 = 1.0f - weight
+        if (!shading1.valid && !shading2.valid) {
+            return vertex.shade(context.brightness(offset) brMul fallbackDimming, context.color(offset) colorMul fallbackDimming)
+        }
+        if (!shading1.valid) { shading1 = shading2; weight1 *= dimming }
+        if (!shading2.valid) { shading2 = shading1; weight2 *= dimming }
+        vertex.shade(shading1, shading2, weight1, weight2)
+    }
+
+    override fun rotate(rot: Rotation) =
+        CornerInterpolateDimming(face1.rotate(rot), face2.rotate(rot), edgeDir.rotate(rot), weight, dimming, fallbackDimming)
+}
+
+class FaceCenter(val face: Direction): ModelLighter {
+    override fun shade(context: LightingCtx, vertex: RenderVertex) {
+        vertex.red = 0.0f; vertex.green = 0.0f; vertex.blue = 0.0f;
+        val b = IntArray(4)
+        boxFaces[face].allCorners.forEachIndexed { idx, corner ->
+            val shading = context.lighting(face, corner.first, corner.second)
+            vertex.red += shading.red
+            vertex.green += shading.green
+            vertex.blue += shading.blue
+            b[idx] = shading.brightness
+        }
+        vertex.apply { red *= 0.25f; green *= 0.25f; blue *= 0.25f }
+        vertex.brightness = brSum(0.25f, *b)
+    }
+    override fun rotate(rot: Rotation) = FaceCenter(face.rotate(rot))
+}
+
+class FaceFlat(val face: Direction): ModelLighter {
+    override fun shade(context: LightingCtx, vertex: RenderVertex) {
+        vertex.shade(context.brightness(face.offset), context.color(Int3.zero))
+    }
+    override fun rotate(rot: Rotation): ModelLighter = FaceFlat(face.rotate(rot))
+}
+
+class FlatOffset(val offset: Int3): ModelLighter {
+    override fun shade(context: LightingCtx, vertex: RenderVertex)  {
+        vertex.brightness = context.brightness(offset)
+        vertex.setColor(context.color(offset))
+    }
+    override fun rotate(rot: Rotation): ModelLighter = this
+}
+
+class FlatOffsetNoColor(val offset: Int3): ModelLighter {
+    override fun shade(context: LightingCtx, vertex: RenderVertex)  {
+        vertex.brightness = context.brightness(offset)
+        vertex.red = 1.0f; vertex.green = 1.0f; vertex.blue = 1.0f
+    }
+    override fun rotate(rot: Rotation): ModelLighter = this
+}
--- a/src/main/kotlin/mods/betterfoliage/render/lighting/PixelFormat.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/lighting/PixelFormat.kt
@@ -0,0 +1,3 @@
+@file:JvmName("PixelFormat")
+package mods.betterfoliage.render.lighting
+
--- a/src/main/kotlin/mods/betterfoliage/render/lighting/Vertex.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/lighting/Vertex.kt
@@ -0,0 +1,146 @@
+package mods.betterfoliage.render.lighting
+
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.Quad
+import mods.betterfoliage.render.old.Vertex
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Rotation
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.Direction.*
+import java.awt.Color
+
+typealias QuadIconResolver = (CombinedContext, Int, Quad) -> TextureAtlasSprite?
+typealias PostProcessLambda = RenderVertex.(CombinedContext, Int, Quad, Int, Vertex) -> Unit
+
+@Suppress("NOTHING_TO_INLINE")
+class RenderVertex {
+    var x: Double = 0.0
+    var y: Double = 0.0
+    var z: Double = 0.0
+    var u: Double = 0.0
+    var v: Double = 0.0
+    var brightness: Int = 0
+    var red: Float = 0.0f
+    var green: Float = 0.0f
+    var blue: Float = 0.0f
+
+    val rawData = IntArray(7)
+
+    fun init(vertex: Vertex, rot: Rotation, trans: Double3): RenderVertex {
+        val result = vertex.xyz.rotate(rot) + trans
+        x = result.x; y = result.y; z = result.z
+        return this
+    }
+    fun init(vertex: Vertex): RenderVertex {
+        x = vertex.xyz.x; y = vertex.xyz.y; z = vertex.xyz.z;
+        u = vertex.uv.u; v = vertex.uv.v
+        return this
+    }
+    fun translate(trans: Double3): RenderVertex { x += trans.x; y += trans.y; z += trans.z; return this }
+    fun rotate(rot: Rotation): RenderVertex {
+        if (rot === Rotation.identity) return this
+        val rotX = rot.rotatedComponent(EAST, x, y, z)
+        val rotY = rot.rotatedComponent(UP, x, y, z)
+        val rotZ = rot.rotatedComponent(SOUTH, x, y, z)
+        x = rotX; y = rotY; z = rotZ
+        return this
+    }
+    inline fun rotateUV(n: Int): RenderVertex {
+        when (n % 4) {
+            1 -> { val t = v; v = -u; u = t; return this }
+            2 -> { u = -u; v = -v; return this }
+            3 -> { val t = -v; v = u; u = t; return this }
+            else -> { return this }
+        }
+    }
+    inline fun mirrorUV(mirrorU: Boolean, mirrorV: Boolean) {
+        if (mirrorU) u = -u
+        if (mirrorV) v = -v
+    }
+    inline fun setIcon(icon: TextureAtlasSprite): RenderVertex {
+        u = (icon.maxU - icon.minU) * (u + 0.5) + icon.minU
+        v = (icon.maxV - icon.minV) * (v + 0.5) + icon.minV
+        return this
+    }
+
+    inline fun setGrey(level: Float) {
+        val grey = Math.min((red + green + blue) * 0.333f * level, 1.0f)
+        red = grey; green = grey; blue = grey
+    }
+    inline fun multiplyColor(color: Int) {
+        red *= (color shr 16 and 255) / 256.0f
+        green *= (color shr 8 and 255) / 256.0f
+        blue *= (color and 255) / 256.0f
+    }
+    inline fun setColor(color: Int) {
+        red = (color shr 16 and 255) / 256.0f
+        green = (color shr 8 and 255) / 256.0f
+        blue = (color and 255) / 256.0f
+    }
+
+}
+
+/** List of bit-shift offsets in packed brightness values where meaningful (4-bit) data is contained. */
+var brightnessComponents = listOf(20, 4)
+
+/** Multiply the components of this packed brightness value with the given [Float]. */
+infix fun Int.brMul(f: Float): Int {
+    val weight = (f * 256.0f).toInt()
+    var result = 0
+    brightnessComponents.forEach { shift ->
+        val raw = (this shr shift) and 15
+        val weighted = (raw) * weight / 256
+        result = result or (weighted shl shift)
+    }
+    return result
+}
+
+/** Multiply the components of this packed color value with the given [Float]. */
+infix fun Int.colorMul(f: Float): Int {
+    val weight = (f * 256.0f).toInt()
+    val red = (this shr 16 and 255) * weight / 256
+    val green = (this shr 8 and 255) * weight / 256
+    val blue = (this and 255) * weight / 256
+    return (red shl 16) or (green shl 8) or blue
+}
+
+/** Sum the components of all packed brightness values given. */
+fun brSum(multiplier: Float?, vararg brightness: Int): Int {
+    val sum = Array(brightnessComponents.size) { 0 }
+    brightnessComponents.forEachIndexed { idx, shift -> brightness.forEach { br ->
+        val comp = (br shr shift) and 15
+        sum[idx] += comp
+    } }
+    var result = 0
+    brightnessComponents.forEachIndexed { idx, shift ->
+        val comp = if (multiplier == null)
+            ((sum[idx]) shl shift)
+        else
+            ((sum[idx].toFloat() * multiplier).toInt() shl shift)
+        result = result or comp
+    }
+    return result
+}
+
+fun brWeighted(br1: Int, weight1: Float, br2: Int, weight2: Float): Int {
+    val w1int = (weight1 * 256.0f + 0.5f).toInt()
+    val w2int = (weight2 * 256.0f + 0.5f).toInt()
+    var result = 0
+    brightnessComponents.forEachIndexed { idx, shift ->
+        val comp1 = (br1 shr shift) and 15
+        val comp2 = (br2 shr shift) and 15
+        val compWeighted = (comp1 * w1int + comp2 * w2int) / 256
+        result = result or ((compWeighted and 15) shl shift)
+    }
+    return result
+}
+
+data class HSB(var hue: Float, var saturation: Float, var brightness: Float) {
+    companion object {
+        fun fromColor(color: Int): HSB {
+            val hsbVals = Color.RGBtoHSB((color shr 16) and 255, (color shr 8) and 255, color and 255, null)
+            return HSB(hsbVals[0], hsbVals[1], hsbVals[2])
+        }
+    }
+    val asColor: Int get() = Color.HSBtoRGB(hue, saturation, brightness)
+}
--- a/src/main/kotlin/mods/betterfoliage/render/old/AbstractEntityFX.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/old/AbstractEntityFX.kt
@@ -0,0 +1,127 @@
+package mods.betterfoliage.render.old
+
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.PI2
+import net.minecraft.client.Minecraft
+import net.minecraft.client.particle.IParticleRenderType
+import net.minecraft.client.particle.SpriteTexturedParticle
+import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.world.World
+import kotlin.math.cos
+import kotlin.math.sin
+
+abstract class AbstractEntityFX(world: World, x: Double, y: Double, z: Double) : SpriteTexturedParticle(world, x, y, z) {
+
+    companion object {
+        @JvmStatic val sin = Array(64) { idx -> sin(PI2 / 64.0 * idx) }
+        @JvmStatic val cos = Array(64) { idx -> cos(PI2 / 64.0 * idx) }
+    }
+
+    val billboardRot = Pair(Double3.zero, Double3.zero)
+    val currentPos = Double3.zero
+    val prevPos = Double3.zero
+    val velocity = Double3.zero
+
+    override fun tick() {
+        super.tick()
+        currentPos.setTo(posX, posY, posZ)
+        prevPos.setTo(prevPosX, prevPosY, prevPosZ)
+        velocity.setTo(motionX, motionY, motionZ)
+        update()
+        posX = currentPos.x; posY = currentPos.y; posZ = currentPos.z;
+        motionX = velocity.x; motionY = velocity.y; motionZ = velocity.z;
+    }
+
+    /** Render the particle. */
+    abstract fun render(worldRenderer: BufferBuilder, partialTickTime: Float)
+
+    /** Update particle on world tick. */
+    abstract fun update()
+
+    /** True if the particle is renderable. */
+    abstract val isValid: Boolean
+
+    /** Add the particle to the effect renderer if it is valid. */
+    fun addIfValid() { if (isValid) Minecraft.getInstance().particles.addEffect(this) }
+
+//    override fun renderParticle(buffer: BufferBuilder, entity: ActiveRenderInfo, partialTicks: Float, rotX: Float, rotZ: Float, rotYZ: Float, rotXY: Float, rotXZ: Float) {
+//        billboardRot.first.setTo(rotX + rotXY, rotZ, rotYZ + rotXZ)
+//        billboardRot.second.setTo(rotX - rotXY, -rotZ, rotYZ - rotXZ)
+//        render(buffer, partialTicks)
+//    }
+    /**
+     * Render a particle quad.
+     *
+     * @param[tessellator] the [Tessellator] instance to use
+     * @param[partialTickTime] partial tick time
+     * @param[currentPos] render position
+     * @param[prevPos] previous tick position for interpolation
+     * @param[size] particle size
+     * @param[rotation] viewpoint-dependent particle rotation (64 steps)
+     * @param[icon] particle texture
+     * @param[isMirrored] mirror particle texture along V-axis
+     * @param[alpha] aplha blending
+     */
+//    fun renderParticleQuad(worldRenderer: BufferBuilder,
+//                           partialTickTime: Float,
+//                           currentPos: Double3 = this.currentPos,
+//                           prevPos: Double3 = this.prevPos,
+//                           size: Double = particleScale.toDouble(),
+//                           rotation: Int = 0,
+//                           icon: TextureAtlasSprite = sprite,
+//                           isMirrored: Boolean = false,
+//                           alpha: Float = this.particleAlpha) {
+//
+//        val minU = (if (isMirrored) icon.minU else icon.maxU).toDouble()
+//        val maxU = (if (isMirrored) icon.maxU else icon.minU).toDouble()
+//        val minV = icon.minV.toDouble()
+//        val maxV = icon.maxV.toDouble()
+//
+//        val center = currentPos.copy().sub(prevPos).mul(partialTickTime.toDouble()).add(prevPos).sub(interpPosX, interpPosY, interpPosZ)
+//        val v1 = if (rotation == 0) billboardRot.first * size else
+//            Double3.weight(billboardRot.first, cos[rotation and 63] * size, billboardRot.second, sin[rotation and 63] * size)
+//        val v2 = if (rotation == 0) billboardRot.second * size else
+//            Double3.weight(billboardRot.first, -sin[rotation and 63] * size, billboardRot.second, cos[rotation and 63] * size)
+//
+//        val renderBrightness = this.getBrightnessForRender(partialTickTime)
+//        val brLow = renderBrightness shr 16 and 65535
+//        val brHigh = renderBrightness and 65535
+//
+//        worldRenderer
+//            .pos(center.x - v1.x, center.y - v1.y, center.z - v1.z)
+//            .tex(maxU, maxV)
+//            .color(particleRed, particleGreen, particleBlue, alpha)
+//            .lightmap(brLow, brHigh)
+//            .endVertex()
+//
+//        worldRenderer
+//            .pos(center.x - v2.x, center.y - v2.y, center.z - v2.z)
+//            .tex(maxU, minV)
+//            .color(particleRed, particleGreen, particleBlue, alpha)
+//            .lightmap(brLow, brHigh)
+//            .endVertex()
+//
+//        worldRenderer
+//            .pos(center.x + v1.x, center.y + v1.y, center.z + v1.z)
+//            .tex(minU, minV)
+//            .color(particleRed, particleGreen, particleBlue, alpha)
+//            .lightmap(brLow, brHigh)
+//            .endVertex()
+//
+//        worldRenderer
+//            .pos(center.x + v2.x, center.y + v2.y, center.z + v2.z)
+//            .tex(minU, maxV)
+//            .color(particleRed, particleGreen, particleBlue, alpha)
+//            .lightmap(brLow, brHigh)
+//            .endVertex()
+//    }
+
+    //    override fun getFXLayer() = 1
+    override fun getRenderType(): IParticleRenderType = IParticleRenderType.PARTICLE_SHEET_TRANSLUCENT
+
+    fun setColor(color: Int) {
+        particleBlue = (color and 255) / 256.0f
+        particleGreen = ((color shr 8) and 255) / 256.0f
+        particleRed = ((color shr 16) and 255) / 256.0f
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/render/old/BlockContext.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/old/BlockContext.kt
@@ -0,0 +1,80 @@
+package mods.betterfoliage.render.old
+
+import com.mojang.blaze3d.matrix.MatrixStack
+import com.mojang.blaze3d.vertex.IVertexBuilder
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.offset
+import mods.betterfoliage.util.plus
+import mods.betterfoliage.util.semiRandom
+import net.minecraft.block.Block
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.BlockRendererDispatcher
+import net.minecraft.client.renderer.RenderType
+import net.minecraft.util.Direction
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.ILightReader
+import net.minecraft.world.IWorldReader
+import net.minecraft.world.biome.Biome
+import net.minecraftforge.client.model.data.IModelData
+import java.util.*
+
+/**
+ * Represents the block being rendered. Has properties and methods to query the neighborhood of the block in
+ * block-relative coordinates.
+ */
+interface BlockCtx {
+    val world: ILightReader
+    val pos: BlockPos
+
+    fun offset(dir: Direction) = offset(dir.offset)
+    fun offset(offset: Int3): BlockCtx
+
+    val state: BlockState get() = world.getBlockState(pos)
+    fun state(dir: Direction) = world.getBlockState(pos + dir.offset)
+    fun state(offset: Int3) = world.getBlockState(pos + offset)
+
+    val biome: Biome? get() = (world as? IWorldReader)?.getBiome(pos)
+
+    val isNormalCube: Boolean get() = state.isNormalCube(world, pos)
+
+    fun shouldSideBeRendered(side: Direction) = Block.shouldSideBeRendered(state, world, pos, side)
+
+    /** Get a semi-random value based on the block coordinate and the given seed. */
+    fun semiRandom(seed: Int) = pos.semiRandom(seed)
+
+    /** Get an array of semi-random values based on the block coordinate. */
+    fun semiRandomArray(num: Int): Array<Int> = Array(num) { semiRandom(it) }
+}
+
+open class BasicBlockCtx(
+    override val world: ILightReader,
+    override val pos: BlockPos
+) : BlockCtx {
+    override var state: BlockState = world.getBlockState(pos)
+        protected set
+    override fun offset(offset: Int3) = BasicBlockCtx(world, pos + offset)
+    fun cache() = CachedBlockCtx(world, pos)
+}
+
+open class CachedBlockCtx(world: ILightReader, pos: BlockPos) : BasicBlockCtx(world, pos) {
+    var neighbors = Array<BlockState>(6) { world.getBlockState(pos + allDirections[it].offset) }
+    override var biome: Biome? = super.biome
+    override fun state(dir: Direction) = neighbors[dir.ordinal]
+}
+
+
+data class RenderCtx(
+    val dispatcher: BlockRendererDispatcher,
+    val renderBuffer: IVertexBuilder,
+    val matrixStack: MatrixStack,
+    val layer: RenderType,
+    val checkSides: Boolean,
+    val random: Random,
+    val modelData: IModelData
+) {
+    fun render(worldBlock: BlockCtx) =
+//        dispatcher.renderBlock(worldBlock.state, worldBlock.pos, worldBlock.world, renderBuffer, random, modelData)
+    dispatcher.renderModel(worldBlock.state, worldBlock.pos, worldBlock.world, matrixStack, renderBuffer, checkSides, random, modelData)
+}
+
--- a/src/main/kotlin/mods/betterfoliage/render/old/CombinedContext.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/old/CombinedContext.kt
@@ -0,0 +1,116 @@
+package mods.betterfoliage.render.old
+
+import mods.betterfoliage.render.canRenderInCutout
+import mods.betterfoliage.render.isCutout
+import mods.betterfoliage.render.lighting.DefaultLightingCtx
+import mods.betterfoliage.render.lighting.LightingCtx
+import mods.betterfoliage.render.lighting.PostProcessLambda
+import mods.betterfoliage.render.lighting.QuadIconResolver
+import mods.betterfoliage.render.lighting.RenderVertex
+import mods.octarinecore.BufferBuilder_setSprite
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.plus
+import net.minecraft.block.Blocks
+import net.minecraft.client.renderer.RenderTypeLookup
+import net.minecraft.client.renderer.Vector3f
+import net.minecraft.client.renderer.Vector4f
+import net.minecraft.fluid.Fluids
+import net.minecraft.util.Direction
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.ILightReader
+import net.minecraft.world.LightType
+import net.minecraft.world.level.ColorResolver
+
+class CombinedContext(
+    val blockCtx: BlockCtx, val renderCtx: RenderCtx, val lightingCtx: DefaultLightingCtx
+) : BlockCtx by blockCtx, LightingCtx by lightingCtx {
+
+    var hasRendered = false
+
+    fun render(force: Boolean = false) = renderCtx.let {
+        if (force || RenderTypeLookup.canRenderInLayer(state, it.layer) || (state.canRenderInCutout() && it.layer.isCutout)) {
+            it.render(blockCtx)
+            hasRendered = true
+        }
+        Unit
+    }
+
+    fun exchange(moddedOffset: Int3, targetOffset: Int3) = CombinedContext(
+        BasicBlockCtx(OffsetEnvBlockReader(blockCtx.world, pos + moddedOffset, pos + targetOffset), pos),
+        renderCtx,
+        lightingCtx
+    )
+
+    val isCutout = renderCtx.layer.isCutout
+
+    /** Get the centerpoint of the block being rendered. */
+    val blockCenter: Double3 get() = Double3((pos.x and 15) + 0.5, (pos.y and 15) + 0.5, (pos.z and 15) + 0.5)
+
+    /** Holds final vertex data before it goes to the [Tessellator]. */
+    val temp = RenderVertex()
+
+    fun render(
+        model: Model,
+        rotation: Rotation = Rotation.identity,
+        translation: Double3 = blockCenter,
+        forceFlat: Boolean = false,
+        quadFilter: (Int, Quad) -> Boolean = { _, _ -> true },
+        icon: QuadIconResolver,
+        postProcess: PostProcessLambda = noPost
+    ) {
+        val cameraTransform = renderCtx.matrixStack.last
+        lightingCtx.modelRotation = rotation
+        model.quads.forEachIndexed { quadIdx, quad ->
+            if (quadFilter(quadIdx, quad)) {
+                val normal = quad.normal.let { Vector3f(it.x.toFloat(), it.y.toFloat(), it.z.toFloat()) }
+                normal.transform(cameraTransform.normal)
+
+                val drawIcon = icon(this, quadIdx, quad)
+                if (drawIcon != null) {
+                    // let OptiFine know the texture we're using, so it can
+                    // transform UV coordinates to quad-relative
+                    BufferBuilder_setSprite.invoke(renderCtx.renderBuffer, drawIcon)
+
+                    quad.verts.forEachIndexed { vertIdx, vert ->
+                        temp.init(vert).rotate(lightingCtx.modelRotation)
+                            .translate(translation)
+                        val vertex = temp.let { Vector4f(it.x.toFloat(), it.y.toFloat(), it.z.toFloat(), 0.0F) }
+                            .apply { transform(cameraTransform.matrix) }
+                        val shader = if (lightingCtx.aoEnabled && !forceFlat) vert.aoShader else vert.flatShader
+                        shader.shade(lightingCtx, temp)
+                        temp.postProcess(this, quadIdx, quad, vertIdx, vert)
+                        temp.setIcon(drawIcon)
+
+                        renderCtx.renderBuffer
+                            .pos(temp.x, temp.y, temp.z)
+//                            .pos(vertex.x.toDouble(), vertex.y.toDouble(), vertex.z.toDouble())
+                            .color(temp.red, temp.green, temp.blue, 1.0f)
+                            .tex(temp.u.toFloat(), temp.v.toFloat())
+                            .lightmap(temp.brightness shr 16 and 65535, temp.brightness and 65535)
+                            .normal(quad.normal.x.toFloat(), quad.normal.y.toFloat(), quad.normal.z.toFloat())
+//                            .normal(normal.x, normal.y, normal.z)
+                            .endVertex()
+                    }
+                }
+            }
+        }
+        hasRendered = true
+    }
+}
+
+val allFaces: (Direction) -> Boolean = { true }
+val topOnly: (Direction) -> Boolean = { it == Direction.UP }
+
+/** Perform no post-processing */
+val noPost: PostProcessLambda = { _, _, _, _, _ -> }
+
+object NonNullWorld : ILightReader {
+    override fun getBlockState(pos: BlockPos) = Blocks.AIR.defaultState
+    override fun getLightFor(type: LightType, pos: BlockPos) = 0
+    override fun getFluidState(pos: BlockPos) = Fluids.EMPTY.defaultState
+    override fun getTileEntity(pos: BlockPos) = null
+    override fun getLightManager() = null
+    override fun getBlockColor(p0: BlockPos, p1: ColorResolver) = 0
+}
--- a/src/main/kotlin/mods/betterfoliage/render/old/Model.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/old/Model.kt
@@ -0,0 +1,159 @@
+package mods.betterfoliage.render.old
+
+import mods.betterfoliage.render.lighting.ModelLighter
+import mods.betterfoliage.render.lighting.NoLighting
+import mods.betterfoliage.render.lighting.ShaderFactory
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerFlat
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.boxFaces
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.minmax
+import mods.betterfoliage.util.replace
+import mods.betterfoliage.util.times
+import mods.betterfoliage.util.vec
+import net.minecraft.util.Direction
+import java.lang.Math.max
+import java.lang.Math.min
+
+/**
+ * Vertex UV coordinates
+ *
+ * Zero-centered: coordinates fall between (-0.5, 0.5) (inclusive)
+ */
+data class UV(val u: Double, val v: Double) {
+    companion object {
+        val topLeft = UV(-0.5, -0.5)
+        val topRight = UV(0.5, -0.5)
+        val bottomLeft = UV(-0.5, 0.5)
+        val bottomRight = UV(0.5, 0.5)
+    }
+
+    val rotate: UV get() = UV(v, -u)
+
+    fun rotate(n: Int) = when(n % 4) {
+        0 -> copy()
+        1 -> UV(v, -u)
+        2 -> UV(-u, -v)
+        else -> UV(-v, u)
+    }
+
+    fun clamp(minU: Double = -0.5, maxU: Double = 0.5, minV: Double = -0.5, maxV: Double = 0.5) =
+        UV(u.minmax(minU, maxU), v.minmax(minV, maxV))
+
+    fun mirror(mirrorU: Boolean, mirrorV: Boolean) = UV(if (mirrorU) -u else u, if (mirrorV) -v else v)
+}
+
+/**
+ * Model vertex
+ *
+ * @param[xyz] x, y, z coordinates
+ * @param[uv] u, v coordinates
+ * @param[aoShader] [ModelLighter] instance to use with AO rendering
+ * @param[flatShader] [ModelLighter] instance to use with non-AO rendering
+ */
+data class Vertex(val xyz: Double3 = Double3(0.0, 0.0, 0.0),
+                  val uv: UV = UV(0.0, 0.0),
+                  val aoShader: ModelLighter = NoLighting,
+                  val flatShader: ModelLighter = NoLighting
+)
+
+/**
+ * Model quad
+ */
+data class Quad(val v1: Vertex, val v2: Vertex, val v3: Vertex, val v4: Vertex) {
+    val verts = arrayOf(v1, v2, v3, v4)
+    inline fun transformV(trans: (Vertex)-> Vertex): Quad = transformVI { vertex, idx -> trans(vertex) }
+    inline fun transformVI(trans: (Vertex, Int)-> Vertex): Quad =
+            Quad(trans(v1, 0), trans(v2, 1), trans(v3, 2), trans(v4, 3))
+    val normal: Double3 get() = (v2.xyz - v1.xyz).cross(v4.xyz - v1.xyz).normalize
+
+    fun move(trans: Double3) = transformV { it.copy(xyz = it.xyz + trans) }
+    fun move(trans: Pair<Double, Direction>) = move(Double3(trans.second) * trans.first)
+    fun scale (scale: Double) = transformV { it.copy(xyz = it.xyz * scale) }
+    fun scale (scale: Double3) = transformV { it.copy(xyz = Double3(it.xyz.x * scale.x, it.xyz.y * scale.y, it.xyz.z * scale.z)) }
+    fun scaleUV (scale: Double) = transformV { it.copy(uv = UV(it.uv.u * scale, it.uv.v * scale)) }
+    fun rotate(rot: Rotation) = transformV {
+        it.copy(xyz = it.xyz.rotate(rot), aoShader = it.aoShader.rotate(rot), flatShader = it.flatShader.rotate(rot))
+    }
+    fun rotateUV(n: Int) = transformV { it.copy(uv = it.uv.rotate(n)) }
+    fun clampUV(minU: Double = -0.5, maxU: Double = 0.5, minV: Double = -0.5, maxV: Double = 0.5) =
+        transformV { it.copy(uv = it.uv.clamp(minU, maxU, minV, maxV)) }
+    fun mirrorUV(mirrorU: Boolean, mirrorV: Boolean) = transformV { it.copy(uv = it.uv.mirror(mirrorU, mirrorV)) }
+    fun setAoShader(factory: ShaderFactory, predicate: (Vertex, Int)->Boolean = { v, vi -> true }) =
+        transformVI { vertex, idx ->
+            if (!predicate(vertex, idx)) vertex else vertex.copy(aoShader = factory(this@Quad, vertex))
+        }
+    fun setFlatShader(factory: ShaderFactory, predicate: (Vertex, Int)->Boolean = { v, vi -> true }) =
+        transformVI { vertex, idx ->
+            if (!predicate(vertex, idx)) vertex else vertex.copy(flatShader = factory(this@Quad, vertex))
+        }
+    fun setFlatShader(shader: ModelLighter) = transformVI { vertex, idx -> vertex.copy(flatShader = shader) }
+    val flipped: Quad get() = Quad(v4, v3, v2, v1)
+
+    fun cycleVertices(n: Int) = when(n % 4) {
+        1 -> Quad(v2, v3, v4, v1)
+        2 -> Quad(v3, v4, v1, v2)
+        3 -> Quad(v4, v1, v2, v3)
+        else -> this.copy()
+    }
+}
+
+/**
+ * Model. The basic unit of rendering blocks with OctarineCore.
+ *
+ * The model should be positioned so that (0,0,0) is the block center.
+ * The block extends to (-0.5, 0.5) in all directions (inclusive).
+ */
+class Model() {
+    constructor(other: List<Quad>) : this() { quads.addAll(other) }
+    val quads = mutableListOf<Quad>()
+
+    fun Quad.add() = quads.add(this)
+    fun Iterable<Quad>.addAll() = forEach { quads.add(it) }
+
+    fun transformQ(trans: (Quad)-> Quad) = quads.replace(trans)
+    fun transformV(trans: (Vertex)-> Vertex) = quads.replace{ it.transformV(trans) }
+
+    fun verticalRectangle(x1: Double, z1: Double, x2: Double, z2: Double, yBottom: Double, yTop: Double) = Quad(
+            Vertex(Double3(x1, yBottom, z1), UV.bottomLeft),
+            Vertex(Double3(x2, yBottom, z2), UV.bottomRight),
+            Vertex(Double3(x2, yTop, z2), UV.topRight),
+            Vertex(Double3(x1, yTop, z1), UV.topLeft)
+    )
+
+    fun horizontalRectangle(x1: Double, z1: Double, x2: Double, z2: Double, y: Double): Quad {
+        val xMin = min(x1, x2); val xMax = max(x1, x2)
+        val zMin = min(z1, z2); val zMax = max(z1, z2)
+        return Quad(
+            Vertex(Double3(xMin, y, zMin), UV.topLeft),
+            Vertex(Double3(xMin, y, zMax), UV.bottomLeft),
+            Vertex(Double3(xMax, y, zMax), UV.bottomRight),
+            Vertex(Double3(xMax, y, zMin), UV.topRight)
+        )
+    }
+
+    fun faceQuad(face: Direction): Quad {
+        val base = face.vec * 0.5
+        val top = boxFaces[face].top * 0.5
+        val left = boxFaces[face].left * 0.5
+        return Quad(
+                Vertex(base + top + left, UV.topLeft),
+                Vertex(base - top + left, UV.bottomLeft),
+                Vertex(base - top - left, UV.bottomRight),
+                Vertex(base + top - left, UV.topRight)
+        )
+    }
+}
+
+val fullCube = Model().apply {
+    allDirections.forEach {
+        faceQuad(it)
+        .setAoShader(faceOrientedAuto(corner = cornerAo(it.axis), edge = null))
+        .setFlatShader(faceOrientedAuto(corner = cornerFlat, edge = null))
+        .add()
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/render/old/OffsetBlockReader.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/old/OffsetBlockReader.kt
@@ -0,0 +1,45 @@
+package mods.betterfoliage.render.old
+
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockReader
+import net.minecraft.world.ILightReader
+
+/**
+ * Delegating [IBlockAccess] that fakes a _modified_ location to return values from a _target_ location.
+ * All other locations are handled normally.
+ *
+ * @param[original] the [IBlockAccess] that is delegated to
+ */
+@Suppress("NOTHING_TO_INLINE", "NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS", "HasPlatformType")
+open class OffsetBlockReader(open val original: IBlockReader, val modded: BlockPos, val target: BlockPos) : IBlockReader {
+    inline fun actualPos(pos: BlockPos) = if (pos != null && pos.x == modded.x && pos.y == modded.y && pos.z == modded.z) target else pos
+
+    override fun getBlockState(pos: BlockPos) = original.getBlockState(actualPos(pos))
+    override fun getTileEntity(pos: BlockPos) = original.getTileEntity(actualPos(pos))
+    override fun getFluidState(pos: BlockPos) = original.getFluidState(actualPos(pos))
+}
+
+@Suppress("NOTHING_TO_INLINE", "NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS", "HasPlatformType")
+class OffsetEnvBlockReader(val original: ILightReader, val modded: BlockPos, val target: BlockPos) : ILightReader by original {
+    inline fun actualPos(pos: BlockPos) = if (pos.x == modded.x && pos.y == modded.y && pos.z == modded.z) target else pos
+
+    override fun getBlockState(pos: BlockPos) = original.getBlockState(actualPos(pos))
+    override fun getTileEntity(pos: BlockPos) = original.getTileEntity(actualPos(pos))
+    override fun getFluidState(pos: BlockPos) = original.getFluidState(actualPos(pos))
+}
+
+/**
+ * Temporarily replaces the [IBlockReader] used by this [BlockContext] and the corresponding [ExtendedRenderBlocks]
+ * to use an [OffsetEnvBlockReader] while executing this lambda.
+ *
+ * @param[modded] the _modified_ location
+ * @param[target] the _target_ location
+ * @param[func] the lambda to execute
+ */
+//inline fun <reified T> BlockContext.withOffset(modded: Int3, target: Int3, func: () -> T): T {
+//    val original = reader!!
+//    reader = OffsetEnvBlockReader(original, pos + modded, pos + target)
+//    val result = func()
+//    reader = original
+//    return result
+//}
--- a/src/main/kotlin/mods/betterfoliage/render/old/RenderDecorator.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/old/RenderDecorator.kt
@@ -0,0 +1,23 @@
+@file:JvmName("RendererHolder")
+package mods.betterfoliage.render.old
+
+import mods.betterfoliage.resource.ResourceHandler
+import net.minecraft.block.BlockState
+import net.minecraftforge.eventbus.api.IEventBus
+
+abstract class RenderDecorator(modId: String, modBus: IEventBus) : ResourceHandler(modId, modBus) {
+
+    open val renderOnCutout: Boolean get() = true
+    open val onlyOnCutout: Boolean get() = false
+
+    // ============================
+    // Custom rendering
+    // ============================
+    abstract fun isEligible(ctx: CombinedContext): Boolean
+    abstract fun render(ctx: CombinedContext)
+
+}
+
+data class BlockData(val state: BlockState, val color: Int, val brightness: Int)
+
+
--- a/src/main/kotlin/mods/betterfoliage/client/resource/Aliases.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/resource/Aliases.kt
@@ -1,4 +1,4 @@
-package mods.betterfoliage.client.resource
+package mods.betterfoliage.resource

 import net.minecraft.client.renderer.model.ModelResourceLocation
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
--- a/src/main/kotlin/mods/betterfoliage/resource/ResourceHandler.kt
+++ b/src/main/kotlin/mods/betterfoliage/resource/ResourceHandler.kt
@@ -0,0 +1,151 @@
+package mods.betterfoliage.resource
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.render.old.Model
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.completedVoid
+import mods.betterfoliage.util.sink
+import mods.octarinecore.client.resource.AsyncSpriteProvider
+import mods.octarinecore.client.resource.AtlasFuture
+import mods.octarinecore.client.resource.StitchPhases
+import net.minecraft.resources.IResourceManager
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.MathHelper
+import net.minecraft.world.IWorld
+import net.minecraft.world.gen.SimplexNoiseGenerator
+import net.minecraftforge.event.world.WorldEvent
+import net.minecraftforge.eventbus.api.IEventBus
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import net.minecraftforge.fml.config.ModConfig
+import java.util.*
+import java.util.concurrent.CompletableFuture
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+// ============================
+// Resource types
+// ============================
+interface IConfigChangeListener { fun onConfigChange() }
+interface IWorldLoadListener { fun onWorldLoad(world: IWorld) }
+
+/**
+ * Base class for declarative resource handling.
+ *
+ * Resources are automatically reloaded/recalculated when the appropriate events are fired.
+ *
+ * @param[modId] mod ID associated with this handler (used to filter config change events)
+ */
+open class ResourceHandler(
+    val modId: String,
+    val modBus: IEventBus,
+    val targetAtlas: Atlas = Atlas.BLOCKS
+) {
+
+    val resources = mutableListOf<Any>()
+    // ============================
+    // Self-registration
+    // ============================
+    init { modBus.register(this) }
+
+    // ============================
+    // Resource declarations
+    // ============================
+    fun sprite(id: Identifier) = sprite { id }
+    fun sprite(idFunc: ()->Identifier) = AsyncSpriteDelegate(idFunc).apply { BetterFoliage.getSpriteManager(targetAtlas).providers.add(this) }
+    fun spriteSet(idFunc: (Int)->Identifier) = AsyncSpriteSet(targetAtlas, idFunc).apply { BetterFoliage.getSpriteManager(targetAtlas).providers.add(this) }
+    fun spriteSetTransformed(check: (Int)->Identifier, register: (Identifier)->Identifier) =
+        AsyncSpriteSet(targetAtlas, check, register).apply { BetterFoliage.getSpriteManager(targetAtlas).providers.add(this) }
+    fun model(init: Model.()->Unit) = ModelHolder(init).apply { resources.add(this) }
+    fun modelSet(num: Int, init: Model.(Int)->Unit) = ModelSet(num, init).apply { resources.add(this) }
+    fun vectorSet(num: Int, init: (Int)-> Double3) = VectorSet(num, init).apply { resources.add(this) }
+    fun simplexNoise() = SimplexNoise().apply { resources.add(this) }
+
+    // ============================
+    // Event registration
+    // ============================
+    @SubscribeEvent
+    fun handleModConfigChange(event: ModConfig.ModConfigEvent) {
+        resources.forEach { (it as? IConfigChangeListener)?.onConfigChange() }
+    }
+
+    @SubscribeEvent
+    fun handleWorldLoad(event: WorldEvent.Load) =
+        resources.forEach { (it as? IWorldLoadListener)?.onWorldLoad(event.world) }
+}
+
+// ============================
+// Resource container classes
+// ============================
+class AsyncSpriteDelegate(val idFunc: ()->Identifier) : ReadOnlyProperty<Any, Sprite>, AsyncSpriteProvider<Any> {
+    protected lateinit var value: Sprite
+    override fun getValue(thisRef: Any, property: KProperty<*>) = value
+
+    override fun setup(manager: IResourceManager, sourceF: CompletableFuture<Any>, atlas: AtlasFuture): StitchPhases {
+        sourceF.thenRun {
+            val sprite = atlas.sprite(idFunc())
+            atlas.runAfter {
+                sprite.handle { sprite, error -> value = sprite ?: atlas.missing.get()!! }
+            }
+        }
+        return StitchPhases(completedVoid(), completedVoid())
+    }
+}
+
+interface SpriteSet {
+    val num: Int
+    operator fun get(idx: Int): Sprite
+}
+
+class AsyncSpriteSet(val targetAtlas: Atlas = Atlas.BLOCKS, val idFunc: (Int)->Identifier, val transform: (Identifier)->Identifier = { it }) :
+    AsyncSpriteProvider<Any> {
+    var num = 0
+        protected set
+    protected var sprites: List<Sprite> = emptyList()
+
+    override fun setup(manager: IResourceManager, sourceF: CompletableFuture<Any>, atlas: AtlasFuture): StitchPhases {
+        var list: List<CompletableFuture<Sprite>> = emptyList()
+
+        return StitchPhases(
+            discovery = sourceF.sink {
+                list = (0 until 16).map { idFunc(it) }
+                    .filter { manager.hasResource( targetAtlas.wrap(it)) }
+                    .map { transform(it) }
+                    .map { atlas.sprite(it) }
+            },
+            cleanup = atlas.runAfter {
+                sprites = list.filter { !it.isCompletedExceptionally }.map { it.get() }
+                if (sprites.isEmpty()) sprites = listOf(atlas.missing.get()!!)
+                num = sprites.size
+            }
+        )
+    }
+    operator fun get(idx: Int) = sprites[idx % num]
+}
+
+class ModelHolder(val init: Model.()->Unit): IConfigChangeListener {
+    var model: Model = Model()
+    override fun onConfigChange() { model = Model().apply(init) }
+}
+
+class ModelSet(val num: Int, val init: Model.(Int)->Unit): IConfigChangeListener {
+    val models = Array(num) { Model() }
+    override fun onConfigChange() { (0 until num).forEach { models[it] = Model().apply{ init(it) } } }
+    operator fun get(idx: Int) = models[idx % num]
+}
+
+class VectorSet(val num: Int, val init: (Int)-> Double3): IConfigChangeListener {
+    val models = Array(num) { Double3.zero }
+    override fun onConfigChange() { (0 until num).forEach { models[it] = init(it) } }
+    operator fun get(idx: Int) = models[idx % num]
+}
+
+class SimplexNoise : IWorldLoadListener {
+    var noise = SimplexNoiseGenerator(Random())
+    override fun onWorldLoad(world: IWorld) { noise = SimplexNoiseGenerator(Random(world.worldInfo.seed))
+    }
+    operator fun get(x: Int, z: Int) = MathHelper.floor((noise.getValue(x.toDouble(), z.toDouble()) + 1.0) * 32.0)
+    operator fun get(pos: Int3) = get(pos.x, pos.z)
+    operator fun get(pos: BlockPos) = get(pos.x, pos.z)
+}
--- a/src/main/kotlin/mods/betterfoliage/resource/discovery/AsyncSpriteProviderManager.kt
+++ b/src/main/kotlin/mods/betterfoliage/resource/discovery/AsyncSpriteProviderManager.kt
@@ -0,0 +1,95 @@
+package mods.octarinecore.client.resource
+
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.Sprite
+import mods.betterfoliage.util.map
+import net.minecraft.client.renderer.texture.AtlasTexture
+import net.minecraft.client.renderer.texture.MissingTextureSprite
+import net.minecraft.profiler.IProfiler
+import net.minecraft.resources.IResourceManager
+import java.util.*
+import java.util.concurrent.CompletableFuture
+
+/**
+ * Main entry point to atlas manipulation. Called from mixins that wrap [AtlasTexture.stitch] calls.
+ *
+ * 1. All registered providers receive an [AsyncSpriteProvider.setup] call. Providers can set up their
+ *   processing chain at this point, but should not do anything yet except configuration and housekeeping.
+ * 2. The [CompletableFuture] of the stitch source finishes, starting the "discovery" phase. Providers
+ *   may register sprites in the [AtlasFuture].
+ * 3. After all providers finish their discovery, the atlas is stitched.
+ * 4. The [AtlasFuture] finishes, starting the "cleanup" phase. All [AtlasFuture.runAfter] and
+ *   [AtlasFuture.mapAfter] tasks are processed.
+ * 5. After all providers finish their cleanup, we return to the original code path.
+ */
+class AsnycSpriteProviderManager<SOURCE: Any>(val profilerSection: String) {
+
+    val providers = mutableListOf<AsyncSpriteProvider<SOURCE>>()
+
+    /**
+     * Needed in order to keep the actual [AtlasTexture.stitch] call in the original method, in case
+     * other modders want to modify it too.
+     */
+    class StitchWrapper(val idList: Iterable<Identifier>, val onComplete: (AtlasTexture.SheetData)->Unit) {
+        fun complete(sheet: AtlasTexture.SheetData) = onComplete(sheet)
+    }
+
+    var currentAtlas: AtlasFuture? = null
+    var currentPhases: List<StitchPhases> = emptyList()
+
+    @Suppress("UNCHECKED_CAST")
+    fun prepare(sourceObj: Any, manager: IResourceManager, idList: Iterable<Identifier>, profiler: IProfiler): Set<Identifier> {
+        profiler.startSection(profilerSection)
+
+        val source = CompletableFuture<SOURCE>()
+        currentAtlas = AtlasFuture(idList)
+
+        currentPhases = providers.map { it.setup(manager, source, currentAtlas!!) }
+        source.complete(sourceObj as SOURCE)
+        currentPhases.forEach { it.discovery.get() }
+
+        return currentAtlas!!.idSet
+    }
+
+    fun finish(sheetData: AtlasTexture.SheetData, profiler: IProfiler): AtlasTexture.SheetData {
+        currentAtlas!!.complete(sheetData)
+        currentPhases.forEach { it.cleanup.get() }
+        currentAtlas = null
+        currentPhases = emptyList()
+        profiler.endSection()
+        return sheetData
+    }
+}
+
+/**
+ * Provides a way for [AsyncSpriteProvider]s to register sprites to receive [CompletableFuture]s.
+ * Tracks sprite ids that need to be stitched.
+ */
+class AtlasFuture(initial: Iterable<Identifier>) {
+    val idSet = Collections.synchronizedSet(mutableSetOf<Identifier>().apply { addAll(initial) })
+    protected val sheet = CompletableFuture<AtlasTexture.SheetData>()
+    protected val finished = CompletableFuture<Void>()
+
+    fun complete(sheetData: AtlasTexture.SheetData) {
+        sheet.complete(sheetData)
+        finished.complete(null)
+    }
+
+    fun sprite(id: String) = sprite(Identifier(id))
+    fun sprite(id: Identifier): CompletableFuture<Sprite> {
+        idSet.add(id)
+        return sheet.map { sheetData -> sheetData.sprites.find { it.name == id } ?: throw IllegalStateException("Atlas does not contain $id") }
+    }
+    val missing = sheet.map { sheetData -> sheetData.sprites.find { it.name == MissingTextureSprite.getLocation() } }
+    fun <T> mapAfter(supplier: ()->T): CompletableFuture<T> = finished.map{ supplier() }
+    fun runAfter(action: ()->Unit): CompletableFuture<Void> = finished.thenRun(action)
+}
+
+class StitchPhases(
+    val discovery: CompletableFuture<Void>,
+    val cleanup: CompletableFuture<Void>
+)
+
+interface AsyncSpriteProvider<SOURCE: Any> {
+    fun setup(manager: IResourceManager, source: CompletableFuture<SOURCE>, atlas: AtlasFuture): StitchPhases
+}
--- a/src/main/kotlin/mods/betterfoliage/resource/discovery/ModelDiscovery.kt
+++ b/src/main/kotlin/mods/betterfoliage/resource/discovery/ModelDiscovery.kt
@@ -0,0 +1,143 @@
+package mods.betterfoliage.resource.discovery
+
+import com.google.common.base.Joiner
+import mods.betterfoliage.render.old.BlockCtx
+import mods.octarinecore.client.resource.AsyncSpriteProvider
+import mods.octarinecore.client.resource.AtlasFuture
+import mods.octarinecore.client.resource.StitchPhases
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.config.IBlockMatcher
+import mods.betterfoliage.config.ModelTextureList
+import mods.betterfoliage.util.HasLogger
+import mods.betterfoliage.util.findFirst
+import mods.betterfoliage.util.plus
+import mods.betterfoliage.util.sinkAsync
+import mods.betterfoliage.util.stripStart
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.BlockModelShapes
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.client.renderer.model.IUnbakedModel
+import net.minecraft.client.renderer.model.ModelBakery
+import net.minecraft.client.renderer.model.ModelResourceLocation
+import net.minecraft.client.renderer.model.VariantList
+import net.minecraft.client.renderer.texture.MissingTextureSprite
+import net.minecraft.resources.IResourceManager
+import net.minecraft.util.ResourceLocation
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.IBlockReader
+import net.minecraftforge.registries.ForgeRegistries
+import java.util.concurrent.CompletableFuture
+
+interface ModelRenderRegistry<T> {
+    operator fun get(ctx: BlockCtx) = get(ctx.state, ctx.world, ctx.pos)
+    operator fun get(ctx: BlockCtx, offset: Int3) = get(ctx.state(offset), ctx.world, ctx.pos + offset)
+    operator fun get(state: BlockState, world: IBlockReader, pos: BlockPos): T?
+}
+
+abstract class ModelRenderRegistryRoot<T> : ModelRenderRegistry<T> {
+    val registries = mutableListOf<ModelRenderRegistry<T>>()
+    override fun get(state: BlockState, world: IBlockReader, pos: BlockPos) = registries.findFirst { it[state, world, pos] }
+}
+
+/**
+ * Information about a single BlockState and all the IUnbakedModel it could render as.
+ */
+class ModelDiscoveryContext(
+    bakery: ModelBakery,
+    val state: BlockState,
+    val modelId: ModelResourceLocation
+) {
+    val models = bakery.unwrapVariants(bakery.getUnbakedModel(modelId) to modelId)
+        .filter { it.second != bakery.getUnbakedModel(ModelBakery.MODEL_MISSING) }
+
+    fun ModelBakery.unwrapVariants(modelAndLoc: Pair<IUnbakedModel, ResourceLocation>): List<Pair<IUnbakedModel, ResourceLocation>> = when(val model = modelAndLoc.first) {
+        is VariantList -> model.variantList.flatMap { variant -> unwrapVariants(getUnbakedModel(variant.modelLocation) to variant.modelLocation) }
+        is BlockModel -> listOf(modelAndLoc)
+        else -> emptyList()
+    }
+}
+
+abstract class ModelDiscovery<T> : HasLogger, AsyncSpriteProvider<ModelBakery>, ModelRenderRegistry<T> {
+
+    var modelData: Map<BlockState, T> = emptyMap()
+        protected set
+
+    override fun get(state: BlockState, world: IBlockReader, pos: BlockPos) = modelData[state]
+
+    abstract fun processModel(ctx: ModelDiscoveryContext, atlas: AtlasFuture): CompletableFuture<T>?
+
+    override fun setup(manager: IResourceManager, bakeryF: CompletableFuture<ModelBakery>, atlas: AtlasFuture): StitchPhases {
+        val modelDataTemp = mutableMapOf<BlockState, CompletableFuture<T>>()
+
+        return StitchPhases(
+            discovery = bakeryF.sinkAsync { bakery ->
+                var errors = 0
+                bakery.iterateModels { ctx ->
+                    try {
+                        processModel(ctx, atlas)?.let { modelDataTemp[ctx.state] = it }
+                    } catch (e: Exception) {
+                        errors++
+                    }
+                }
+                log("${modelDataTemp.size} BlockStates discovered, $errors errors")
+            },
+            cleanup = atlas.runAfter {
+                modelData = modelDataTemp.filterValues { !it.isCompletedExceptionally }.mapValues { it.value.get() }
+                val errors = modelDataTemp.values.filter { it.isCompletedExceptionally }.size
+                log("${modelData.size} BlockStates loaded, $errors errors")
+            }
+        )
+    }
+
+    fun ModelBakery.iterateModels(func: (ModelDiscoveryContext)->Unit) {
+        ForgeRegistries.BLOCKS.flatMap { block ->
+            block.stateContainer.validStates.map { state -> state to BlockModelShapes.getModelLocation(state) }
+        }.forEach { (state, stateModelResource) ->
+            func(ModelDiscoveryContext(this, state, stateModelResource))
+        }
+    }
+}
+
+abstract class ConfigurableModelDiscovery<T> : ModelDiscovery<T>() {
+
+    abstract val matchClasses: IBlockMatcher
+    abstract val modelTextures: List<ModelTextureList>
+
+    abstract fun processModel(state: BlockState, textures: List<ResourceLocation>, atlas: AtlasFuture): CompletableFuture<T>?
+
+    override fun processModel(ctx: ModelDiscoveryContext, atlas: AtlasFuture): CompletableFuture<T>? {
+        val matchClass = matchClasses.matchingClass(ctx.state.block) ?: return null
+        log("block state ${ctx.state}")
+        log("      class ${ctx.state.block.javaClass.name} matches ${matchClass.name}")
+
+        if (ctx.models.isEmpty()) {
+            log("       no models found")
+            return null
+        }
+
+        ctx.models.filter { it.first is BlockModel }.forEach { (model, location) ->
+            model as BlockModel
+            val modelMatch = modelTextures.firstOrNull { (model to location).derivesFrom(it.modelLocation) }
+            if (modelMatch != null) {
+                log("      model ${model} matches ${modelMatch.modelLocation}")
+
+                val textures = modelMatch.textureNames.map { it to model.resolveTextureName(it).textureLocation }
+                val texMapString = Joiner.on(", ").join(textures.map { "${it.first}=${it.second}" })
+                log("    sprites [$texMapString]")
+
+                if (textures.all { it.second != MissingTextureSprite.getLocation() }) {
+                    // found a valid model (all required textures exist)
+                    return processModel(ctx.state, textures.map { it.second}, atlas)
+                }
+            }
+        }
+        return null
+    }
+}
+
+fun Pair<BlockModel, ResourceLocation>.derivesFrom(targetLocation: ResourceLocation): Boolean {
+    if (second.stripStart("models/") == targetLocation) return true
+    if (first.parent != null && first.parentLocation != null)
+        return Pair(first.parent!!, first.parentLocation!!).derivesFrom(targetLocation)
+    return false
+}
--- a/src/main/kotlin/mods/betterfoliage/resource/generated/CenteringTextureGenerator.kt
+++ b/src/main/kotlin/mods/betterfoliage/resource/generated/CenteringTextureGenerator.kt
@@ -0,0 +1,39 @@
+package mods.betterfoliage.resource.generated
+
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.texture.loadSprite
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.bytes
+import net.minecraft.resources.IResourceManager
+import java.awt.image.BufferedImage
+import java.lang.Math.max
+
+data class CenteredSprite(val sprite: Identifier, val atlas: Atlas = Atlas.BLOCKS, val aspectHeight: Int = 1, val aspectWidth: Int = 1) {
+
+    fun register(pack: GeneratedBlockTexturePack) = pack.register(this, this::draw)
+
+    fun draw(resourceManager: IResourceManager): ByteArray {
+        val baseTexture = resourceManager.loadSprite(atlas.wrap(sprite))
+
+        val frameWidth = baseTexture.width
+        val frameHeight = baseTexture.width * aspectHeight / aspectWidth
+        val frames = baseTexture.height / frameHeight
+        val size = max(frameWidth, frameHeight)
+
+        val resultTexture = BufferedImage(size, size * frames, BufferedImage.TYPE_4BYTE_ABGR)
+        val graphics = resultTexture.createGraphics()
+
+        // iterate all frames
+        for (frame in 0 until frames) {
+            val baseFrame = baseTexture.getSubimage(0, size * frame, frameWidth, frameHeight)
+            val resultFrame = BufferedImage(size, size, BufferedImage.TYPE_4BYTE_ABGR)
+
+            resultFrame.createGraphics().apply {
+                drawImage(baseFrame, (size - frameWidth) / 2, (size - frameHeight) / 2, null)
+            }
+            graphics.drawImage(resultFrame, 0, size * frame, null)
+        }
+
+        return resultTexture.bytes
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/resource/generated/GeneratedGrass.kt
+++ b/src/main/kotlin/mods/betterfoliage/resource/generated/GeneratedGrass.kt
@@ -1,6 +1,12 @@
-package mods.betterfoliage.client.texture
+package mods.betterfoliage.resource.generated

-import mods.betterfoliage.client.resource.Identifier
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.texture.blendRGB
+import mods.betterfoliage.texture.loadSprite
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.bytes
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.set
 import mods.octarinecore.client.resource.*
 import net.minecraft.resources.IResourceManager
 import java.awt.image.BufferedImage
--- a/src/main/kotlin/mods/betterfoliage/resource/generated/GeneratedLeaf.kt
+++ b/src/main/kotlin/mods/betterfoliage/resource/generated/GeneratedLeaf.kt
@@ -1,6 +1,13 @@
-package mods.betterfoliage.client.texture
+package mods.betterfoliage.resource.generated

 import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.texture.loadSprite
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.bytes
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.loadImage
+import mods.betterfoliage.util.resourceManager
+import mods.betterfoliage.util.set
 import mods.octarinecore.client.resource.*
 import net.minecraft.resources.IResource
 import net.minecraft.resources.IResourceManager
--- a/src/main/kotlin/mods/betterfoliage/resource/generated/ResourceGeneration.kt
+++ b/src/main/kotlin/mods/betterfoliage/resource/generated/ResourceGeneration.kt
@@ -0,0 +1,90 @@
+package mods.betterfoliage.resource.generated
+
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.HasLogger
+import mods.betterfoliage.util.completedVoid
+import mods.betterfoliage.util.map
+import mods.octarinecore.client.resource.AsyncSpriteProvider
+import mods.octarinecore.client.resource.AtlasFuture
+import mods.octarinecore.client.resource.StitchPhases
+import net.minecraft.client.renderer.model.ModelBakery
+import net.minecraft.client.resources.ClientResourcePackInfo
+import net.minecraft.resources.*
+import net.minecraft.resources.ResourcePackType.CLIENT_RESOURCES
+import net.minecraft.resources.data.IMetadataSectionSerializer
+import net.minecraft.util.text.StringTextComponent
+import org.apache.logging.log4j.Logger
+import java.io.IOException
+import java.util.*
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ExecutionException
+import java.util.function.Predicate
+import java.util.function.Supplier
+
+/**
+ * [IResourcePack] containing generated resources
+ *
+ * @param[name] Name of the resource pack
+ * @param[generators] List of resource generators
+ */
+class GeneratedBlockTexturePack(val nameSpace: String, val packName: String, override val logger: Logger) : HasLogger, IResourcePack,
+    AsyncSpriteProvider<ModelBakery> {
+
+    override fun getName() = packName
+    override fun getResourceNamespaces(type: ResourcePackType) = setOf(nameSpace)
+    override fun <T : Any?> getMetadata(deserializer: IMetadataSectionSerializer<T>) = null
+    override fun getRootResourceStream(id: String) = null
+    override fun getAllResourceLocations(type: ResourcePackType, namespace:String, path: String, maxDepth: Int, filter: Predicate<String>) = emptyList<Identifier>()
+
+    override fun close() {}
+
+    protected var manager: CompletableFuture<IResourceManager>? = null
+    val identifiers = Collections.synchronizedMap(mutableMapOf<Any, Identifier>())
+    val resources = Collections.synchronizedMap(mutableMapOf<Identifier, CompletableFuture<ByteArray>>())
+
+    fun register(key: Any, func: (IResourceManager)->ByteArray): Identifier {
+        if (manager == null) throw IllegalStateException("Cannot register resources unless block textures are being reloaded")
+        identifiers[key]?.let { return it }
+
+        val id = Identifier(nameSpace, UUID.randomUUID().toString())
+        val resource = manager!!.map { func(it) }
+
+        identifiers[key] = id
+        resources[Atlas.BLOCKS.wrap(id)] = resource
+        log("generated resource $key -> $id")
+        return id
+    }
+
+    override fun getResourceStream(type: ResourcePackType, id: Identifier) =
+        if (type != CLIENT_RESOURCES) null else
+            try { resources[id]!!.get().inputStream() }
+            catch (e: ExecutionException) { (e.cause as? IOException)?.let { throw it } }   // rethrow wrapped IOException if present
+
+    override fun resourceExists(type: ResourcePackType, id: Identifier) =
+        type == CLIENT_RESOURCES && resources.containsKey(id)
+
+    override fun setup(manager: IResourceManager, bakeryF: CompletableFuture<ModelBakery>, atlas: AtlasFuture): StitchPhases {
+        this.manager = CompletableFuture.completedFuture(manager)
+        return StitchPhases(
+            completedVoid(),
+            atlas.runAfter {
+                this.manager = null
+                identifiers.clear()
+                resources.clear()
+            }
+        )
+    }
+
+    val finder = object : IPackFinder {
+        val packInfo = ClientResourcePackInfo(
+            packName, true, Supplier { this@GeneratedBlockTexturePack },
+            StringTextComponent(packName),
+            StringTextComponent("Generated block textures resource pack"),
+            PackCompatibility.COMPATIBLE, ResourcePackInfo.Priority.TOP, true, null, true
+        )
+        override fun <T : ResourcePackInfo> addPackInfosToMap(nameToPackMap: MutableMap<String, T>, packInfoFactory: ResourcePackInfo.IFactory<T>) {
+            (nameToPackMap as MutableMap<String, ResourcePackInfo>).put(packName, packInfo)
+        }
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/client/texture/GrassRegistry.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/GrassRegistry.kt
@@ -1,13 +1,16 @@
-package mods.betterfoliage.client.texture
+package mods.betterfoliage.texture

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.render.lighting.HSB
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.render.lighting.HSB
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelRenderRegistryRoot
 import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.config.ConfigurableBlockMatcher
-import mods.octarinecore.common.config.ModelTextureList
+import mods.betterfoliage.config.ConfigurableBlockMatcher
+import mods.betterfoliage.config.ModelTextureList
+import mods.betterfoliage.util.averageColor
 import net.minecraft.block.BlockState
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
 import org.apache.logging.log4j.Level
@@ -37,9 +40,9 @@ object AsyncGrassDiscovery : ConfigurableModelDiscovery<GrassInfo>() {
    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.grassBlocks
    override val modelTextures: List<ModelTextureList> get() = BlockConfig.grassModels.modelList

-    override fun processModel(state: BlockState, textures: List<String>, atlas: AtlasFuture): CompletableFuture<GrassInfo> {
+    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: AtlasFuture): CompletableFuture<GrassInfo> {
        val textureName = textures[0]
-        val spriteF = atlas.sprite(Identifier(textureName))
+        val spriteF = atlas.sprite(textureName)
        logger.log(Level.DEBUG, "$logName:       texture $textureName")
        return atlas.mapAfter {
            val sprite = spriteF.get()
--- a/src/main/kotlin/mods/betterfoliage/client/texture/LeafParticleRegistry.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/LeafParticleRegistry.kt
@@ -1,13 +1,19 @@
-package mods.betterfoliage.client.texture
+package mods.betterfoliage.texture

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.resource.Identifier
-import mods.betterfoliage.client.resource.Sprite
-import mods.octarinecore.client.resource.*
-import mods.octarinecore.stripStart
-import mods.octarinecore.client.resource.Atlas
-import mods.octarinecore.common.sinkAsync
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.Sprite
+import mods.betterfoliage.resource.SpriteSet
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.getLines
+import mods.betterfoliage.util.resourceManager
+import mods.betterfoliage.util.sinkAsync
+import mods.betterfoliage.util.stripStart
+import mods.octarinecore.client.resource.AsyncSpriteProvider
+import mods.octarinecore.client.resource.AtlasFuture
+import mods.octarinecore.client.resource.StitchPhases
 import net.minecraft.client.particle.ParticleManager
 import net.minecraft.resources.IResourceManager
 import java.util.concurrent.CompletableFuture
--- a/src/main/kotlin/mods/betterfoliage/client/texture/LeafRegistry.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/LeafRegistry.kt
@@ -1,12 +1,17 @@
-package mods.betterfoliage.client.texture
+package mods.betterfoliage.texture

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.HasLogger
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.ConfigurableBlockMatcher
+import mods.betterfoliage.config.ModelTextureList
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.SpriteSet
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelRenderRegistryRoot
+import mods.betterfoliage.resource.generated.GeneratedLeaf
+import mods.betterfoliage.util.HasLogger
+import mods.betterfoliage.util.averageColor
 import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.config.ConfigurableBlockMatcher
-import mods.octarinecore.common.config.ModelTextureList
 import net.minecraft.block.BlockState
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
 import java.util.concurrent.CompletableFuture
@@ -22,7 +27,7 @@ class LeafInfo(
    val leafType: String,

    /** Average color of the round leaf texture. */
-    val averageColor: Int = roundLeafTexture.averageColor
+    val averageColor: Int
 ) {
    /** [IconSet] of the textures to use for leaf particles emitted from this block. */
    val particleTextures: SpriteSet get() = LeafParticleRegistry[leafType]
@@ -35,7 +40,7 @@ object AsyncLeafDiscovery : ConfigurableModelDiscovery<LeafInfo>() {
    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.leafBlocks
    override val modelTextures: List<ModelTextureList> get() = BlockConfig.leafModels.modelList

-    override fun processModel(state: BlockState, textures: List<String>, atlas: AtlasFuture) = defaultRegisterLeaf(Identifier(textures[0]), atlas)
+    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: AtlasFuture) = defaultRegisterLeaf(textures[0], atlas)

    fun init() {
        LeafRegistry.registries.add(this)
@@ -47,10 +52,11 @@ fun HasLogger.defaultRegisterLeaf(sprite: Identifier, atlas: AtlasFuture): Compl
    val leafType = LeafParticleRegistry.typeMappings.getType(sprite) ?: "default"
    val generated = GeneratedLeaf(sprite, leafType).register(BetterFoliage.asyncPack)
    val roundLeaf = atlas.sprite(generated)
+    val leafTex = atlas.sprite(sprite)

    log(" leaf texture $sprite")
    log("     particle $leafType")
    return atlas.mapAfter {
-        LeafInfo(roundLeaf.get(), leafType)
+        LeafInfo(roundLeaf.get(), leafType, leafTex.get().averageColor)
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/client/texture/Utils.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/Utils.kt
@@ -1,10 +1,9 @@
@file:JvmName("Utils")
-package mods.betterfoliage.client.texture
+package mods.betterfoliage.texture

-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.resource.Atlas
-import mods.octarinecore.client.resource.get
-import mods.octarinecore.client.resource.loadImage
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.loadImage
 import net.minecraft.resources.IResourceManager
 import java.io.IOException

--- a/src/main/kotlin/mods/betterfoliage/util/Caching.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Caching.kt
@@ -0,0 +1,60 @@
+package mods.betterfoliage.util
+
+import java.lang.ref.WeakReference
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+interface Invalidator {
+    fun invalidate() {
+        val iterator = callbacks.iterator()
+        while(iterator.hasNext()) iterator.next().let { callback ->
+            callback.get()?.invoke() ?: iterator.remove()
+        }
+    }
+    val callbacks: MutableList<WeakReference<()->Unit>>
+    fun onInvalidate(callback: ()->Unit) {
+        callbacks.add(WeakReference(callback))
+    }
+}
+
+class LazyInvalidatable<V>(invalidator: Invalidator, val valueFactory: ()->V): ReadOnlyProperty<Any, V> {
+    init { invalidator.onInvalidate { value = null } }
+
+    var value: V? = null
+
+    override fun getValue(thisRef: Any, property: KProperty<*>): V {
+        value?.let { return it }
+        return synchronized(this) {
+            value?.let { return it }
+            valueFactory().apply { value = this }
+        }
+    }
+}
+
+class LazyMap<K, V>(val invalidator: Invalidator, val valueFactory: (K)->V) {
+    init { invalidator.onInvalidate { values.clear() } }
+
+    val values = mutableMapOf<K, V>()
+
+    operator fun get(key: K): V {
+        values[key]?.let { return it }
+        return synchronized(values) {
+            values[key]?.let { return it }
+            valueFactory(key).apply { values[key] = this }
+        }
+    }
+    operator fun set(key: K, value: V) { values[key] = value }
+
+    fun delegate(key: K) = Delegate(key)
+
+    inner class Delegate(val key: K) : ReadOnlyProperty<Any, V> {
+        init { invalidator.onInvalidate { cached = null } }
+
+        private var cached: V? = null
+
+        override fun getValue(thisRef: Any, property: KProperty<*>): V {
+            cached?.let { return it }
+            get(key).let { cached = it; return it }
+        }
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/util/Collections.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Collections.kt
@@ -0,0 +1,63 @@
+package mods.betterfoliage.util
+
+import java.util.*
+
+/**
+ * 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
+    }
+}
+
+inline fun <T, C: Comparable<C>> Pair<T, T>.minBy(func: (T)->C) =
+    if (func(first) < func(second)) first else second
+
+inline fun <T, C: Comparable<C>> Pair<T, T>.maxBy(func: (T)->C) =
+    if (func(first) > func(second)) first else second
+
+inline fun <T, C: Comparable<C>> Triple<T, T, T>.maxValueBy(func: (T)->C): C {
+    var result = func(first)
+    func(second).let { if (it > result) result = it }
+    func(third).let { if (it > result) result = it }
+    return result
+}
+
+@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
+}
+
+inline fun <A1, reified A2, B> List<Pair<A1, B>>.filterIsInstanceFirst(cls: Class<A2>) = filter { it.first is A2 } as List<Pair<A2, B>>
+
+/** 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)
+        }
+    }
+
+/** 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
+}
+
+/** Return a random element from the array using the provided random generator */
+inline operator fun <T> Array<T>.get(random: Random) = get(random.nextInt(Int.MAX_VALUE) % size)
--- a/src/main/kotlin/mods/betterfoliage/util/Futures.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Futures.kt
@@ -0,0 +1,15 @@
+package mods.betterfoliage.util
+
+import net.minecraft.client.Minecraft
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.CompletionStage
+import java.util.function.Consumer
+import java.util.function.Function
+
+fun completedVoid() = CompletableFuture.completedFuture<Void>(null)!!
+
+fun <T, U> CompletionStage<T>.map(func: (T)->U) = thenApply(Function(func)).toCompletableFuture()!!
+fun <T, U> CompletionStage<T>.mapAsync(func: (T)->U) = thenApplyAsync(Function(func), Minecraft.getInstance()).toCompletableFuture()!!
+
+fun <T> CompletionStage<T>.sink(func: (T)->Unit) = thenAccept(Consumer(func)).toCompletableFuture()!!
+fun <T> CompletionStage<T>.sinkAsync(func: (T)->Unit) = thenAcceptAsync(Consumer(func), Minecraft.getInstance()).toCompletableFuture()!!
--- a/src/main/kotlin/mods/betterfoliage/util/Geometry.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Geometry.kt
@@ -0,0 +1,221 @@
+package mods.betterfoliage.util
+
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.*
+import net.minecraft.util.Direction.Axis.*
+import net.minecraft.util.Direction.AxisDirection.NEGATIVE
+import net.minecraft.util.Direction.AxisDirection.POSITIVE
+import net.minecraft.util.math.BlockPos
+
+// ================================
+// Axes and directions
+// ================================
+val axes = listOf(X, Y, Z)
+val axisDirs = listOf(POSITIVE, NEGATIVE)
+val Direction.dir: AxisDirection get() = axisDirection
+val AxisDirection.sign: String get() = when(this) { POSITIVE -> "+"; NEGATIVE -> "-" }
+val allDirections = Direction.values()
+val horizontalDirections = listOf(NORTH, SOUTH, EAST, WEST)
+val allDirOffsets = allDirections.map { Int3(it) }
+val Pair<Axis, AxisDirection>.face: Direction get() = when(this) {
+    X to POSITIVE -> EAST; X to NEGATIVE -> WEST;
+    Y to POSITIVE -> UP; Y to NEGATIVE -> DOWN;
+    Z to POSITIVE -> SOUTH; else -> NORTH;
+}
+val Direction.perpendiculars: List<Direction> get() =
+    axes.filter { it != this.axis }.cross(axisDirs).map { it.face }
+val Direction.offset: Int3 get() = allDirOffsets[ordinal]
+
+/** Old ForgeDirection rotation matrix yanked from 1.7.10 */
+val ROTATION_MATRIX: Array<IntArray> get() = arrayOf(
+    intArrayOf(0, 1, 4, 5, 3, 2, 6),
+    intArrayOf(0, 1, 5, 4, 2, 3, 6),
+    intArrayOf(5, 4, 2, 3, 0, 1, 6),
+    intArrayOf(4, 5, 2, 3, 1, 0, 6),
+    intArrayOf(2, 3, 1, 0, 4, 5, 6),
+    intArrayOf(3, 2, 0, 1, 4, 5, 6)
+)
+
+// ================================
+// Vectors
+// ================================
+operator fun Direction.times(scale: Double) =
+    Double3(directionVec.x.toDouble() * scale, directionVec.y.toDouble() * scale, directionVec.z.toDouble() * scale)
+val Direction.vec: Double3 get() = Double3(directionVec.x.toDouble(), directionVec.y.toDouble(), directionVec.z.toDouble())
+
+operator fun BlockPos.plus(other: Int3) = BlockPos(x + other.x, y + other.y, z + other.z)
+
+/** 3D vector of [Double]s. Offers both mutable operations, and immutable operations in operator notation. */
+data class Double3(var x: Double, var y: Double, var z: Double) {
+    constructor(x: Float, y: Float, z: Float) : this(x.toDouble(), y.toDouble(), z.toDouble())
+    constructor(dir: Direction) : this(dir.directionVec.x.toDouble(), dir.directionVec.y.toDouble(), dir.directionVec.z.toDouble())
+    companion object {
+        val zero: Double3 get() = Double3(0.0, 0.0, 0.0)
+        fun weight(v1: Double3, weight1: Double, v2: Double3, weight2: Double) =
+            Double3(v1.x * weight1 + v2.x * weight2, v1.y * weight1 + v2.y * weight2, v1.z * weight1 + v2.z * weight2)
+    }
+
+    // immutable operations
+    operator fun plus(other: Double3) = Double3(x + other.x, y + other.y, z + other.z)
+    operator fun unaryMinus() = Double3(-x, -y, -z)
+    operator fun minus(other: Double3) = Double3(x - other.x, y - other.y, z - other.z)
+    operator fun times(scale: Double) = Double3(x * scale, y * scale, z * scale)
+    operator fun times(other: Double3) = Double3(x * other.x, y * other.y, z * other.z)
+
+    /** Rotate this vector, and return coordinates in the unrotated frame */
+    fun rotate(rot: Rotation) = Double3(
+        rot.rotatedComponent(EAST, x, y, z),
+        rot.rotatedComponent(UP, x, y, z),
+        rot.rotatedComponent(SOUTH, x, y, z)
+    )
+
+    // mutable operations
+    fun setTo(other: Double3): Double3 { x = other.x; y = other.y; z = other.z; return this }
+    fun setTo(x: Double, y: Double, z: Double): Double3 { this.x = x; this.y = y; this.z = z; return this }
+    fun setTo(x: Float, y: Float, z: Float) = setTo(x.toDouble(), y.toDouble(), z.toDouble())
+    fun add(other: Double3): Double3 { x += other.x; y += other.y; z += other.z; return this }
+    fun add(x: Double, y: Double, z: Double): Double3 { this.x += x; this.y += y; this.z += z; return this }
+    fun sub(other: Double3): Double3 { x -= other.x; y -= other.y; z -= other.z; return this }
+    fun sub(x: Double, y: Double, z: Double): Double3 { this.x -= x; this.y -= y; this.z -= z; return this }
+    fun invert(): Double3 { x = -x; y = -y; z = -z; return this }
+    fun mul(scale: Double): Double3 { x *= scale; y *= scale; z *= scale; return this }
+    fun mul(other: Double3): Double3 { x *= other.x; y *= other.y; z *= other.z; return this }
+    fun rotateMut(rot: Rotation): Double3 {
+        val rotX = rot.rotatedComponent(EAST, x, y, z)
+        val rotY = rot.rotatedComponent(UP, x, y, z)
+        val rotZ = rot.rotatedComponent(SOUTH, x, y, z)
+        return setTo(rotX, rotY, rotZ)
+    }
+
+    // misc operations
+    infix fun dot(other: Double3) = x * other.x + y * other.y + z * other.z
+    infix fun cross(o: Double3) = Double3(y * o.z - z * o.y, z * o.x - x * o.z, x * o.y - y * o.x)
+    val length: Double get() = Math.sqrt(x * x + y * y + z * z)
+    val normalize: Double3 get() = (1.0 / length).let { Double3(x * it, y * it, z * it) }
+    val nearestCardinal: Direction get() = nearestAngle(this, allDirections.asIterable()) { it.vec }.first
+}
+
+/** 3D vector of [Int]s. Offers both mutable operations, and immutable operations in operator notation. */
+data class Int3(var x: Int, var y: Int, var z: Int) {
+    constructor(dir: Direction) : this(dir.directionVec.x, dir.directionVec.y, dir.directionVec.z)
+    constructor(offset: Pair<Int, Direction>) : this(
+        offset.first * offset.second.directionVec.x,
+        offset.first * offset.second.directionVec.y,
+        offset.first * offset.second.directionVec.z
+    )
+    companion object {
+        val zero = Int3(0, 0, 0)
+    }
+
+    // immutable operations
+    operator fun plus(other: Int3) = Int3(x + other.x, y + other.y, z + other.z)
+    operator fun plus(other: Pair<Int, Direction>) = Int3(
+        x + other.first * other.second.directionVec.x,
+        y + other.first * other.second.directionVec.y,
+        z + other.first * other.second.directionVec.z
+    )
+    operator fun unaryMinus() = Int3(-x, -y, -z)
+    operator fun minus(other: Int3) = Int3(x - other.x, y - other.y, z - other.z)
+    operator fun times(scale: Int) = Int3(x * scale, y * scale, z * scale)
+    operator fun times(other: Int3) = Int3(x * other.x, y * other.y, z * other.z)
+
+    /** Rotate this vector, and return coordinates in the unrotated frame */
+    fun rotate(rot: Rotation) = Int3(
+        rot.rotatedComponent(EAST, x, y, z),
+        rot.rotatedComponent(UP, x, y, z),
+        rot.rotatedComponent(SOUTH, x, y, z)
+    )
+
+    // mutable operations
+    fun setTo(other: Int3): Int3 { x = other.x; y = other.y; z = other.z; return this }
+    fun setTo(x: Int, y: Int, z: Int): Int3 { this.x = x; this.y = y; this.z = z; return this }
+    fun add(other: Int3): Int3 { x += other.x; y += other.y; z += other.z; return this }
+    fun sub(other: Int3): Int3 { x -= other.x; y -= other.y; z -= other.z; return this }
+    fun invert(): Int3 { x = -x; y = -y; z = -z; return this }
+    fun mul(scale: Int): Int3 { x *= scale; y *= scale; z *= scale; return this }
+    fun mul(other: Int3): Int3 { x *= other.x; y *= other.y; z *= other.z; return this }
+    fun rotateMut(rot: Rotation): Int3 {
+        val rotX = rot.rotatedComponent(EAST, x, y, z)
+        val rotY = rot.rotatedComponent(UP, x, y, z)
+        val rotZ = rot.rotatedComponent(SOUTH, x, y, z)
+        return setTo(rotX, rotY, rotZ)
+    }
+}
+
+// ================================
+// Rotation
+// ================================
+val Direction.rotations: Array<Direction> get() =
+    Array(6) { idx -> Direction.values()[ROTATION_MATRIX[ordinal][idx]] }
+fun Direction.rotate(rot: Rotation) = rot.forward[ordinal]
+fun rot(axis: Direction) = Rotation.rot90[axis.ordinal]
+
+/**
+ * Class representing an arbitrary rotation (or combination of rotations) around cardinal axes by 90 degrees.
+ * In effect, a permutation of [ForgeDirection]s.
+ */
+@Suppress("NOTHING_TO_INLINE")
+class Rotation(val forward: Array<Direction>, val reverse: Array<Direction>) {
+    operator fun plus(other: Rotation) = Rotation(
+        Array(6) { idx -> forward[other.forward[idx].ordinal] },
+        Array(6) { idx -> other.reverse[reverse[idx].ordinal] }
+    )
+    operator fun unaryMinus() = Rotation(reverse, forward)
+    operator fun times(num: Int) = when(num % 4) { 1 -> this; 2 -> this + this; 3 -> -this; else -> identity }
+
+    inline fun rotatedComponent(dir: Direction, x: Int, y: Int, z: Int) =
+        when(reverse[dir.ordinal]) { EAST -> x; WEST -> -x; UP -> y; DOWN -> -y; SOUTH -> z; NORTH -> -z; else -> 0 }
+    inline fun rotatedComponent(dir: Direction, x: Double, y: Double, z: Double) =
+        when(reverse[dir.ordinal]) { EAST -> x; WEST -> -x; UP -> y; DOWN -> -y; SOUTH -> z; NORTH -> -z; else -> 0.0 }
+
+    companion object {
+        // Forge rotation matrix is left-hand
+        val rot90 = Array(6) { idx -> Rotation(allDirections[idx].opposite.rotations, allDirections[idx].rotations) }
+        val identity = Rotation(allDirections, allDirections)
+    }
+
+}
+
+// ================================
+// Miscellaneous
+// ================================
+
+inline operator fun <reified T> Array<T>.get(face: Direction): T = get(face.ordinal)
+
+data class BoxFace(val top: Direction, val left: Direction) {
+
+    val allCorners = listOf(top to left, top to left.opposite, top.opposite to left, top.opposite to left.opposite)
+}
+val boxFaces = allDirections.map { when(it) {
+    DOWN -> BoxFace(SOUTH, WEST)
+    UP -> BoxFace(SOUTH, EAST)
+    NORTH -> BoxFace(WEST, UP)
+    SOUTH -> BoxFace(UP, WEST)
+    WEST -> BoxFace(SOUTH, UP)
+    EAST -> BoxFace(SOUTH, DOWN)
+}}.toTypedArray()
+
+/** List of all 12 box edges, represented as a [Pair] of [ForgeDirection]s */
+val boxEdges = allDirections.flatMap { face1 -> allDirections.filter { it.axis > face1.axis }.map { face1 to it } }
+
+/**
+ * Get the closest object to the specified point from a list of objects.
+ *
+ * @param[vertex] the reference point
+ * @param[objs] list of geomertric objects
+ * @param[objPos] lambda to calculate the position of an object
+ * @return [Pair] of (object, distance)
+ */
+fun <T> nearestPosition(vertex: Double3, objs: Iterable<T>, objPos: (T)-> Double3): Pair<T, Double>  =
+        objs.map { it to (objPos(it) - vertex).length }.minBy { it.second }!!
+
+/**
+ * Get the object closest in orientation to the specified vector from a list of objects.
+ *
+ * @param[vector] the reference vector (direction)
+ * @param[objs] list of geomertric objects
+ * @param[objAngle] lambda to calculate the orientation of an object
+ * @return [Pair] of (object, normalized dot product)
+ */
+fun <T> nearestAngle(vector: Double3, objs: Iterable<T>, objAngle: (T)-> Double3): Pair<T, Double> =
+        objs.map { it to objAngle(it).dot(vector) }.maxBy { it.second }!!
--- a/src/main/kotlin/mods/betterfoliage/util/Gui.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Gui.kt
@@ -0,0 +1,22 @@
+@file:JvmName("Utils")
+package mods.betterfoliage.util
+
+import net.minecraft.util.text.StringTextComponent
+import net.minecraft.util.text.Style
+import net.minecraft.util.text.TextFormatting
+import net.minecraft.util.text.TextFormatting.AQUA
+import net.minecraft.util.text.TextFormatting.GRAY
+
+fun stripTooltipDefaultText(tooltip: MutableList<String>) {
+    var defaultRows = false
+    val iter = tooltip.iterator()
+    while (iter.hasNext()) {
+        if (iter.next().startsWith(AQUA.toString())) defaultRows = true
+        if (defaultRows) iter.remove()
+    }
+}
+
+fun textComponent(msg: String, color: TextFormatting = GRAY): StringTextComponent {
+    val style = Style().apply { this.color = color }
+    return StringTextComponent(msg).apply { this.style = style }
+}
--- a/src/main/kotlin/mods/betterfoliage/util/Misc.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Misc.kt
@@ -0,0 +1,75 @@
+@file:Suppress("NOTHING_TO_INLINE")
+package mods.betterfoliage.util
+
+import net.minecraft.util.ResourceLocation
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.World
+import org.apache.logging.log4j.Level
+import org.apache.logging.log4j.Logger
+import java.lang.Math.*
+import kotlin.reflect.KProperty
+
+const val PI2 = 2.0 * PI
+
+/** Strip the given prefix off the start of the string, if present */
+inline fun String.stripStart(str: String, ignoreCase: Boolean = true) = if (startsWith(str, ignoreCase)) substring(str.length) else this
+inline fun String.stripEnd(str: String, ignoreCase: Boolean = true) = if (endsWith(str, ignoreCase)) substring(0, length - 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))
+inline fun ResourceLocation.stripEnd(str: String) = ResourceLocation(namespace, path.stripEnd(str))
+
+/**
+ * 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) }
+}
+
+/** 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 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 IWorldReader.isBlockLoaded(pos: BlockPos) = when {
+//    this is World -> isBlockLoaded(pos, false)
+//    this is RenderChunkCache -> isworld.isBlockLoaded(pos, false)
+//    Refs.OptifineChunkCache.isInstance(this) -> (Refs.CCOFChunkCache.get(this) as ChunkCache).world.isBlockLoaded(pos, false)
+//    else -> false
+//}
+
+interface HasLogger {
+    val logger: Logger
+    val logName: String get() = this::class.simpleName!!
+    fun log(msg: String) = log(Level.INFO, msg)
+    fun log(level: Level, msg: String) = logger.log(level, "[$logName] $msg")
+    fun log(msg: String, e: Throwable) = log(Level.WARN, msg, e)
+    fun log(level: Level, msg: String, e: Throwable) = logger.log(level, "[$logName] $msg", e)
+}
+
+//fun textComponent(msg: String, color: Formatting = Formatting.GRAY): LiteralText {
+//    val style = Style().apply { this.color = color }
+//    return LiteralText(msg).apply { this.style = style }
+//}
--- a/src/main/kotlin/mods/betterfoliage/util/Random.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Random.kt
@@ -0,0 +1,18 @@
+package mods.betterfoliage.util
+
+import net.minecraft.util.math.BlockPos
+import java.util.Random
+
+val random = Random(System.nanoTime())
+
+fun randomB() = random.nextBoolean()
+fun randomI(min: Int = 0, max: Int = Int.MAX_VALUE) = min + random.nextInt(max - min)
+fun randomD(min: Double = 0.0, max: Double = 1.0) = random.nextDouble() * (max - min) + min
+
+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))
+    value = (3 * x * value + 5 * y * value + 7 * z * value + (11 * seed))
+    return value shr 4
+}
+
+fun BlockPos.semiRandom(seed: Int) = semiRandom(x, y, z, seed)
--- a/src/main/kotlin/mods/betterfoliage/util/Reflection.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Reflection.kt
@@ -0,0 +1,179 @@
+@file:JvmName("Reflection")
+package mods.betterfoliage.util
+
+import java.lang.reflect.Field
+import java.lang.reflect.Method
+import mods.betterfoliage.util.Namespace.*
+
+/** Get a Java class with the given name. */
+fun getJavaClass(name: String) = tryDefault(null) { Class.forName(name) }
+
+/** Get the field with the given name and type using reflection. */
+inline fun <reified T> Any.reflectField(field: String): T? =
+    tryDefault(null) { this.javaClass.getDeclaredField(field) }?.let {
+        it.isAccessible = true
+        it.get(this) as T
+    }
+
+/** Get the static field with the given name and type using reflection. */
+inline fun <reified T> Class<*>.reflectStaticField(field: String): T? =
+    tryDefault(null) { this.getDeclaredField(field) }?.let {
+        it.isAccessible = true
+        it.get(null) as T
+    }
+
+/**
+ * Get all nested _object_s of this _object_ with reflection.
+ *
+ * @return [Pair]s of (name, instance)
+ */
+val Any.reflectNestedObjects: List<Pair<String, Any>> get() = this.javaClass.declaredClasses.map {
+    tryDefault(null) { it.name.split("$")[1] to it.getField("INSTANCE").get(null) }
+}.filterNotNull()
+
+/**
+ * Get all fields of this instance that match (or subclass) any of the given classes.
+ *
+ * @param[types] classes to look for
+ * @return [Pair]s of (field name, instance)
+ */
+fun Any.reflectFieldsOfType(vararg types: Class<*>) = this.javaClass.declaredFields
+    .filter { field -> types.any { it.isAssignableFrom(field.type) } }
+    .map { field -> field.name to field.let { it.isAccessible = true; it.get(this) } }
+    .filterNotNull()
+
+fun <T> Any.reflectFields(type: Class<T>) = this.javaClass.declaredFields
+    .filter { field -> type.isAssignableFrom(field.type) }
+    .map { field -> field.name to field.let { it.isAccessible = true; it.get(this) as T } }
+
+fun <T> Any.reflectDelegates(type: Class<T>) = this.javaClass.declaredFields
+    .filter { field -> type.isAssignableFrom(field.type) && field.name.contains("$") }
+    .map { field -> field.name.split("$")[0] to field.let { it.isAccessible = true; it.get(this) } as T }
+
+enum class Namespace { MCP, SRG }
+
+abstract class Resolvable<T> {
+    abstract fun resolve(): T?
+    val element: T? by lazy { resolve() }
+}
+
+/** Return true if all given elements are found. */
+fun allAvailable(vararg codeElement: Resolvable<*>) = codeElement.all { it.element != null }
+
+/**
+ * Reference to a class.
+ *
+ * @param[name] MCP name of the class
+ */
+open class ClassRef<T: Any?>(val name: String) : Resolvable<Class<T>>() {
+
+    companion object {
+        val int = ClassRefPrimitive("I", Int::class.java)
+        val long = ClassRefPrimitive("J", Long::class.java)
+        val float = ClassRefPrimitive("F", Float::class.java)
+        val boolean = ClassRefPrimitive("Z", Boolean::class.java)
+        val void = ClassRefPrimitive("V", Void::class.java)
+    }
+
+    open fun asmDescriptor(namespace: Namespace) = "L${name.replace(".", "/")};"
+
+    override fun resolve() = getJavaClass(name) as Class<T>?
+
+    fun isInstance(obj: Any) = element?.isInstance(obj) ?: false
+}
+
+/**
+ * Reference to a primitive type.
+ *
+ * @param[name] ASM descriptor of this primitive type
+ * @param[clazz] class of this primitive type
+ */
+class ClassRefPrimitive<T>(name: String, val clazz: Class<T>?) : ClassRef<T>(name) {
+    override fun asmDescriptor(namespace: Namespace) = name
+    override fun resolve() = clazz
+}
+
+/**
+ * Reference to a method.
+ *
+ * @param[parentClass] reference to the class containing the method
+ * @param[mcpName] MCP name of the method
+ * @param[srgName] SRG name of the method
+ * @param[returnType] reference to the return type
+ * @param[returnType] references to the argument types
+ */
+class MethodRef<T: Any?>(val parentClass: ClassRef<*>,
+                         val mcpName: String,
+                         val srgName: String,
+                         val returnType: ClassRef<T>,
+                         vararg val argTypes: ClassRef<*>
+) : Resolvable<Method>() {
+    constructor(parentClass: ClassRef<*>, mcpName: String, returnType: ClassRef<T>, vararg argTypes: ClassRef<*>) :
+    this(parentClass, mcpName, mcpName, returnType, *argTypes)
+
+    fun name(namespace: Namespace) = when(namespace) { SRG -> srgName; MCP -> mcpName }
+    fun asmDescriptor(namespace: Namespace) = "(${argTypes.map { it.asmDescriptor(namespace) }.fold(""){ s1, s2 -> s1 + s2 } })${returnType.asmDescriptor(namespace)}"
+
+    override fun resolve(): Method? =
+        if (parentClass.element == null || argTypes.any { it.element == null }) null
+        else {
+            val args = argTypes.map { it.element!! }.toTypedArray()
+            listOf(srgName, mcpName).map { tryDefault(null) {
+                parentClass.element!!.getDeclaredMethod(it, *args)
+            }}.filterNotNull().firstOrNull()
+            ?.apply { isAccessible = true }
+        }
+
+    /** Invoke this method using reflection. */
+    operator fun invoke(receiver: Any, vararg args: Any?) = element?.invoke(receiver, *args) as T
+
+    /** Invoke this static method using reflection. */
+    fun invokeStatic(vararg args: Any) = element?.invoke(null, *args)
+}
+
+/**
+ * Reference to a field.
+ *
+ * @param[parentClass] reference to the class containing the field
+ * @param[mcpName] MCP name of the field
+ * @param[srgName] SRG name of the field
+ * @param[type] reference to the field type
+ */
+class FieldRef<T>(val parentClass: ClassRef<*>,
+                  val mcpName: String,
+                  val srgName: String,
+                  val type: ClassRef<T>
+) : Resolvable<Field>() {
+    constructor(parentClass: ClassRef<*>, mcpName: String, type: ClassRef<T>) : this(parentClass, mcpName, mcpName, type)
+
+    fun name(namespace: Namespace) = when(namespace) { SRG -> srgName; MCP -> mcpName }
+    fun asmDescriptor(namespace: Namespace) = type.asmDescriptor(namespace)
+
+    override fun resolve(): Field? =
+        if (parentClass.element == null) null
+        else {
+            listOf(srgName, mcpName).mapNotNull { tryDefault(null) {
+                parentClass.element!!.getDeclaredField(it)
+            } }.firstOrNull()
+            ?.apply{ isAccessible = true }
+        }
+
+    /** Get this field using reflection. */
+    operator fun get(receiver: Any?) = element?.get(receiver) as T
+
+    /** Get this static field using reflection. */
+    fun getStatic() = get(null)
+
+    fun set(receiver: Any?, obj: Any?) { element?.set(receiver, obj) }
+}
+
+
+fun Any.isInstance(cls: ClassRef<*>) = cls.isInstance(this)
+interface ReflectionCallable<T> {
+    operator fun invoke(vararg args: Any): T
+}
+inline operator fun <reified T> Any.get(field: FieldRef<T>) = field.get(this)
+inline operator fun <reified T> Any.set(field: FieldRef<T>, value: T) = field.set(this, value)
+inline operator fun <T> Any.get(methodRef: MethodRef<T>) = object : ReflectionCallable<T> {
+    override fun invoke(vararg args: Any) = methodRef.invoke(this@get, args)
+}
--- a/src/main/kotlin/mods/betterfoliage/util/Resources.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Resources.kt
@@ -0,0 +1,26 @@
+package mods.betterfoliage.util
+
+import net.minecraft.client.Minecraft
+import net.minecraft.resources.IReloadableResourceManager
+import net.minecraft.resources.IResource
+import net.minecraft.resources.IResourceManager
+import net.minecraft.util.ResourceLocation
+
+/** Concise getter for the Minecraft resource manager. */
+val resourceManager: IReloadableResourceManager
+    get() = Minecraft.getInstance().resourceManager as IReloadableResourceManager
+
+/** Append a string to the [ResourceLocation]'s path. */
+operator fun ResourceLocation.plus(str: String) = ResourceLocation(namespace, path + str)
+
+/** Index operator to get a resource. */
+operator fun IResourceManager.get(domain: String, path: String): IResource? = get(ResourceLocation(domain, path))
+/** Index operator to get a resource. */
+operator fun IResourceManager.get(location: ResourceLocation): IResource? = tryDefault(null) { getResource(location) }
+
+/** Get the lines of a text resource. */
+fun IResource.getLines(): List<String> {
+    val result = arrayListOf<String>()
+    inputStream.bufferedReader().useLines { it.forEach { result.add(it) } }
+    return result
+}
--- a/src/main/kotlin/mods/betterfoliage/util/Sprites.kt
+++ b/src/main/kotlin/mods/betterfoliage/util/Sprites.kt
@@ -0,0 +1,86 @@
+package mods.betterfoliage.util
+
+import mods.betterfoliage.render.lighting.HSB
+import net.minecraft.client.Minecraft
+import net.minecraft.client.renderer.texture.AtlasTexture
+import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.resources.IResource
+import net.minecraft.resources.IResourceManager
+import net.minecraft.util.ResourceLocation
+import java.awt.image.BufferedImage
+import java.io.ByteArrayOutputStream
+import java.io.IOException
+import javax.imageio.ImageIO
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.sin
+
+enum class Atlas(val basePath: String, val resourceId: ResourceLocation) {
+    BLOCKS("textures", AtlasTexture.LOCATION_BLOCKS_TEXTURE),
+    PARTICLES("textures", AtlasTexture.LOCATION_PARTICLES_TEXTURE);
+
+    /** Get the fully-qualified resource name for sprites belonging to this atlas*/
+    fun wrap(resource: ResourceLocation) = ResourceLocation(resource.namespace, "$basePath/${resource.path}.png")
+
+    /** Get the short resource name for sprites belonging to this atlas*/
+    fun unwrap(resource: ResourceLocation) = resource.stripStart("$basePath/").stripEnd(".png")
+
+    /** Reference to the atlas itself */
+    val atlas: AtlasTexture get() = Minecraft.getInstance().textureManager.getTexture(resourceId) as AtlasTexture
+}
+
+inline operator fun AtlasTexture.get(res: ResourceLocation): TextureAtlasSprite? = this.getSprite(res)
+inline operator fun AtlasTexture.get(name: String): TextureAtlasSprite? = get(ResourceLocation(name))
+
+fun IResourceManager.loadSprite(id: ResourceLocation) = this.get(id)?.loadImage() ?: throw IOException("Cannot load resource $id")
+
+fun IResource.loadImage(): BufferedImage? = ImageIO.read(this.inputStream)
+
+/** Index operator to get the RGB value of a pixel. */
+operator fun BufferedImage.get(x: Int, y: Int) = this.getRGB(x, y)
+/** Index operator to set the RGB value of a pixel. */
+operator fun BufferedImage.set(x: Int, y: Int, value: Int) = this.setRGB(x, y, value)
+
+val BufferedImage.bytes: ByteArray get() =
+    ByteArrayOutputStream().let { ImageIO.write(this, "PNG", it); it.toByteArray() }
+
+/**
+ * Calculate the average color of a texture.
+ *
+ * Only non-transparent pixels are considered. Averages are taken in the HSB color space (note: Hue is a circular average),
+ * and the result transformed back to the RGB color space.
+ */
+val TextureAtlasSprite.averageColor: Int get() {
+    var numOpaque = 0
+    var sumHueX = 0.0
+    var sumHueY = 0.0
+    var sumSaturation = 0.0f
+    var sumBrightness = 0.0f
+    for (x in 0 until width)
+        for (y in 0 until height) {
+            val pixel = getPixelRGBA(0, x, y)
+            val alpha = (pixel shr 24) and 255
+            val hsb = HSB.fromColor(pixel)
+            if (alpha == 255) {
+                numOpaque++
+                sumHueX += cos((hsb.hue.toDouble() - 0.5) * PI2)
+                sumHueY += sin((hsb.hue.toDouble() - 0.5) * PI2)
+                sumSaturation += hsb.saturation
+                sumBrightness += hsb.brightness
+            }
+        }
+
+    // circular average - transform sum vector to polar angle
+    val avgHue = (atan2(sumHueY, sumHueX) / PI2 + 0.5).toFloat()
+    return HSB(avgHue, sumSaturation / numOpaque.toFloat(), sumBrightness / numOpaque.toFloat()).asColor
+}
+
+/** Weighted blend of 2 packed RGB colors */
+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)
+    return result
+}