[WIP] 1.14.4 port

2020-01-01 16:57:47 +01:00
parent 1ea2b6b946
commit 46cbe64328
164 changed files with 1715 additions and 2115 deletions
--- a/src/main/kotlin/mods/betterfoliage/BetterFoliage.kt
+++ b/src/main/kotlin/mods/betterfoliage/BetterFoliage.kt
@@ -0,0 +1,57 @@
+package mods.betterfoliage
+
+import mods.betterfoliage.client.Client
+import mods.betterfoliage.client.config.Config
+import mods.betterfoliage.client.isAfterPostInit
+import mods.octarinecore.client.resource.GeneratorPack
+import net.alexwells.kottle.FMLKotlinModLoadingContext
+import net.minecraft.client.Minecraft
+import net.minecraftforge.eventbus.api.IEventBus
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import net.minecraftforge.fml.ModLoadingContext
+import net.minecraftforge.fml.common.Mod
+import net.minecraftforge.fml.config.ModConfig
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent
+import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent
+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(BetterFoliage.MOD_ID)
+object BetterFoliage {
+    const val MOD_ID = "betterfoliage"
+    const val MOD_NAME = "Better Foliage"
+
+    val modBus = FMLKotlinModLoadingContext.get().modEventBus
+
+    var log = LogManager.getLogger("BetterFoliage")
+    var logDetail = SimpleLogger(
+        "BetterFoliage",
+        DEBUG,
+        false, false, true, false,
+        "yyyy-MM-dd HH:mm:ss",
+        null,
+        PropertiesUtil(Properties()),
+        PrintStream(File("logs/betterfoliage.log").apply {
+            parentFile.mkdirs()
+            if (!exists()) createNewFile()
+        })
+    )
+
+    val genPack = GeneratorPack(
+        "bf_gen",
+        "Better Foliage generated assets",
+        "bf_generated_pack.png"
+    )
+
+    init {
+        log.log(DEBUG, "Constructing mod")
+        ModLoadingContext.get().registerConfig(ModConfig.Type.CLIENT, Config.build())
+        Minecraft.getInstance().resourcePackList.addPackFinder(genPack.packFinder)
+        Client.init()
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt
+++ b/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt
@@ -1,78 +0,0 @@
-package mods.betterfoliage
-
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.isAfterPostInit
-import net.minecraftforge.common.config.Configuration
-import net.minecraftforge.fml.common.FMLCommonHandler
-import net.minecraftforge.fml.common.Mod
-import net.minecraftforge.fml.common.event.FMLPostInitializationEvent
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent
-import net.minecraftforge.fml.common.network.NetworkCheckHandler
-import net.minecraftforge.fml.relauncher.Side
-import org.apache.logging.log4j.Level.DEBUG
-import org.apache.logging.log4j.Level.INFO
-import org.apache.logging.log4j.Logger
-import org.apache.logging.log4j.simple.SimpleLogger
-import org.apache.logging.log4j.util.PropertiesUtil
-import java.io.File
-import java.io.PrintStream
-import java.util.*
-
-@Mod(
-    modid = BetterFoliageMod.MOD_ID,
-    name = BetterFoliageMod.MOD_NAME,
-    acceptedMinecraftVersions = BetterFoliageMod.MC_VERSIONS,
-    guiFactory = BetterFoliageMod.GUI_FACTORY,
-    dependencies = "after:forgelin",
-    modLanguageAdapter = "net.shadowfacts.forgelin.KotlinAdapter",
-    clientSideOnly = true
-)
-object BetterFoliageMod {
-
-    const val MOD_ID = "betterfoliage"
-    const val MOD_NAME = "Better Foliage"
-    const val DOMAIN = "betterfoliage"
-    const val LEGACY_DOMAIN = "bettergrassandleaves"
-    const val MC_VERSIONS = "[1.12]"
-    const val GUI_FACTORY = "mods.betterfoliage.client.gui.ConfigGuiFactory"
-
-    lateinit var log: Logger
-    lateinit var logDetail: Logger
-
-    var config: Configuration? = null
-
-    init {
-        // inject pack into default list at construction time to get domains enumerated
-        // there's no 2nd resource reload pass anymore
-        Client.generatorPack.inject()
-    }
-
-    @Mod.EventHandler
-    fun preInit(event: FMLPreInitializationEvent) {
-        log = event.modLog
-        val logDetailFile = File(event.modConfigurationDirectory.parentFile, "logs/betterfoliage.log").apply {
-            parentFile.mkdirs()
-            if (!exists()) createNewFile()
-        }
-        logDetail = SimpleLogger(
-            "BetterFoliage",
-            DEBUG,
-            false, false, true, false,
-            "yyyy-MM-dd HH:mm:ss",
-            null,
-            PropertiesUtil(Properties()),
-            PrintStream(logDetailFile)
-        )
-        config = Configuration(event.suggestedConfigurationFile, null, true)
-
-        Config.attach(config!!)
-        Client.init()
-        Client.log(INFO, "BetterFoliage initialized")
-        isAfterPostInit = true
-    }
-
-    /** Mod is cosmetic only, always allow connection. */
-    @NetworkCheckHandler
-    fun checkVersion(mods: Map<String, String>, side: Side) = true
-}
--- a/src/main/kotlin/mods/betterfoliage/client/Client.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/Client.kt
@@ -1,53 +1,48 @@
 package mods.betterfoliage.client

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.gui.ConfigGuiFactory
-import mods.betterfoliage.client.integration.*
+import mods.betterfoliage.client.config.BlockConfig
+import mods.betterfoliage.client.integration.ForestryIntegration
+import mods.betterfoliage.client.integration.IC2RubberIntegration
+import mods.betterfoliage.client.integration.OptifineCustomColors
+import mods.betterfoliage.client.integration.TechRebornRubberIntegration
 import mods.betterfoliage.client.render.*
 import mods.betterfoliage.client.texture.*
-import mods.octarinecore.client.KeyHandler
 import mods.octarinecore.client.gui.textComponent
 import mods.octarinecore.client.render.AbstractBlockRenderingHandler
 import mods.octarinecore.client.resource.CenteringTextureGenerator
 import mods.octarinecore.client.resource.GeneratorPack
-import net.minecraft.block.Block
-import net.minecraft.block.state.IBlockState
+import mods.octarinecore.client.resource.IConfigChangeListener
+import net.minecraft.block.BlockState
 import net.minecraft.client.Minecraft
 import net.minecraft.util.math.BlockPos
-import net.minecraft.util.text.TextComponentTranslation
 import net.minecraft.util.text.TextFormatting
-import net.minecraftforge.fml.client.FMLClientHandler
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraft.util.text.TranslationTextComponent
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import net.minecraftforge.fml.config.ModConfig
+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.
- *
- * This and all other singletons are annotated [SideOnly] to avoid someone accidentally partially
- * initializing the mod on a server environment.
 */
-@SideOnly(Side.CLIENT)
 object Client {
+    var renderers= emptyList<AbstractBlockRenderingHandler>()
+    var configListeners = emptyList<IConfigChangeListener>()

-    lateinit var renderers: List<AbstractBlockRenderingHandler>
-    val suppressRenderErrors = mutableSetOf<IBlockState>()
+    val suppressRenderErrors = mutableSetOf<BlockState>()

-    // texture generation stuff
+    // texture generators
    val genGrass = GrassGenerator("bf_gen_grass")
    val genLeaves = LeafGenerator("bf_gen_leaves")
    val genReeds = CenteringTextureGenerator("bf_gen_reeds", 1, 2)

-    val generatorPack = GeneratorPack(
-        "Better Foliage generated",
-        genGrass,
-        genLeaves,
-        genReeds
-    )
-
    fun init() {
+        // add resource generators to pack
+        listOf(genGrass, genLeaves, genReeds).forEach { BetterFoliage.genPack.generators.add(it) }
+
        // init renderers
        renderers = listOf(
            RenderGrass(),
@@ -66,6 +61,7 @@ object Client {

        // init other singletons
        val singletons = listOf(
+            BlockConfig,
            StandardCactusRegistry,
            LeafParticleRegistry,
            ChunkOverlayManager,
@@ -75,7 +71,7 @@ object Client {

        // init mod integrations
        val integrations = listOf(
-            ShadersModIntegration,
+//            ShadersModIntegration,
            OptifineCustomColors,
            ForestryIntegration,
            IC2RubberIntegration,
@@ -87,30 +83,26 @@ object Client {
        LeafRegistry.addRegistry(StandardLeafRegistry)
        LogRegistry.addRegistry(StandardLogRegistry)

-        // init config hotkey
-        val configKey = KeyHandler(BetterFoliageMod.MOD_NAME, 66, "key.betterfoliage.gui") {
-            FMLClientHandler.instance().showGuiScreen(
-                ConfigGuiFactory.createBFConfigGui(Minecraft.getMinecraft().currentScreen)
-            )
-        }
+        configListeners = listOf(renderers, singletons, integrations).flatten().filterIsInstance<IConfigChangeListener>()
+        configListeners.forEach { it.onConfigChange() }
    }

    fun log(level: Level, msg: String) {
-        BetterFoliageMod.log.log(level, "[BetterFoliage] $msg")
-        BetterFoliageMod.logDetail.log(level, msg)
+        BetterFoliage.log.log(level, "[BetterFoliage] $msg")
+        BetterFoliage.logDetail.log(level, msg)
    }

    fun logDetail(msg: String) {
-        BetterFoliageMod.logDetail.log(Level.DEBUG, msg)
+        BetterFoliage.logDetail.log(Level.DEBUG, msg)
    }

-    fun logRenderError(state: IBlockState, location: BlockPos) {
+    fun logRenderError(state: BlockState, location: BlockPos) {
        if (state in suppressRenderErrors) return
        suppressRenderErrors.add(state)

-        val blockName = Block.REGISTRY.getNameForObject(state.block).toString()
+        val blockName = ForgeRegistries.BLOCKS.getKey(state.block).toString()
        val blockLoc = "${location.x},${location.y},${location.z}"
-        Minecraft.getMinecraft().ingameGUI.chatGUI.printChatMessage(TextComponentTranslation(
+        Minecraft.getInstance().ingameGUI.chatGUI.printChatMessage(TranslationTextComponent(
            "betterfoliage.rendererror",
            textComponent(blockName, TextFormatting.GOLD),
            textComponent(blockLoc, TextFormatting.GOLD)
--- a/src/main/kotlin/mods/betterfoliage/client/Hooks.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/Hooks.kt
@@ -1,7 +1,9 @@
@file:JvmName("Hooks")
-@file:SideOnly(Side.CLIENT)
 package mods.betterfoliage.client

+import mods.betterfoliage.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.betterfoliage.loader.Refs
@@ -10,46 +12,43 @@ import mods.octarinecore.client.resource.LoadModelDataEvent
 import mods.octarinecore.common.plus
 import mods.octarinecore.metaprog.allAvailable
 import net.minecraft.block.Block
-import net.minecraft.block.state.IBlockState
+import net.minecraft.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.init.Blocks
+import net.minecraft.client.renderer.model.ModelBakery
+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.EnumFacing
+import net.minecraft.util.Direction
 import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
+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.World
-import net.minecraftforge.client.model.ModelLoader
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraftforge.client.model.data.IModelData
+import java.util.*

 var isAfterPostInit = false
 val isOptifinePresent = allAvailable(Refs.OptifineClassTransformer)

-fun doesSideBlockRenderingOverride(original: Boolean, blockAccess: IBlockAccess, pos: BlockPos, side: EnumFacing): Boolean {
-    return original && !(Config.enabled && Config.roundLogs.enabled && Config.blocks.logClasses.matchesClass(blockAccess.getBlockState(pos).block));
+fun getAmbientOcclusionLightValueOverride(original: Float, state: BlockState): Float {
+    if (Config.enabled && Config.roundLogs.enabled && BlockConfig.logBlocks.matchesClass(state.block)) return Config.roundLogs.dimming.toFloat();
+    return original
 }

-fun isOpaqueCubeOverride(original: Boolean, state: IBlockState): Boolean {
-    // caution: blocks are initialized and the method called during startup
-    if (!isAfterPostInit) return original
-    return original && !(Config.enabled && Config.roundLogs.enabled && Config.blocks.logClasses.matchesClass(state.block))
+fun getUseNeighborBrightnessOverride(original: Boolean, state: BlockState): Boolean {
+    return original || (Config.enabled && Config.roundLogs.enabled && BlockConfig.logBlocks.matchesClass(state.block));
 }

-fun getAmbientOcclusionLightValueOverride(original: Float, state: IBlockState): Float {
-    if (Config.enabled && Config.roundLogs.enabled && Config.blocks.logClasses.matchesClass(state.block)) return Config.roundLogs.dimming;
-    return original;
+fun onClientBlockChanged(worldClient: ClientWorld, pos: BlockPos, oldState: BlockState, newState: BlockState, flags: Int) {
+    ChunkOverlayManager.onBlockChange(worldClient, pos)
 }

-fun getUseNeighborBrightnessOverride(original: Boolean, state: IBlockState): Boolean {
-    return original || (Config.enabled && Config.roundLogs.enabled && Config.blocks.logClasses.matchesClass(state.block));
-}
-
-fun onRandomDisplayTick(world: World, state: IBlockState, pos: BlockPos) {
+fun onRandomDisplayTick(block: Block, state: BlockState, world: World, pos: BlockPos, random: Random) {
    if (Config.enabled &&
        Config.risingSoul.enabled &&
        state.block == Blocks.SOUL_SAND &&
@@ -60,42 +59,52 @@ fun onRandomDisplayTick(world: World, state: IBlockState, pos: BlockPos) {

    if (Config.enabled &&
        Config.fallingLeaves.enabled &&
-        Config.blocks.leavesClasses.matchesClass(state.block) &&
+        BlockConfig.leafBlocks.matchesClass(state.block) &&
        world.isAirBlock(pos + down1) &&
        Math.random() < Config.fallingLeaves.chance) {
            EntityFallingLeavesFX(world, pos).addIfValid()
    }
 }

-fun onAfterLoadModelDefinitions(loader: ModelLoader) {
-    MinecraftForge.EVENT_BUS.post(LoadModelDataEvent(loader))
+fun onLoadModelDefinitions(bakery: Any) {
+    BetterFoliage.modBus.post(LoadModelDataEvent(bakery as ModelBakery))
+}
+
+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)
 }

 fun renderWorldBlock(dispatcher: BlockRendererDispatcher,
-                     state: IBlockState,
+                     state: BlockState,
                     pos: BlockPos,
-                     blockAccess: IBlockAccess,
-                     worldRenderer: BufferBuilder,
+                     reader: IEnviromentBlockReader,
+                     buffer: BufferBuilder,
+                     random: Random,
+                     modelData: IModelData,
                     layer: BlockRenderLayer
 ): Boolean {
    val doBaseRender = state.canRenderInLayer(layer) || (layer == targetCutoutLayer && state.canRenderInLayer(otherCutoutLayer))
    blockContext.let { ctx ->
-        ctx.set(blockAccess, pos)
+        ctx.set(reader, pos)
        Client.renderers.forEach { renderer ->
            if (renderer.isEligible(ctx)) {
                // render on the block's default layer
                // also render on the cutout layer if the renderer requires it
                if (doBaseRender || (renderer.addToCutout && layer == targetCutoutLayer)) {
-                    return renderer.render(ctx, dispatcher, worldRenderer, layer)
+                    return renderer.render(ctx, dispatcher, buffer, random, modelData, layer)
                }
            }
        }
    }

-    return if (doBaseRender) dispatcher.renderBlock(state, pos, blockAccess, worldRenderer) else false
+    return if (doBaseRender) dispatcher.renderBlock(state, pos, reader, buffer, random, modelData) else false
 }

-fun canRenderBlockInLayer(block: Block, state: IBlockState, layer: BlockRenderLayer) = block.canRenderInLayer(state, layer) || layer == targetCutoutLayer
+fun canRenderInLayerOverride(state: BlockState, layer: BlockRenderLayer) = state.canRenderInLayer(layer) || layer == targetCutoutLayer

-val targetCutoutLayer: BlockRenderLayer get() = if (Minecraft.getMinecraft().gameSettings.mipmapLevels > 0) CUTOUT_MIPPED else CUTOUT
-val otherCutoutLayer: BlockRenderLayer get() = if (Minecraft.getMinecraft().gameSettings.mipmapLevels > 0) CUTOUT else CUTOUT_MIPPED
+fun canRenderInLayerOverrideOptifine(state: BlockState, optifineReflector: Any?, layerArray: Array<Any>) =
+    canRenderInLayerOverride(state, layerArray[0] as BlockRenderLayer)
+
+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
--- a/src/main/kotlin/mods/betterfoliage/client/chunk/Overlay.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/chunk/Overlay.kt
@@ -1,56 +1,66 @@
 package mods.betterfoliage.client.chunk

+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.Client
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.multiplayer.WorldClient
-import net.minecraft.entity.Entity
-import net.minecraft.entity.player.EntityPlayer
-import net.minecraft.util.SoundCategory
-import net.minecraft.util.SoundEvent
+import mods.betterfoliage.loader.Refs
+import net.minecraft.block.BlockState
+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.IBlockAccess
-import net.minecraft.world.IWorldEventListener
-import net.minecraft.world.World
-import net.minecraft.world.chunk.EmptyChunk
+import net.minecraft.world.IBlockReader
+import net.minecraft.world.IEnviromentBlockReader
+import net.minecraft.world.IWorldReader
+import net.minecraft.world.dimension.DimensionType
 import net.minecraftforge.common.MinecraftForge
 import net.minecraftforge.event.world.ChunkEvent
 import net.minecraftforge.event.world.WorldEvent
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+import net.minecraftforge.eventbus.api.SubscribeEvent
 import org.apache.logging.log4j.Level
+import java.util.*
+
+val IEnviromentBlockReader.dimType: DimensionType get() = when {
+    this is IWorldReader -> dimension.type
+    this is ChunkRenderCache -> world.dimension.type
+    Refs.OptifineChunkCache.isInstance(this) -> (Refs.CCOFChunkCache.get(this) as ChunkRenderCache).world.dimension.type
+    else -> throw IllegalArgumentException("DimensionType of world with class ${this::class.qualifiedName} cannot be determined!")
+}

 /**
 * Represents some form of arbitrary non-persistent data that can be calculated and cached for each block position
 */
 interface ChunkOverlayLayer<T> {
-    abstract fun calculate(world: IBlockAccess, pos: BlockPos): T
-    abstract fun onBlockUpdate(world: IBlockAccess, pos: BlockPos)
+    abstract fun calculate(reader: IEnviromentBlockReader, pos: BlockPos): T
+    abstract fun onBlockUpdate(reader: IEnviromentBlockReader, pos: BlockPos)
 }

 /**
 * Query, lazy calculation and lifecycle management of multiple layers of chunk overlay data.
 */
-object ChunkOverlayManager : IBlockUpdateListener {
+object ChunkOverlayManager {
+
+    var tempCounter = 0
+
    init {
        Client.log(Level.INFO, "Initializing client overlay manager")
        MinecraftForge.EVENT_BUS.register(this)
    }

-    val chunkData = mutableMapOf<ChunkPos, ChunkOverlayData>()
+    val chunkData = IdentityHashMap<DimensionType, MutableMap<ChunkPos, ChunkOverlayData>>()
    val layers = mutableListOf<ChunkOverlayLayer<*>>()

    /**
     * Get the overlay data for a given layer and position
     *
     * @param layer Overlay layer to query
-     * @param world World to use if calculation of overlay value is necessary
+     * @param reader World to use if calculation of overlay value is necessary
     * @param pos Block position
     */
-    fun <T> get(layer: ChunkOverlayLayer<T>, world: IBlockAccess, pos: BlockPos): T? {
-        val data = chunkData[ChunkPos(pos)] ?: return null
+    fun <T> get(layer: ChunkOverlayLayer<T>, reader: IEnviromentBlockReader, pos: BlockPos): T? {
+        val data = chunkData[reader.dimType]?.get(ChunkPos(pos)) ?: return null
        data.get(layer, pos).let { value ->
            if (value !== ChunkOverlayData.UNCALCULATED) return value
-            val newValue = layer.calculate(world, pos)
+            val newValue = layer.calculate(reader, pos)
            data.set(layer, pos, newValue)
            return newValue
        }
@@ -62,32 +72,39 @@ object ChunkOverlayManager : IBlockUpdateListener {
     * @param layer Overlay layer to clear
     * @param pos Block position
     */
-    fun <T> clear(layer: ChunkOverlayLayer<T>, pos: BlockPos) {
-        chunkData[ChunkPos(pos)]?.clear(layer, pos)
+    fun <T> clear(dimension: DimensionType, layer: ChunkOverlayLayer<T>, pos: BlockPos) {
+        chunkData[dimension]?.get(ChunkPos(pos))?.clear(layer, pos)
    }

-    override fun notifyBlockUpdate(world: World, pos: BlockPos, oldState: IBlockState, newState: IBlockState, flags: Int) {
-        if (chunkData.containsKey(ChunkPos(pos))) layers.forEach { layer -> layer.onBlockUpdate(world, pos) }
-    }
-
-    @SubscribeEvent
-    fun handleLoadWorld(event: WorldEvent.Load) {
-        if (event.world is WorldClient) {
-            event.world.addEventListener(this)
+    fun onBlockChange(world: ClientWorld, pos: BlockPos) {
+        if (chunkData[world.dimType]?.containsKey(ChunkPos(pos)) == true) {
+            layers.forEach { layer -> layer.onBlockUpdate(world, pos) }
        }
    }

    @SubscribeEvent
-    fun handleLoadChunk(event: ChunkEvent.Load) {
-        if (event.world is WorldClient && event.chunk !is EmptyChunk) {
-            chunkData[event.chunk.pos] = ChunkOverlayData(layers)
+    fun handleLoadWorld(event: WorldEvent.Load) = (event.world as? ClientWorld)?.let { world ->
+        BetterFoliage.log.debug("Unloaded world: id=${world.dimType.id} name=${world.dimType.registryName}")
+        chunkData[world.dimType] = mutableMapOf()
+    }
+
+    @SubscribeEvent
+    fun handleUnloadWorld(event: WorldEvent.Unload) = (event.world as? ClientWorld)?.let { world ->
+        BetterFoliage.log.debug("Unloaded world: id=${world.dimType.id} name=${world.dimType.registryName}")
+        chunkData.remove(world.dimType)
+    }
+
+    @SubscribeEvent
+    fun handleLoadChunk(event: ChunkEvent.Load) = (event.world as? ClientWorld)?.let { world ->
+        chunkData[world.dimType]?.let { chunks ->
+            // check for existence first because Optifine fires a TON of these
+            if (event.chunk.pos !in chunks.keys) chunks[event.chunk.pos] = ChunkOverlayData(layers)
        }
    }
+
    @SubscribeEvent
-    fun handleUnloadChunk(event: ChunkEvent.Unload) {
-        if (event.world is WorldClient) {
-            chunkData.remove(event.chunk.pos)
-        }
+    fun handleUnloadChunk(event: ChunkEvent.Unload) = (event.world as? ClientWorld)?.let { world ->
+        chunkData[world.dimType]?.remove(event.chunk.pos)
    }
 }

@@ -107,6 +124,7 @@ class ChunkOverlayData(layers: List<ChunkOverlayLayer<*>>) {
 * IWorldEventListener helper subclass
 * No-op for everything except notifyBlockUpdate()
 */
+/*
 interface IBlockUpdateListener : IWorldEventListener {
    override fun playSoundToAllNearExcept(player: EntityPlayer?, soundIn: SoundEvent, category: SoundCategory, x: Double, y: Double, z: Double, volume: Float, pitch: Float) {}
    override fun onEntityAdded(entityIn: Entity) {}
@@ -119,4 +137,8 @@ interface IBlockUpdateListener : IWorldEventListener {
    override fun playRecord(soundIn: SoundEvent, pos: BlockPos) {}
    override fun sendBlockBreakProgress(breakerId: Int, pos: BlockPos, progress: Int) {}
    override fun markBlockRangeForRenderUpdate(x1: Int, y1: Int, z1: Int, x2: Int, y2: Int, z2: Int) {}
-}
+    override fun addParticle(p0: IParticleData, p1: Boolean, p2: Double, p3: Double, p4: Double, p5: Double, p6: Double, p7: Double) {}
+    override fun addParticle(p0: IParticleData, p1: Boolean, p2: Boolean, p3: Double, p4: Double, p5: Double, p6: Double, p7: Double, p8: Double) {}
+}
+
+ */
--- a/src/main/kotlin/mods/betterfoliage/client/config/Config.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/config/Config.kt
@@ -1,18 +1,16 @@
 package mods.betterfoliage.client.config

-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.gui.BiomeListConfigEntry
+import mods.betterfoliage.BetterFoliage
+import mods.octarinecore.client.resource.LoadModelDataEvent
 import mods.octarinecore.common.config.*
-import net.minecraft.client.Minecraft
-import net.minecraft.world.biome.Biome
-import net.minecraftforge.fml.client.event.ConfigChangedEvent
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.lwjgl.opengl.GL11
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.common.MinecraftForge
+import net.minecraftforge.eventbus.api.SubscribeEvent

 // BetterFoliage-specific property delegates
-private val OBSOLETE = ObsoleteConfigProperty()
+//private val OBSOLETE = ObsoleteConfigProperty()
 private fun featureEnable() = boolean(true).lang("enabled")
+/*
 fun biomeList(defaults: (Biome) -> Boolean) = intList {
    Biome.REGISTRY
        .filter { it != null && defaults(it) }
@@ -24,14 +22,15 @@ fun biomeList(defaults: (Biome) -> Boolean) = intList {
 private fun Biome.filterTemp(min: Float?, max: Float?) = (min == null || min <= defaultTemperature) && (max == null || max >= defaultTemperature)
 private fun Biome.filterRain(min: Float?, max: Float?) = (min == null || min <= rainfall) && (max == null || max >= rainfall)
 private fun Biome.filterClass(vararg name: String) = name.any { it in this.javaClass.name.toLowerCase() }
+*/

 // Config singleton
-@SideOnly(Side.CLIENT)
-object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAIN) {
+object Config : DelegatingConfig(BetterFoliage.MOD_ID, BetterFoliage.MOD_ID) {

-    var enabled by boolean(true)
-    var nVidia by boolean(GL11.glGetString(GL11.GL_VENDOR).toLowerCase().contains("nvidia"))
+    val enabled by boolean(true)
+    val nVidia by boolean(false)

+    /*
    object blocks {
        val leavesClasses = ConfigurableBlockMatcher(BetterFoliageMod.DOMAIN, "leaves_blocks_default.cfg")
        val leavesModels = ModelTextureListConfigOption(BetterFoliageMod.DOMAIN, "leaves_models_default.cfg", 1)
@@ -54,8 +53,9 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAI
        val logsWhitelist = OBSOLETE
        val logsBlacklist = OBSOLETE
    }
+*/

-    object leaves {
+    object leaves : ConfigCategory() {
        val enabled by featureEnable()
        val snowEnabled by boolean(true)
        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
@@ -65,7 +65,7 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAI
        val hideInternal by boolean(true)
    }

-    object shortGrass {
+    object shortGrass : ConfigCategory(){
        val grassEnabled by boolean(true)
        val myceliumEnabled by boolean(true)
        val snowEnabled by boolean(true)
@@ -79,23 +79,16 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAI
        val saturationThreshold by double(default=0.1)
    }

-//    object hangingGrass {
-//        var enabled by featureEnable()
-//        var distance by distanceLimit()
-//        var size by double(min=0.25, max=1.5, default=0.75).lang("size")
-//        var separation by double(max=0.5, default=0.25)
-//    }
-
-    object connectedGrass {
+    object connectedGrass : ConfigCategory(){
        val enabled by boolean(true)
        val snowEnabled by boolean(false)
    }

-    object roundLogs {
+    object roundLogs : ConfigCategory(){
        val enabled by featureEnable()
        val radiusSmall by double(max=0.5, default=0.25)
        val radiusLarge by double(max=0.5, default=0.44)
-        val dimming by float(default = 0.7)
+        val dimming by double(default = 0.7)
        val connectSolids by boolean(false)
        val lenientConnect by boolean(true)
        val connectPerpendicular by boolean(true)
@@ -104,41 +97,43 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAI
        val zProtection by double(min = 0.9, default = 0.99)
    }

-    object cactus {
+    object cactus : ConfigCategory(){
        val enabled by featureEnable()
        val size by double(min=0.5, max=1.5, default=0.8).lang("size")
        val sizeVariation by double(max=0.5, default=0.1)
        val hOffset by double(max=0.5, default=0.1).lang("hOffset")
    }

-    object lilypad {
+    object lilypad : ConfigCategory(){
        val enabled by featureEnable()
        val hOffset by double(max=0.25, default=0.1).lang("hOffset")
        val flowerChance by int(max=64, default=16, min=0)
    }

-    object reed {
+    object reed : ConfigCategory(){
        val enabled by featureEnable()
        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
        val heightMin by double(min=1.5, max=3.5, default=1.7).lang("heightMin")
        val heightMax by double(min=1.5, max=3.5, default=2.2).lang("heightMax")
        val population by int(max=64, default=32).lang("population")
-        val biomes by biomeList { it.filterTemp(0.4f, null) && it.filterRain(0.4f, null) }
+        val minBiomeTemp by double(default=0.4)
+        val minBiomeRainfall by double(default=0.4)
+//        val biomes by biomeList { it.filterTemp(0.4f, null) && it.filterRain(0.4f, null) }
        val shaderWind by boolean(true).lang("shaderWind")
    }

-    object algae {
+    object algae : ConfigCategory(){
        val enabled by featureEnable()
        val hOffset by double(max=0.25, default=0.1).lang("hOffset")
        val size by double(min=0.5, max=1.5, default=1.0).lang("size")
        val heightMin by double(min=0.1, max=1.5, default=0.5).lang("heightMin")
        val heightMax by double(min=0.1, max=1.5, default=1.0).lang("heightMax")
        val population by int(max=64, default=48).lang("population")
-        val biomes by biomeList { it.filterClass("river", "ocean") }
+//        val biomes by biomeList { it.filterClass("river", "ocean") }
        val shaderWind by boolean(true).lang("shaderWind")
    }

-    object coral {
+    object coral : ConfigCategory(){
        val enabled by featureEnable()
        val shallowWater by boolean(false)
        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
@@ -147,10 +142,10 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAI
        val crustSize by double(min=0.5, max=1.5, default=1.4)
        val chance by int(max=64, default=32)
        val population by int(max=64, default=48).lang("population")
-        val biomes by biomeList { it.filterClass("river", "ocean", "beach") }
+//        val biomes by biomeList { it.filterClass("river", "ocean", "beach") }
    }

-    object netherrack {
+    object netherrack : ConfigCategory(){
        val enabled by featureEnable()
        val hOffset by double(max=0.4, default=0.2).lang("hOffset")
        val heightMin by double(min=0.1, max=1.5, default=0.6).lang("heightMin")
@@ -158,7 +153,7 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAI
        val size by double(min=0.5, max=1.5, default=1.0).lang("size")
    }

-    object fallingLeaves {
+    object fallingLeaves : ConfigCategory(){
        val enabled by featureEnable()
        val speed by double(min=0.01, max=0.15, default=0.05)
        val windStrength by double(min=0.1, max=2.0, default=0.5)
@@ -170,20 +165,20 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAI
        val opacityHack by boolean(true)
    }

-    object risingSoul {
+    object risingSoul : ConfigCategory(){
        val enabled by featureEnable()
        val chance by double(min=0.001, max=1.0, default=0.02)
        val perturb by double(min=0.01, max=0.25, default=0.05)
        val headSize by double(min=0.25, max=1.5, default=1.0)
        val trailSize by double(min=0.25, max=1.5, default=0.75)
-        val opacity by float(min=0.05, max=1.0, default=0.5)
+        val opacity by double(min=0.05, max=1.0, default=0.5)
        val sizeDecay by double(min=0.5, max=1.0, default=0.97)
-        val opacityDecay by float(min=0.5, max=1.0, default=0.97)
+        val opacityDecay by double(min=0.5, max=1.0, default=0.97)
        val lifetime by double(min=1.0, max=15.0, default=4.0)
        val trailLength by int(min=2, max=128, default=48)
        val trailDensity by int(min=1, max=16, default=3)
    }
-
+/*
    val forceReloadOptions = listOf(
        blocks.leavesClasses,
        blocks.leavesModels,
@@ -194,8 +189,39 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAI

    override fun onChange(event: ConfigChangedEvent.PostConfigChangedEvent) {
        if (hasChanged(forceReloadOptions))
-            Minecraft.getMinecraft().refreshResources()
+            Minecraft.getInstance().refreshResources()
        else
-            Minecraft.getMinecraft().renderGlobal.loadRenderers()
+            Minecraft.getInstance().renderGlobal.loadRenderers()
    }
+*/
 }
+
+object BlockConfig {
+    private val list = mutableListOf<Any>()
+
+    val leafBlocks = blocks("leaves_blocks_default.cfg")
+    val leafModels = models("leaves_models_default.cfg")
+    val grassBlocks = blocks("grass_blocks_default.cfg")
+    val grassModels = models("grass_models_default.cfg")
+    val mycelium = blocks("mycelium_blocks_default.cfg")
+//    val dirt = blocks("dirt_default.cfg")
+    val crops = blocks("crop_default.cfg")
+    val logBlocks = blocks("log_blocks_default.cfg")
+    val logModels = models("log_models_default.cfg")
+    val sand = blocks("sand_default.cfg")
+    val lilypad = blocks("lilypad_default.cfg")
+    val cactus = blocks("cactus_default.cfg")
+    val netherrack = blocks("netherrack_blocks_default.cfg")
+
+    init { BetterFoliage.modBus.register(this) }
+    private fun blocks(cfgName: String) = ConfigurableBlockMatcher(BetterFoliage.logDetail, ResourceLocation(BetterFoliage.MOD_ID, cfgName)).apply { list.add(this) }
+    private fun models(cfgName: String) = ModelTextureListConfiguration(BetterFoliage.logDetail, ResourceLocation(BetterFoliage.MOD_ID, cfgName)).apply { list.add(this) }
+
+    @SubscribeEvent
+    fun handleLoadModelData(event: LoadModelDataEvent) {
+        list.forEach { when(it) {
+            is ConfigurableBlockMatcher -> it.readDefaults()
+            is ModelTextureListConfiguration -> it.readDefaults()
+        } }
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/client/gui/BiomeListConfigEntry.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/gui/BiomeListConfigEntry.kt
@@ -1,19 +0,0 @@
-package mods.betterfoliage.client.gui
-
-import mods.octarinecore.client.gui.IdListConfigEntry
-import net.minecraft.world.biome.Biome
-import net.minecraftforge.fml.client.config.GuiConfig
-import net.minecraftforge.fml.client.config.GuiConfigEntries
-import net.minecraftforge.fml.client.config.IConfigElement
-
-/** Toggleable list of all defined biomes. */
-class BiomeListConfigEntry(
-    owningScreen: GuiConfig,
-    owningEntryList: GuiConfigEntries,
-    configElement: IConfigElement)
-: IdListConfigEntry<Biome>(owningScreen, owningEntryList, configElement) {
-
-    override val baseSet: List<Biome> get() = Biome.REGISTRY.filterNotNull()
-    override val Biome.itemId: Int get() = Biome.REGISTRY.getIDForObject(this)
-    override val Biome.itemName: String get() = this.biomeName
-}
--- a/src/main/kotlin/mods/betterfoliage/client/gui/ConfigGuiFactory.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/gui/ConfigGuiFactory.kt
@@ -1,29 +0,0 @@
-package mods.betterfoliage.client.gui
-
-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.config.Config
-import net.minecraft.client.Minecraft
-import net.minecraft.client.gui.GuiScreen
-import net.minecraftforge.fml.client.IModGuiFactory
-import net.minecraftforge.fml.client.config.GuiConfig
-
-class ConfigGuiFactory : IModGuiFactory {
-
-    override fun initialize(minecraftInstance: Minecraft?) { }
-    override fun hasConfigGui() = true
-    override fun runtimeGuiCategories() = hashSetOf<IModGuiFactory.RuntimeOptionCategoryElement>()
-    override fun createConfigGui(parentScreen: GuiScreen?) = createBFConfigGui(parentScreen)
-
-    companion object {
-        @JvmStatic
-        fun createBFConfigGui(parentScreen: GuiScreen?) = GuiConfig(
-            parentScreen,
-            Config.rootGuiElements,
-            BetterFoliageMod.MOD_ID,
-            null,
-            false,
-            false,
-            BetterFoliageMod.MOD_NAME
-        )
-    }
-}
--- a/src/main/kotlin/mods/betterfoliage/client/integration/ForestryIntegration.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/ForestryIntegration.kt
@@ -1,8 +1,8 @@
 package mods.betterfoliage.client.integration

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
+import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.render.LogRegistry
 import mods.betterfoliage.client.render.StandardLogRegistry
 import mods.betterfoliage.client.render.column.ColumnTextureInfo
@@ -19,19 +19,19 @@ import mods.octarinecore.metaprog.ClassRef
 import mods.octarinecore.metaprog.FieldRef
 import mods.octarinecore.metaprog.MethodRef
 import mods.octarinecore.metaprog.allAvailable
-import net.minecraft.block.state.IBlockState
+import net.minecraft.block.BlockState
 import net.minecraft.client.Minecraft
-import net.minecraft.client.renderer.block.model.ModelResourceLocation
+import net.minecraft.client.renderer.model.IUnbakedModel
+import net.minecraft.client.renderer.model.ModelResourceLocation
 import net.minecraft.util.ResourceLocation
 import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
+import net.minecraft.world.IBlockReader
+import net.minecraft.world.IWorldReader
 import net.minecraftforge.client.event.TextureStitchEvent
 import net.minecraftforge.client.model.IModel
-import net.minecraftforge.fml.common.Loader
-import net.minecraftforge.fml.common.eventhandler.EventPriority
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraftforge.eventbus.api.EventPriority
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import net.minecraftforge.fml.ModList
 import org.apache.logging.log4j.Level
 import kotlin.collections.Map
 import kotlin.collections.component1
@@ -45,7 +45,6 @@ import kotlin.collections.mapValues
 import kotlin.collections.mutableMapOf
 import kotlin.collections.set

-@SideOnly(Side.CLIENT)
 object ForestryIntegration {

    val TextureLeaves = ClassRef("forestry.arboriculture.models.TextureLeaves")
@@ -71,7 +70,7 @@ object ForestryIntegration {
    val getSprite = MethodRef(ILeafSpriteProvider, "getSprite", Refs.ResourceLocation, ClassRef.boolean, ClassRef.boolean)

    init {
-        if (Loader.isModLoaded("forestry") && allAvailable(TiLgetLeaveSprite, getLeafSpriteProvider, getSprite)) {
+        if (ModList.get().isLoaded("forestry") && allAvailable(TiLgetLeaveSprite, getLeafSpriteProvider, getSprite)) {
            Client.log(Level.INFO, "Forestry support initialized")
            LeafRegistry.addRegistry(ForestryLeafRegistry)
            LogRegistry.addRegistry(ForestryLogRegistry)
@@ -80,13 +79,13 @@ object ForestryIntegration {
 }

 object ForestryLeafRegistry : ModelRenderRegistry<LeafInfo> {
-    val logger = BetterFoliageMod.logDetail
+    val logger = BetterFoliage.logDetail
    val textureToKey = mutableMapOf<ResourceLocation, ModelRenderKey<LeafInfo>>()
    var textureToValue = emptyMap<ResourceLocation, LeafInfo>()

-    override fun get(state: IBlockState, world: IBlockAccess, pos: BlockPos): LeafInfo? {
+    override fun get(state: BlockState, world: IBlockReader, pos: BlockPos): LeafInfo? {
        // check variant property (used in decorative leaves)
-        state.properties.entries.find {
+        state.values.entries.find {
            ForestryIntegration.PropertyTreeType.isInstance(it.key) && ForestryIntegration.TreeDefinition.isInstance(it.value)
        } ?.let {
            val species = ForestryIntegration.TdSpecies.get(it.value)
@@ -96,7 +95,7 @@ object ForestryLeafRegistry : ModelRenderRegistry<LeafInfo> {
        }

        // extract leaf texture information from TileEntity
-        val tile = world.getTileEntitySafe(pos) ?: return null
+        val tile = world.getTileEntity(pos) ?: return null
        if (!ForestryIntegration.TileLeaves.isInstance(tile)) return null
        val textureLoc = ForestryIntegration.TiLgetLeaveSprite.invoke(tile, Minecraft.isFancyGraphicsEnabled()) ?: return null
        return textureToValue[textureLoc]
@@ -115,7 +114,7 @@ object ForestryLeafRegistry : ModelRenderRegistry<LeafInfo> {
                ForestryIntegration.TeLpollplain.get(it.value) as ResourceLocation,
                ForestryIntegration.TeLpollfancy.get(it.value) as ResourceLocation
            ).forEach { textureLocation ->
-                val key = StandardLeafKey(logger, textureLocation.toString()).apply { onPreStitch(event.map) }
+                val key = StandardLeafKey(logger, textureLocation.toString()).apply { onPreStitch(event) }
                textureToKey[textureLocation] = key
            }
        }
@@ -129,14 +128,14 @@ object ForestryLeafRegistry : ModelRenderRegistry<LeafInfo> {
 }

 object ForestryLogRegistry : ModelRenderRegistryBase<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
+    override val logger = BetterFoliage.logDetail

-    override fun processModel(state: IBlockState, modelLoc: ModelResourceLocation, model: IModel): ModelRenderKey<ColumnTextureInfo>? {
+    override fun processModel(state: BlockState, modelLoc: ModelResourceLocation, models: List<Pair<IUnbakedModel, ResourceLocation>>): ModelRenderKey<ColumnTextureInfo>? {
        // respect class list to avoid triggering on fences, stairs, etc.
-        if (!Config.blocks.logClasses.matchesClass(state.block)) return null
+        if (!BlockConfig.logBlocks.matchesClass(state.block)) return null

        // find wood type property
-        val woodType = state.properties.entries.find {
+        val woodType = state.values.entries.find {
            ForestryIntegration.PropertyWoodType.isInstance(it.key) && ForestryIntegration.IWoodType.isInstance(it.value)
        } ?: return null

--- a/src/main/kotlin/mods/betterfoliage/client/integration/OptifineCustomColors.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/OptifineCustomColors.kt
@@ -7,22 +7,19 @@ import mods.octarinecore.client.render.BlockContext
 import mods.octarinecore.common.Int3
 import mods.octarinecore.metaprog.allAvailable
 import mods.octarinecore.metaprog.reflectField
-import net.minecraft.block.state.IBlockState
+import net.minecraft.block.BlockState
 import net.minecraft.client.Minecraft
-import net.minecraft.client.renderer.block.model.BakedQuad
+import net.minecraft.client.renderer.model.BakedQuad
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats
-import net.minecraft.util.EnumFacing
+import net.minecraft.util.Direction.UP
 import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraft.world.IBlockReader
 import org.apache.logging.log4j.Level

 /**
 * Integration for OptiFine custom block colors.
 */
@Suppress("UNCHECKED_CAST")
-@SideOnly(Side.CLIENT)
 object OptifineCustomColors {

    val isColorAvailable = allAvailable(
@@ -34,27 +31,26 @@ object OptifineCustomColors {
    }

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

    fun getBlockColor(ctx: BlockContext): Int {
-        val ofColor = if (isColorAvailable && Minecraft.getMinecraft().gameSettings.reflectField<Boolean>("ofCustomColors") == true) {
-            renderEnv.reset(ctx.world!!, ctx.blockState(Int3.zero), ctx.pos)
-            Refs.getColorMultiplier.invokeStatic(fakeQuad, ctx.blockState(Int3.zero), ctx.world!!, ctx.pos, renderEnv.wrapped) as? Int
+        val ofColor = if (isColorAvailable && Minecraft.getInstance().gameSettings.reflectField<Boolean>("ofCustomColors") == true) {
+            renderEnv.reset(ctx.reader!!, ctx.blockState(Int3.zero), ctx.pos)
+            Refs.getColorMultiplier.invokeStatic(fakeQuad, ctx.blockState(Int3.zero), ctx.reader!!, ctx.pos, renderEnv.wrapped) as? Int
        } else null
        return if (ofColor == null || ofColor == -1) ctx.blockData(Int3.zero).color else ofColor
    }
 }

-@SideOnly(Side.CLIENT)
 class OptifineRenderEnv {
    val wrapped: Any = Refs.RenderEnv.element!!.getDeclaredConstructor(
-        Refs.IBlockAccess.element, Refs.IBlockState.element, Refs.BlockPos.element
+        Refs.IBlockReader.element, Refs.BlockState.element, Refs.BlockPos.element
    ).let {
        it.isAccessible = true
        it.newInstance(null, null, null)
    }

-    fun reset(blockAccess: IBlockAccess, state: IBlockState, pos: BlockPos) {
+    fun reset(blockAccess: IBlockReader, state: BlockState, pos: BlockPos) {
        Refs.RenderEnv_reset.invoke(wrapped, blockAccess, state, pos)
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/client/integration/RubberIntegration.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/RubberIntegration.kt
@@ -1,6 +1,6 @@
 package mods.betterfoliage.client.integration

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.render.LogRegistry
 import mods.betterfoliage.client.render.column.ColumnTextureInfo
@@ -13,39 +13,39 @@ import mods.octarinecore.client.resource.*
 import mods.octarinecore.common.rotate
 import mods.octarinecore.metaprog.ClassRef
 import mods.octarinecore.metaprog.allAvailable
-import net.minecraft.block.state.IBlockState
-import net.minecraft.client.renderer.block.model.ModelResourceLocation
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.client.renderer.model.IUnbakedModel
+import net.minecraft.client.renderer.model.ModelResourceLocation
+import net.minecraft.client.renderer.texture.AtlasTexture
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.client.renderer.texture.TextureMap
-import net.minecraft.util.EnumFacing
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.*
 import net.minecraft.util.ResourceLocation
 import net.minecraftforge.client.model.IModel
-import net.minecraftforge.fml.common.Loader
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraftforge.fml.ModList
 import org.apache.logging.log4j.Level
+import org.apache.logging.log4j.Level.DEBUG
 import org.apache.logging.log4j.Logger

-@SideOnly(Side.CLIENT)
 object IC2RubberIntegration {

    val BlockRubWood = ClassRef("ic2.core.block.BlockRubWood")

    init {
-        if (Loader.isModLoaded("ic2") && allAvailable(BlockRubWood)) {
+        if (ModList.get().isLoaded("ic2") && allAvailable(BlockRubWood)) {
            Client.log(Level.INFO, "IC2 rubber support initialized")
            LogRegistry.addRegistry(IC2LogSupport)
        }
    }
 }

-@SideOnly(Side.CLIENT)
 object TechRebornRubberIntegration {

    val BlockRubberLog = ClassRef("techreborn.blocks.BlockRubberLog")

    init {
-        if (Loader.isModLoaded("techreborn") && allAvailable(BlockRubberLog)) {
+        if (ModList.get().isLoaded("techreborn") && allAvailable(BlockRubberLog)) {
            Client.log(Level.INFO, "TechReborn rubber support initialized")
            LogRegistry.addRegistry(TechRebornLogSupport)
        }
@@ -53,8 +53,8 @@ object TechRebornRubberIntegration {
 }

 class RubberLogInfo(
-    axis: EnumFacing.Axis?,
-    val spotDir: EnumFacing,
+    axis: Axis?,
+    val spotDir: Direction,
    topTexture: TextureAtlasSprite,
    bottomTexture: TextureAtlasSprite,
    val spotTexture: TextureAtlasSprite,
@@ -62,85 +62,85 @@ class RubberLogInfo(
 ) : SimpleColumnInfo(axis, topTexture, bottomTexture, sideTextures) {

    override val side: QuadIconResolver = { ctx: ShadingContext, idx: Int, quad: Quad ->
-        val worldFace = (if ((idx and 1) == 0) EnumFacing.SOUTH else EnumFacing.EAST).rotate(ctx.rotation)
+        val worldFace = (if ((idx and 1) == 0) SOUTH else EAST).rotate(ctx.rotation)
        if (worldFace == spotDir) spotTexture else {
            val sideIdx = if (this.sideTextures.size > 1) (blockContext.random(1) + dirToIdx[worldFace.ordinal]) % this.sideTextures.size else 0
            this.sideTextures[sideIdx]
        }
    }

-    class Key(override val logger: Logger, val axis: EnumFacing.Axis?, val spotDir: EnumFacing, val textures: List<String>): ModelRenderKey<ColumnTextureInfo> {
-        override fun resolveSprites(atlas: TextureMap) = RubberLogInfo(
+    class Key(override val logger: Logger, val axis: Axis?, val spotDir: Direction, val textures: List<String>): ModelRenderKey<ColumnTextureInfo> {
+        override fun resolveSprites(atlas: AtlasTexture) = RubberLogInfo(
            axis,
            spotDir,
-            atlas[textures[0]] ?: atlas.missingSprite,
-            atlas[textures[1]] ?: atlas.missingSprite,
-            atlas[textures[2]] ?: atlas.missingSprite,
-            textures.drop(3).map { atlas[it] ?: atlas.missingSprite }
+            atlas[textures[0]] ?: missingSprite,
+            atlas[textures[1]] ?: missingSprite,
+            atlas[textures[2]] ?: missingSprite,
+            textures.drop(3).map { atlas[it] ?: missingSprite }
        )
    }
 }

 object IC2LogSupport : ModelRenderRegistryBase<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
+    override val logger = BetterFoliage.logDetail

-    override fun processModel(state: IBlockState, modelLoc: ModelResourceLocation, model: IModel): ModelRenderKey<ColumnTextureInfo>? {
+    override fun processModel(state: BlockState, modelLoc: ModelResourceLocation, models: List<Pair<IUnbakedModel, ResourceLocation>>): ModelRenderKey<ColumnTextureInfo>? {
        // check for proper block class, existence of ModelBlock, and "state" blockstate property
        if (!IC2RubberIntegration.BlockRubWood.isInstance(state.block)) return null
-        val blockLoc = model.modelBlockAndLoc.firstOrNull() ?: return null
-        val type = state.properties.entries.find { it.key.getName() == "state" }?.value?.toString() ?: return null
+        val blockLoc = models.firstOrNull() as Pair<BlockModel, ResourceLocation> ?: return null
+        val type = state.values.entries.find { it.key.getName() == "state" }?.value?.toString() ?: return null

        // logs with no rubber spot
        if (blockLoc.derivesFrom(ResourceLocation("block/cube_column"))) {
            val axis = when(type) {
-                "plain_y" -> EnumFacing.Axis.Y
-                "plain_x" -> EnumFacing.Axis.X
-                "plain_z" -> EnumFacing.Axis.Z
+                "plain_y" -> Axis.Y
+                "plain_x" -> Axis.X
+                "plain_z" -> Axis.Z
                else -> null
            }
            val textureNames = listOf("end", "end", "side").map { blockLoc.first.resolveTextureName(it) }
            if (textureNames.any { it == "missingno" }) return null
-            logger.log(Level.DEBUG, "IC2LogSupport: block state ${state.toString()}")
-            logger.log(Level.DEBUG, "IC2LogSupport:             axis=$axis, end=${textureNames[0]}, side=${textureNames[2]}")
+            logger.log(DEBUG, "IC2LogSupport: block state ${state.toString()}")
+            logger.log(DEBUG, "IC2LogSupport:             axis=$axis, end=${textureNames[0]}, side=${textureNames[2]}")
            return SimpleColumnInfo.Key(logger, axis, textureNames)
        }

        // logs with rubber spot
        val spotDir = when(type) {
-            "dry_north", "wet_north" -> EnumFacing.NORTH
-            "dry_south", "wet_south" -> EnumFacing.SOUTH
-            "dry_west", "wet_west" -> EnumFacing.WEST
-            "dry_east", "wet_east" -> EnumFacing.EAST
+            "dry_north", "wet_north" -> NORTH
+            "dry_south", "wet_south" -> SOUTH
+            "dry_west", "wet_west" -> WEST
+            "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
-        logger.log(Level.DEBUG, "IC2LogSupport: block state ${state.toString()}")
-        logger.log(Level.DEBUG, "IC2LogSupport:             spotDir=$spotDir, up=${textureNames[0]}, down=${textureNames[1]}, side=${textureNames[2]}, spot=${textureNames[3]}")
-        return if (spotDir != null) RubberLogInfo.Key(logger, EnumFacing.Axis.Y, spotDir, textureNames) else SimpleColumnInfo.Key(logger, EnumFacing.Axis.Y, textureNames)
+        logger.log(DEBUG, "IC2LogSupport: block state ${state.toString()}")
+        logger.log(DEBUG, "IC2LogSupport:             spotDir=$spotDir, up=${textureNames[0]}, down=${textureNames[1]}, side=${textureNames[2]}, spot=${textureNames[3]}")
+        return if (spotDir != null) RubberLogInfo.Key(logger, Axis.Y, spotDir, textureNames) else SimpleColumnInfo.Key(logger, Axis.Y, textureNames)
    }
 }

 object TechRebornLogSupport : ModelRenderRegistryBase<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
+    override val logger = BetterFoliage.logDetail

-    override fun processModel(state: IBlockState, modelLoc: ModelResourceLocation, model: IModel): ModelRenderKey<ColumnTextureInfo>? {
+    override fun processModel(state: BlockState, modelLoc: ModelResourceLocation, models: List<Pair<IUnbakedModel, ResourceLocation>>): ModelRenderKey<ColumnTextureInfo>? {
        // check for proper block class, existence of ModelBlock
        if (!TechRebornRubberIntegration.BlockRubberLog.isInstance(state.block)) return null
-        val blockLoc = model.modelBlockAndLoc.firstOrNull() ?: return null
+        val blockLoc = models.firstOrNull() as Pair<BlockModel, ResourceLocation> ?: return null

-        val hasSap = state.properties.entries.find { it.key.getName() == "hassap" }?.value as? Boolean ?: return null
-        val sapSide = state.properties.entries.find { it.key.getName() == "sapside" }?.value as? EnumFacing ?: return null
+        val hasSap = state.values.entries.find { it.key.getName() == "hassap" }?.value as? Boolean ?: return null
+        val sapSide = state.values.entries.find { it.key.getName() == "sapside" }?.value as? Direction ?: return null

-        logger.log(Level.DEBUG, "$logName: block state $state")
+        logger.log(DEBUG, "$logName: block state $state")
        if (hasSap) {
            val textureNames = listOf("end", "end", "sapside", "side").map { blockLoc.first.resolveTextureName(it) }
-            logger.log(Level.DEBUG, "$logName:             spotDir=$sapSide, end=${textureNames[0]}, side=${textureNames[2]}, spot=${textureNames[3]}")
-            if (textureNames.all { it != "missingno" }) return RubberLogInfo.Key(logger, EnumFacing.Axis.Y, sapSide, textureNames)
+            logger.log(DEBUG, "$logName:             spotDir=$sapSide, end=${textureNames[0]}, side=${textureNames[2]}, spot=${textureNames[3]}")
+            if (textureNames.all { it != "missingno" }) return RubberLogInfo.Key(logger, Axis.Y, sapSide, textureNames)
        } else {
            val textureNames = listOf("end", "end", "side").map { blockLoc.first.resolveTextureName(it) }
-            logger.log(Level.DEBUG, "$logName:             end=${textureNames[0]}, side=${textureNames[2]}")
-            if (textureNames.all { it != "missingno" })return SimpleColumnInfo.Key(logger, EnumFacing.Axis.Y, textureNames)
+            logger.log(DEBUG, "$logName:             end=${textureNames[0]}, side=${textureNames[2]}")
+            if (textureNames.all { it != "missingno" })return SimpleColumnInfo.Key(logger, Axis.Y, textureNames)
        }
        return null
    }
--- a/src/main/kotlin/mods/betterfoliage/client/integration/ShadersModIntegration.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/ShadersModIntegration.kt
@@ -1,41 +1,36 @@
 package mods.betterfoliage.client.integration

 import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
+import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.loader.Refs
 import mods.octarinecore.metaprog.allAvailable
-import net.minecraft.block.Block
-import net.minecraft.block.BlockTallGrass
-import net.minecraft.block.state.IBlockState
+import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
 import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.init.Blocks
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
 import org.apache.logging.log4j.Level.INFO

 /**
 * Integration for ShadersMod.
 */
-@SideOnly(Side.CLIENT)
 object ShadersModIntegration {

    @JvmStatic var isAvailable = allAvailable(Refs.sVertexBuilder, Refs.pushEntity_state, Refs.pushEntity_num, Refs.popEntity)
-    @JvmStatic val tallGrassEntityData = entityDataFor(Blocks.TALLGRASS.defaultState.withProperty(BlockTallGrass.TYPE, BlockTallGrass.EnumType.GRASS))
-    @JvmStatic val leavesEntityData = entityDataFor(Blocks.LEAVES.defaultState)
+    @JvmStatic val tallGrassEntityData = entityDataFor(Blocks.TALL_GRASS.defaultState)
+    @JvmStatic val leavesEntityData = entityDataFor(Blocks.OAK_LEAVES.defaultState)

-    fun entityDataFor(blockState: IBlockState) =
-        (Block.REGISTRY.getIDForObject(blockState.block).toLong() and 65535) or
-        ((blockState.renderType.ordinal.toLong() and 65535) shl 16) or
-        (blockState.block.getMetaFromState(blockState).toLong() shl 32)
+    fun entityDataFor(blockState: BlockState) = 0L
+//        (ForgeRegistries.BLOCKS.getIDForObject(blockState.block).toLong() and 65535) or
+//        ((blockState.renderType.ordinal.toLong() and 65535) shl 16) or
+//        (blockState.block.getMetaFromState(blockState).toLong() shl 32)


    /**
     * Called from transformed ShadersMod code.
     * @see mods.betterfoliage.loader.BetterFoliageTransformer
     */
-    @JvmStatic fun getBlockIdOverride(original: Long, blockState: IBlockState): Long {
-        if (Config.blocks.leavesClasses.matchesClass(blockState.block)) return leavesEntityData
-        if (Config.blocks.crops.matchesClass(blockState.block)) return tallGrassEntityData
+    @JvmStatic fun getBlockIdOverride(original: Long, blockState: BlockState): Long {
+        if (BlockConfig.leafBlocks.matchesClass(blockState.block)) return leavesEntityData
+        if (BlockConfig.crops.matchesClass(blockState.block)) return tallGrassEntityData
        return original
    }

@@ -56,7 +51,7 @@ object ShadersModIntegration {
    }

    /** Quads rendered inside this block will use the given block entity data in shader programs. */
-    inline fun renderAs(state: IBlockState, renderer: BufferBuilder, enabled: Boolean = true, func: ()->Unit) =
+    inline fun renderAs(state: BlockState, renderer: BufferBuilder, enabled: Boolean = true, func: ()->Unit) =
        renderAs(entityDataFor(state), renderer, enabled, func)

    /** Quads rendered inside this block will behave as tallgrass blocks in shader programs. */
--- a/src/main/kotlin/mods/betterfoliage/client/render/EntityFallingLeavesFX.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/EntityFallingLeavesFX.kt
@@ -15,18 +15,22 @@ import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.MathHelper
 import net.minecraft.world.World
 import net.minecraftforge.common.MinecraftForge
+import net.minecraftforge.event.TickEvent
 import net.minecraftforge.event.world.WorldEvent
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
-import net.minecraftforge.fml.common.gameevent.TickEvent
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraftforge.eventbus.api.SubscribeEvent
 import org.lwjgl.opengl.GL11
-import java.lang.Math.*
 import java.util.*
+import kotlin.math.abs
+import kotlin.math.cos
+import kotlin.math.sin

-@SideOnly(Side.CLIENT)
-class EntityFallingLeavesFX(world: World, pos: BlockPos) :
-AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble(), pos.z.toDouble() + 0.5) {
+const val rotationFactor = PI2.toFloat() / 64.0f
+
+class EntityFallingLeavesFX(
+    world: World, pos: BlockPos
+) : AbstractEntityFX(
+    world, pos.x.toDouble() + 0.5, pos.y.toDouble(), pos.z.toDouble() + 0.5
+) {

    companion object {
        @JvmStatic val biomeBrightnessMultiplier = 0.5f
@@ -38,38 +42,40 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble(), pos.z.toDouble
    var wasCollided = false

    init {
-        particleMaxAge = MathHelper.floor(random(0.6, 1.0) * Config.fallingLeaves.lifetime * 20.0)
+        maxAge = MathHelper.floor(random(0.6, 1.0) * Config.fallingLeaves.lifetime * 20.0)
        motionY = -Config.fallingLeaves.speed
+
        particleScale = Config.fallingLeaves.size.toFloat() * 0.1f

        val state = world.getBlockState(pos)
-        val blockColor = Minecraft.getMinecraft().blockColors.colorMultiplier(state, world, pos, 0)
        val leafInfo = LeafRegistry[state, world, pos]
+        val blockColor = Minecraft.getInstance().blockColors.getColor(state, world, pos, 0)
        if (leafInfo != null) {
-            particleTexture = leafInfo.particleTextures[rand.nextInt(1024)]
+            sprite = leafInfo.particleTextures[rand.nextInt(1024)]
            calculateParticleColor(leafInfo.averageColor, blockColor)
        } else {
-            particleTexture = LeafParticleRegistry["default"][rand.nextInt(1024)]
+            sprite = LeafParticleRegistry["default"][rand.nextInt(1024)]
            setColor(blockColor)
        }
    }

-    override val isValid: Boolean get() = (particleTexture != null)
+    override val isValid: Boolean get() = (sprite != null)

    override fun update() {
        if (rand.nextFloat() > 0.95f) rotPositive = !rotPositive
-        if (particleAge > particleMaxAge - 20) particleAlpha = 0.05f * (particleMaxAge - particleAge)
+        if (age > maxAge - 20) particleAlpha = 0.05f * (maxAge - age)

        if (onGround || wasCollided) {
            velocity.setTo(0.0, 0.0, 0.0)
            if (!wasCollided) {
-                particleAge = Math.max(particleAge, particleMaxAge - 20)
+                age = Math.max(age, maxAge - 20)
                wasCollided = true
            }
        } else {
            velocity.setTo(cos[particleRot], 0.0, sin[particleRot]).mul(Config.fallingLeaves.perturb)
                    .add(LeafWindTracker.current).add(0.0, -1.0, 0.0).mul(Config.fallingLeaves.speed)
            particleRot = (particleRot + (if (rotPositive) 1 else -1)) and 63
+            particleAngle = rotationFactor * particleRot.toFloat()
        }
    }

@@ -96,7 +102,6 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble(), pos.z.toDouble
    }
 }

-@SideOnly(Side.CLIENT)
 object LeafWindTracker {
    var random = Random()
    val target = Double3.zero
@@ -108,7 +113,7 @@ object LeafWindTracker {
    }

    fun changeWind(world: World) {
-        nextChange = world.worldInfo.worldTime + 120 + random.nextInt(80)
+        nextChange = world.worldInfo.gameTime + 120 + random.nextInt(80)
        val direction = PI2 * random.nextDouble()
        val speed = abs(random.nextGaussian()) * Config.fallingLeaves.windStrength +
            (if (!world.isRaining) 0.0 else abs(random.nextGaussian()) * Config.fallingLeaves.stormStrength)
@@ -117,9 +122,9 @@ object LeafWindTracker {

    @SubscribeEvent
    fun handleWorldTick(event: TickEvent.ClientTickEvent) {
-        if (event.phase == TickEvent.Phase.START) Minecraft.getMinecraft().world?.let { world ->
+        if (event.phase == TickEvent.Phase.START) Minecraft.getInstance().world?.let { world ->
            // change target wind speed
-            if (world.worldInfo.worldTime >= nextChange) changeWind(world)
+            if (world.worldInfo.dayTime >= nextChange) changeWind(world)

            // change current wind speed
            val changeRate = if (world.isRaining) 0.015 else 0.005
@@ -132,5 +137,5 @@ object LeafWindTracker {
    }

    @SubscribeEvent
-    fun handleWorldLoad(event: WorldEvent.Load) { if (event.world.isRemote) changeWind(event.world) }
+    fun handleWorldLoad(event: WorldEvent.Load) { if (event.world.isRemote) changeWind(event.world.world) }
 }
--- a/src/main/kotlin/mods/betterfoliage/client/render/EntityRisingSoulFX.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/EntityRisingSoulFX.kt
@@ -1,22 +1,21 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.config.Config
 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 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 net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
+import org.apache.logging.log4j.Level.DEBUG
 import java.util.*

-@SideOnly(Side.CLIENT)
 class EntityRisingSoulFX(world: World, pos: BlockPos) :
 AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.toDouble() + 0.5) {

@@ -26,14 +25,14 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.to
    init {
        motionY = 0.1
        particleGravity = 0.0f
-        particleTexture = RisingSoulTextures.headIcons[rand.nextInt(256)]
-        particleMaxAge = MathHelper.floor((0.6 + 0.4 * rand.nextDouble()) * Config.risingSoul.lifetime * 20.0)
+        sprite = RisingSoulTextures.headIcons[rand.nextInt(256)]
+        maxAge = MathHelper.floor((0.6 + 0.4 * rand.nextDouble()) * Config.risingSoul.lifetime * 20.0)
    }

    override val isValid: Boolean get() = true

    override fun update() {
-        val phase = (initialPhase + particleAge) % 64
+        val phase = (initialPhase + age) % 64
        velocity.setTo(cos[phase] * Config.risingSoul.perturb, 0.1, sin[phase] * Config.risingSoul.perturb)

        particleTrail.addFirst(currentPos.copy())
@@ -43,8 +42,8 @@ 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
-        if (particleAge > particleMaxAge - 40) alpha *= (particleMaxAge - particleAge) / 40.0f
+        var alpha = Config.risingSoul.opacity.toFloat()
+        if (age > maxAge - 40) alpha *= (maxAge - age) / 40.0f

        renderParticleQuad(worldRenderer, partialTickTime,
            size = Config.risingSoul.headSize * 0.25,
@@ -54,7 +53,7 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.to
        var scale = Config.risingSoul.trailSize * 0.25
        particleTrail.forEachPairIndexed { idx, current, previous ->
            scale *= Config.risingSoul.sizeDecay
-            alpha *= Config.risingSoul.opacityDecay
+            alpha *= Config.risingSoul.opacityDecay.toFloat()
            if (idx % Config.risingSoul.trailDensity == 0) renderParticleQuad(worldRenderer, partialTickTime,
                currentPos = current,
                prevPos = previous,
@@ -66,12 +65,11 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.to
    }
 }

-@SideOnly(Side.CLIENT)
-object RisingSoulTextures : ResourceHandler(BetterFoliageMod.MOD_ID) {
-    val headIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/rising_soul_%d")
-    val trackIcon = iconStatic(BetterFoliageMod.LEGACY_DOMAIN, "blocks/soul_track")
+object RisingSoulTextures : ResourceHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus, targetAtlas = Atlas.PARTICLES) {
+    val headIcons = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "rising_soul_$idx") }
+    val trackIcon = iconStatic(BetterFoliage.MOD_ID, "soul_track")

    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${headIcons.num} soul particle textures")
+        Client.log(DEBUG, "Registered ${headIcons.num} soul particle textures")
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/client/render/ModelColumn.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/ModelColumn.kt
@@ -5,7 +5,8 @@ import mods.betterfoliage.client.config.Config
 import mods.octarinecore.client.render.*
 import mods.octarinecore.common.Double3
 import mods.octarinecore.exchange
-import net.minecraft.util.EnumFacing.*
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.*
 import org.lwjgl.opengl.GL11

 /** Weight of the same-side AO values on the outer edges of the 45deg chamfered column faces. */
@@ -25,10 +26,10 @@ fun Model.columnSide(radius: Double, yBottom: Double, yTop: Double, transform: (
        verticalRectangle(x1 = 0.5 - radius, z1 = 0.5, x2 = 0.5 - halfRadius, z2 = 0.5 - halfRadius, yBottom = yBottom, yTop = yTop)
        .clampUV(minU = 0.5 - radius)
        .setAoShader(
-            faceOrientedAuto(overrideFace = SOUTH, corner = cornerInterpolate(Axis.Y, chamferAffinity, Config.roundLogs.dimming))
+            faceOrientedAuto(overrideFace = SOUTH, corner = cornerInterpolate(Axis.Y, chamferAffinity, Config.roundLogs.dimming.toFloat()))
        )
        .setAoShader(
-            faceOrientedAuto(overrideFace = SOUTH, corner = cornerInterpolate(Axis.Y, 0.5f, Config.roundLogs.dimming)),
+            faceOrientedAuto(overrideFace = SOUTH, corner = cornerInterpolate(Axis.Y, 0.5f, Config.roundLogs.dimming.toFloat())),
            predicate = { v, vi -> vi == 1 || vi == 2}
        )
    ).forEach { transform(it.setFlatShader(FaceFlat(SOUTH))).add() }
@@ -37,9 +38,9 @@ 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)))
+            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)),
+            faceOrientedAuto(overrideFace = EAST, corner = cornerInterpolate(Axis.Y, 0.5f, Config.roundLogs.dimming.toFloat())),
            predicate = { v, vi -> vi == 0 || vi == 3}
        ),

--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderAlgae.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderAlgae.kt
@@ -1,42 +1,46 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 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.octarinecore.client.render.*
 import mods.octarinecore.common.Int3
 import mods.octarinecore.common.Rotation
+import net.minecraft.block.Block
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.tags.BlockTags
 import net.minecraft.util.BlockRenderLayer
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
+import net.minecraft.util.ResourceLocation
+import net.minecraft.world.biome.Biome
+import net.minecraftforge.client.model.data.IModelData
+import org.apache.logging.log4j.Level.DEBUG
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderAlgae : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderAlgae : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

    val noise = simplexNoise()

-    val algaeIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_algae_%d")
-    val algaeModels = modelSet(64, RenderGrass.grassTopQuads(Config.algae.heightMin, Config.algae.heightMax))
+    val algaeIcons = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_algae_$idx") }
+    val algaeModels = modelSet(64) { idx -> RenderGrass.grassTopQuads(Config.algae.heightMin, Config.algae.heightMax)(idx) }

    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${algaeIcons.num} algae textures")
+        Client.log(DEBUG, "Registered ${algaeIcons.num} algae textures")
    }

    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.algae.enabled &&
        ctx.blockState(up2).material == Material.WATER &&
        ctx.blockState(up1).material == Material.WATER &&
-        Config.blocks.dirt.matchesClass(ctx.block) &&
-        ctx.biomeId in Config.algae.biomes &&
+        BlockTags.DIRT_LIKE.contains(ctx.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: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
+        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, layer)
        if (!layer.isCutout) return baseRender

        modelRenderer.updateShading(Int3.zero, allFaces)
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderCactus.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderCactus.kt
@@ -1,7 +1,8 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.Client
+import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.config.Config
 import mods.betterfoliage.client.render.column.ColumnTextureInfo
 import mods.betterfoliage.client.render.column.SimpleColumnInfo
@@ -11,33 +12,32 @@ import mods.octarinecore.common.Int3
 import mods.octarinecore.common.Rotation
 import mods.octarinecore.common.config.ModelTextureList
 import mods.octarinecore.common.config.SimpleBlockMatcher
-import net.minecraft.block.BlockCactus
-import net.minecraft.block.state.IBlockState
+import net.minecraft.block.BlockState
+import net.minecraft.block.CactusBlock
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.*
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
+import net.minecraft.util.Direction.*
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.model.data.IModelData
+import org.apache.logging.log4j.Level.DEBUG
+import java.util.*

 object StandardCactusRegistry : ModelRenderRegistryConfigurable<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-    override val matchClasses = SimpleBlockMatcher(BlockCactus::class.java)
+    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: IBlockState, textures: List<String>) = SimpleColumnInfo.Key(logger, Axis.Y, textures)
-    init { MinecraftForge.EVENT_BUS.register(this) }
+    override fun processModel(state: BlockState, textures: List<String>) = SimpleColumnInfo.Key(logger, Axis.Y, textures)
+    init { BetterFoliage.modBus.register(this) }
 }

-@SideOnly(Side.CLIENT)
-class RenderCactus : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderCactus : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

    val cactusStemRadius = 0.4375
    val cactusArmRotation = listOf(NORTH, SOUTH, EAST, WEST).map { Rotation.rot90[it.ordinal] }

-    val iconCross = iconStatic(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_cactus")
-    val iconArm = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_cactus_arm_%d")
+    val iconCross = iconStatic(ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_cactus"))
+    val iconArm = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_cactus_arm_$idx") }

    val modelStem = model {
        horizontalRectangle(x1 = -cactusStemRadius, x2 = cactusStemRadius, z1 = -cactusStemRadius, z2 = cactusStemRadius, y = 0.5)
@@ -68,20 +68,20 @@ class RenderCactus : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
    }

    override fun afterPreStitch() {
-        Client.log(Level.INFO, "Registered ${iconArm.num} cactus arm textures")
+        Client.log(DEBUG, "Registered ${iconArm.num} cactus arm textures")
    }

    override fun isEligible(ctx: BlockContext): Boolean =
        Config.enabled && Config.cactus.enabled &&
-        Config.blocks.cactus.matchesClass(ctx.block)
+        StandardCactusRegistry[ctx] != null

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
        // render the whole block on the cutout layer
        if (!layer.isCutout) return false

        // get AO data
        modelRenderer.updateShading(Int3.zero, allFaces)
-        val icons = StandardCactusRegistry[ctx] ?: return renderWorldBlockBase(ctx, dispatcher, renderer, null)
+        val icons = StandardCactusRegistry[ctx] ?: return renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, null)

        modelRenderer.render(
            renderer,
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrass.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrass.kt
@@ -1,36 +1,36 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.config.Config
+import mods.betterfoliage.client.texture.GrassRegistry
 import mods.octarinecore.client.render.AbstractBlockRenderingHandler
 import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.client.render.withOffset
+import mods.octarinecore.client.render.offset
 import mods.octarinecore.common.Int3
 import mods.octarinecore.common.forgeDirsHorizontal
 import mods.octarinecore.common.offset
+import net.minecraft.block.Block
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.tags.BlockTags
 import net.minecraft.util.BlockRenderLayer
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraftforge.client.model.data.IModelData
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderConnectedGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderConnectedGrass : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {
    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.connectedGrass.enabled &&
-        Config.blocks.dirt.matchesClass(ctx.block) &&
-        Config.blocks.grassClasses.matchesClass(ctx.block(up1)) &&
+        BlockTags.DIRT_LIKE.contains(ctx.block) &&
+        GrassRegistry[ctx, up1] != null &&
        (Config.connectedGrass.snowEnabled || !ctx.blockState(up2).isSnow)

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
        // if the block sides are not visible anyway, render normally
-        if (forgeDirsHorizontal.all { ctx.blockState(it.offset).isOpaqueCube }) return renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+        if (forgeDirsHorizontal.none { ctx.shouldSideBeRendered(it) }) return renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, layer)

-        if (ctx.isSurroundedBy { it.isOpaqueCube } ) return false
-        return ctx.withOffset(Int3.zero, up1) {
-            ctx.withOffset(up1, up2) {
-                renderWorldBlockBase(ctx, dispatcher, renderer, layer)
-            }
+        return ctx.offset(Int3.zero, up1).offset(up1, up2).let { offsetCtx ->
+            renderWorldBlockBase(offsetCtx, dispatcher, renderer, random, modelData, layer)
        }
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrassLog.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrassLog.kt
@@ -1,36 +1,39 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.config.Config
+import mods.betterfoliage.client.texture.GrassRegistry
 import mods.octarinecore.client.render.AbstractBlockRenderingHandler
 import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.client.render.withOffset
+import mods.octarinecore.client.render.offset
 import mods.octarinecore.common.Int3
 import mods.octarinecore.common.offset
+import net.minecraft.block.Block
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.tags.BlockTags
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.*
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraft.util.Direction.*
+import net.minecraftforge.client.model.data.IModelData
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderConnectedGrassLog : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderConnectedGrassLog : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

    val grassCheckDirs = listOf(EAST, WEST, NORTH, SOUTH)

    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.roundLogs.enabled && Config.roundLogs.connectGrass &&
-        Config.blocks.dirt.matchesClass(ctx.block) &&
-        Config.blocks.logClasses.matchesClass(ctx.block(up1))
+        BlockTags.DIRT_LIKE.contains(ctx.block) &&
+        LogRegistry[ctx, up1] != null

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
        val grassDir = grassCheckDirs.find {
-            Config.blocks.grassClasses.matchesClass(ctx.block(it.offset))
-        } ?: return renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+            GrassRegistry[ctx, it.offset] != null
+        } ?: return renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, layer)

-        return ctx.withOffset(Int3.zero, grassDir.offset) {
-            renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+        return ctx.offset(Int3.zero, grassDir.offset).let { offsetCtx ->
+            renderWorldBlockBase(offsetCtx, dispatcher, renderer, random, modelData, layer)
        }
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderCoral.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderCoral.kt
@@ -1,7 +1,8 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 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.common.Int3
@@ -12,19 +13,22 @@ import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.Axis
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
+import net.minecraft.util.Direction.Axis
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
+import net.minecraft.world.biome.Biome
+import net.minecraftforge.api.distmarker.Dist
+import net.minecraftforge.client.model.data.IModelData
+import net.minecraftforge.fml.common.Mod
+import org.apache.logging.log4j.Level.DEBUG
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderCoral : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderCoral : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

    val noise = simplexNoise()

-    val coralIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_coral_%d")
-    val crustIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_crust_%d")
+    val coralIcons = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_coral_$idx") }
+    val crustIcons = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_crust_$idx") }
    val coralModels = modelSet(64) { modelIdx ->
        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.0, yTop = 1.0)
        .scale(Config.coral.size).move(0.5 to UP)
@@ -41,26 +45,26 @@ class RenderCoral : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
    }

    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${coralIcons.num} coral textures")
-        Client.log(INFO, "Registered ${crustIcons.num} coral crust textures")
+        Client.log(DEBUG, "Registered ${coralIcons.num} coral textures")
+        Client.log(DEBUG, "Registered ${crustIcons.num} coral crust textures")
    }

    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.coral.enabled &&
        (ctx.blockState(up2).material == Material.WATER || Config.coral.shallowWater) &&
        ctx.blockState(up1).material == Material.WATER &&
-        Config.blocks.sand.matchesClass(ctx.block) &&
-        ctx.biomeId in Config.coral.biomes &&
+        BlockConfig.sand.matchesClass(ctx.block) &&
+        ctx.biome.category.let { it == Biome.Category.OCEAN || it == Biome.Category.BEACH } &&
        noise[ctx.pos] < Config.coral.population

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
+        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, layer)
        if (!layer.isCutout) return baseRender

        modelRenderer.updateShading(Int3.zero, allFaces)

        forgeDirs.forEachIndexed { idx, face ->
-            if (!ctx.blockState(forgeDirOffsets[idx]).isOpaqueCube && blockContext.random(idx) < Config.coral.chance) {
+            if (!ctx.isNormalCube(forgeDirOffsets[idx]) && blockContext.random(idx) < Config.coral.chance) {
                var variation = blockContext.random(6)
                modelRenderer.render(
                    renderer,
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderGrass.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderGrass.kt
@@ -1,6 +1,6 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.config.Config
 import mods.betterfoliage.client.integration.OptifineCustomColors
@@ -9,17 +9,19 @@ import mods.betterfoliage.client.texture.GrassRegistry
 import mods.octarinecore.client.render.*
 import mods.octarinecore.common.*
 import mods.octarinecore.random
+import net.minecraft.block.Block
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.tags.BlockTags
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.Axis
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
+import net.minecraft.util.Direction.Axis
+import net.minecraft.util.Direction.*
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.model.data.IModelData
+import org.apache.logging.log4j.Level.DEBUG
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderGrass : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

    companion object {
        @JvmStatic fun grassTopQuads(heightMin: Double, heightMax: Double): Model.(Int)->Unit = { modelIdx ->
@@ -34,16 +36,16 @@ class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {

    val noise = simplexNoise()

-    val normalIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_grass_long_%d")
-    val snowedIcons = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_grass_snowed_%d")
-    val normalGenIcon = iconStatic(Client.genGrass.generatedResource("minecraft:blocks/tallgrass", "snowed" to false))
-    val snowedGenIcon = iconStatic(Client.genGrass.generatedResource("minecraft:blocks/tallgrass", "snowed" to true))
+    val normalIcons = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_grass_long_$idx") }
+    val snowedIcons = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_grass_snowed_$idx") }
+    val normalGenIcon = iconStatic { Client.genGrass.register(texture = "minecraft:blocks/tallgrass", isSnowed = false) }
+    val snowedGenIcon = iconStatic { Client.genGrass.register(texture = "minecraft:blocks/tallgrass", isSnowed = true) }

-    val grassModels = modelSet(64, grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax))
+    val grassModels = modelSet(64) { idx -> grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax)(idx) }

    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${normalIcons.num} grass textures")
-        Client.log(INFO, "Registered ${snowedIcons.num} snowed grass textures")
+        Client.log(DEBUG, "Registered ${normalIcons.num} grass textures")
+        Client.log(DEBUG, "Registered ${snowedIcons.num} snowed grass textures")
    }

    override fun isEligible(ctx: BlockContext) =
@@ -51,14 +53,11 @@ class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        (Config.shortGrass.grassEnabled || Config.connectedGrass.enabled) &&
        GrassRegistry[ctx] != null

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
        // render the whole block on the cutout layer
        if (!layer.isCutout) return false

-        val isConnected = ctx.block(down1).let {
-            Config.blocks.dirt.matchesClass(it) ||
-            Config.blocks.grassClasses.matchesClass(it)
-        }
+        val isConnected = BlockTags.DIRT_LIKE.contains(ctx.block(down1)) || GrassRegistry[ctx, down1] != null
        val isSnowed = ctx.blockState(up1).isSnow
        val connectedGrass = isConnected && Config.connectedGrass.enabled && (!isSnowed || Config.connectedGrass.snowEnabled)

@@ -66,7 +65,7 @@ class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        if (grass == null) {
            // shouldn't happen
            Client.logRenderError(ctx.blockState(Int3.zero), ctx.pos)
-            return renderWorldBlockBase(ctx, dispatcher, renderer, null)
+            return renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, null)
        }
        val blockColor = OptifineCustomColors.getBlockColor(ctx)

@@ -75,14 +74,14 @@ class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
            modelRenderer.updateShading(Int3.zero, allFaces)

            // check occlusion
-            val isHidden = forgeDirs.map { ctx.blockState(it.offset).isOpaqueCube }
+            val isVisible = forgeDirs.map { ctx.shouldSideBeRendered(it) }

            // render full grass block
            ShadersModIntegration.renderAs(ctx.blockState(Int3.zero), renderer) {
                modelRenderer.render(
                    renderer,
                    fullCube,
-                    quadFilter = { qi, _ -> !isHidden[qi] },
+                    quadFilter = { qi, _ -> isVisible[qi] },
                    icon = { _, _, _ -> grass.grassTopTexture },
                    postProcess = { ctx, _, _, _, _ ->
                        rotateUV(2)
@@ -93,7 +92,7 @@ class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
                )
            }
        } else {
-            renderWorldBlockBase(ctx, dispatcher, renderer, null)
+            renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, null)

            // get AO data only for block top
            modelRenderer.updateShading(Int3.zero, topOnly)
@@ -101,7 +100,7 @@ class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {

        if (!Config.shortGrass.grassEnabled) return true
        if (isSnowed && !Config.shortGrass.snowEnabled) return true
-        if (ctx.blockState(up1).isOpaqueCube) return true
+        if (ctx.isNormalCube(up1)) return true
        if (Config.shortGrass.population < 64 && noise[ctx.pos] >= Config.shortGrass.population) return true

        // render grass quads
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderLeaves.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderLeaves.kt
@@ -1,6 +1,6 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.config.Config
 import mods.betterfoliage.client.integration.OptifineCustomColors
@@ -17,15 +17,14 @@ import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.DOWN
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraft.util.Direction.*
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.model.data.IModelData
 import java.lang.Math.cos
 import java.lang.Math.sin
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderLeaves : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderLeaves : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

    val leavesModel = model {
        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -0.5 * 1.41, yTop = 0.5 * 1.41)
@@ -34,7 +33,7 @@ class RenderLeaves : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        .scale(Config.leaves.size)
        .toCross(UP).addAll()
    }
-    val snowedIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_leaves_snowed_%d")
+    val snowedIcon = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_leaves_snowed_$idx") }

    val perturbs = vectorSet(64) { idx ->
        val angle = PI2 * idx / 64.0
@@ -46,21 +45,19 @@ class RenderLeaves : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        Config.enabled &&
        Config.leaves.enabled &&
        LeafRegistry[ctx] != null &&
-        !(Config.leaves.hideInternal && ctx.isSurroundedBy { it.isFullCube || it.material == Material.LEAVES } )
+        !(Config.leaves.hideInternal && ctx.isSurroundedByNormal)

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val isSnowed = ctx.blockState(up1).material.let {
-            it == Material.SNOW || it == Material.CRAFTED_SNOW
-        }
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
+        val isSnowed = ctx.blockState(up1).isSnow
        val leafInfo = LeafRegistry[ctx]
        if (leafInfo == null) {
            // shouldn't happen
            Client.logRenderError(ctx.blockState(Int3.zero), ctx.pos)
-            return renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+            return renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, layer)
        }
        val blockColor = OptifineCustomColors.getBlockColor(ctx)

-        renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+        renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, layer)
        if (!layer.isCutout) return true

        modelRenderer.updateShading(Int3.zero, allFaces)
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderLilypad.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderLilypad.kt
@@ -1,7 +1,8 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 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.octarinecore.client.render.*
@@ -10,14 +11,14 @@ import mods.octarinecore.common.Rotation
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.DOWN
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.model.data.IModelData
+import org.apache.logging.log4j.Level.DEBUG
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderLilypad : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderLilypad : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

    val rootModel = model {
        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -1.5, yTop = -0.5)
@@ -30,24 +31,24 @@ class RenderLilypad : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        .setFlatShader(FlatOffsetNoColor(Int3.zero))
        .toCross(UP).addAll()
    }
-    val rootIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_lilypad_roots_%d")
-    val flowerIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_lilypad_flower_%d")
+    val rootIcon = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_lilypad_roots_$idx") }
+    val flowerIcon = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_lilypad_flower_$idx") }
    val perturbs = vectorSet(64) { modelIdx -> xzDisk(modelIdx) * Config.lilypad.hOffset }

    override fun afterPreStitch() {
-        Client.log(Level.INFO, "Registered ${rootIcon.num} lilypad root textures")
-        Client.log(Level.INFO, "Registered ${flowerIcon.num} lilypad flower textures")
+        Client.log(DEBUG, "Registered ${rootIcon.num} lilypad root textures")
+        Client.log(DEBUG, "Registered ${flowerIcon.num} lilypad flower textures")
    }

    override fun isEligible(ctx: BlockContext): Boolean =
        Config.enabled && Config.lilypad.enabled &&
-        Config.blocks.lilypad.matchesClass(ctx.block)
+        BlockConfig.lilypad.matchesClass(ctx.block)

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
        // render the whole block on the cutout layer
        if (!layer.isCutout) return false

-        renderWorldBlockBase(ctx, dispatcher, renderer, null)
+        renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, null)
        modelRenderer.updateShading(Int3.zero, allFaces)

        val rand = ctx.semiRandomArray(5)
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderLog.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderLog.kt
@@ -1,30 +1,32 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 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.texture.GrassRegistry
 import mods.octarinecore.client.render.BlockContext
-import mods.octarinecore.client.resource.*
+import mods.octarinecore.client.resource.ModelRenderRegistry
+import mods.octarinecore.client.resource.ModelRenderRegistryConfigurable
+import mods.octarinecore.client.resource.ModelRenderRegistryRoot
 import mods.octarinecore.common.config.ConfigurableBlockMatcher
 import mods.octarinecore.common.config.ModelTextureList
 import mods.octarinecore.tryDefault
-import net.minecraft.block.BlockLog
-import net.minecraft.block.state.IBlockState
-import net.minecraft.util.EnumFacing.Axis
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraft.block.BlockState
+import net.minecraft.block.LogBlock
+import net.minecraft.util.Direction.Axis

-class RenderLog : AbstractRenderColumn(BetterFoliageMod.MOD_ID) {
+class RenderLog : AbstractRenderColumn(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

    override val addToCutout: Boolean get() = false

    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.roundLogs.enabled &&
-        Config.blocks.logClasses.matchesClass(ctx.block)
+        LogRegistry[ctx] != null

    override val overlayLayer = RoundLogOverlayLayer()
    override val connectPerpendicular: Boolean get() = Config.roundLogs.connectPerpendicular
@@ -37,26 +39,26 @@ class RenderLog : AbstractRenderColumn(BetterFoliageMod.MOD_ID) {

 class RoundLogOverlayLayer : ColumnRenderLayer() {
    override val registry: ModelRenderRegistry<ColumnTextureInfo> get() = LogRegistry
-    override val blockPredicate = { state: IBlockState -> Config.blocks.logClasses.matchesClass(state.block) }
-    override val surroundPredicate = { state: IBlockState -> state.isOpaqueCube && !Config.blocks.logClasses.matchesClass(state.block) }
+    override val blockPredicate = { state: BlockState -> BlockConfig.logBlocks.matchesClass(state.block) }
+    override val surroundPredicate = { state: BlockState -> !BlockConfig.logBlocks.matchesClass(state.block) }

    override val connectSolids: Boolean get() = Config.roundLogs.connectSolids
    override val lenientConnect: Boolean get() = Config.roundLogs.lenientConnect
    override val defaultToY: Boolean get() = Config.roundLogs.defaultY
 }

-@SideOnly(Side.CLIENT)
 object LogRegistry : ModelRenderRegistryRoot<ColumnTextureInfo>()

 object StandardLogRegistry : ModelRenderRegistryConfigurable<ColumnTextureInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-    override val matchClasses: ConfigurableBlockMatcher get() = Config.blocks.logClasses
-    override val modelTextures: List<ModelTextureList> get() = Config.blocks.logModels.list
-    override fun processModel(state: IBlockState, textures: List<String>) = SimpleColumnInfo.Key(logger, getAxis(state), textures)
+    override val logger = BetterFoliage.logDetail
+    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.logBlocks
+    override val modelTextures: List<ModelTextureList> get() = BlockConfig.logModels.modelList
+    override fun processModel(state: BlockState, textures: List<String>) = SimpleColumnInfo.Key(logger, getAxis(state), textures)
+    init { BetterFoliage.modBus.register(this) }

-    fun getAxis(state: IBlockState): Axis? {
-        val axis = tryDefault(null) { state.getValue(BlockLog.LOG_AXIS).toString() } ?:
-        state.properties.entries.find { it.key.getName().toLowerCase() == "axis" }?.value?.toString()
+    fun getAxis(state: BlockState): Axis? {
+        val axis = tryDefault(null) { state.get(LogBlock.AXIS).toString() } ?:
+        state.values.entries.find { it.key.getName().toLowerCase() == "axis" }?.value?.toString()
        return when (axis) {
            "x" -> Axis.X
            "y" -> Axis.Y
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderMycelium.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderMycelium.kt
@@ -1,7 +1,8 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.Client
+import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.config.Config
 import mods.octarinecore.client.render.AbstractBlockRenderingHandler
 import mods.octarinecore.client.render.BlockContext
@@ -12,35 +13,35 @@ import mods.octarinecore.common.Rotation
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
 import net.minecraft.util.BlockRenderLayer
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.model.data.IModelData
+import org.apache.logging.log4j.Level.DEBUG
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderMycelium : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderMycelium : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

-    val myceliumIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_mycel_%d")
-    val myceliumModel = modelSet(64, RenderGrass.grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax))
+    val myceliumIcon = iconSet { idx -> ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_mycel_$idx") }
+    val myceliumModel = modelSet(64) { idx -> RenderGrass.grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax)(idx) }

    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${myceliumIcon.num} mycelium textures")
+        Client.log(DEBUG, "Registered ${myceliumIcon.num} mycelium textures")
    }

    override fun isEligible(ctx: BlockContext): Boolean {
        if (!Config.enabled || !Config.shortGrass.myceliumEnabled) return false
-        return Config.blocks.mycelium.matchesClass(ctx.block)
+        return BlockConfig.mycelium.matchesClass(ctx.block)
    }

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
        // render the whole block on the cutout layer
        if (!layer.isCutout) return false

        val isSnowed = ctx.blockState(up1).isSnow

-        renderWorldBlockBase(ctx, dispatcher, renderer, null)
+        renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, null)

        if (isSnowed && !Config.shortGrass.snowEnabled) return true
-        if (ctx.blockState(up1).isOpaqueCube) return true
+        if (ctx.isNormalCube(up1)) return true

        val rand = ctx.semiRandomArray(2)
        modelRenderer.render(
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderNetherrack.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderNetherrack.kt
@@ -1,7 +1,8 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 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.common.Int3
@@ -10,15 +11,16 @@ import mods.octarinecore.random
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.*
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level.INFO
+import net.minecraft.util.Direction.Axis
+import net.minecraft.util.Direction.*
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.model.data.IModelData
+import org.apache.logging.log4j.Level.DEBUG
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderNetherrack : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderNetherrack : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

-    val netherrackIcon = iconSet(BetterFoliageMod.LEGACY_DOMAIN, "blocks/better_netherrack_%d")
+    val netherrackIcon = iconSet { idx -> ResourceLocation(BetterFoliage.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))
@@ -29,19 +31,19 @@ class RenderNetherrack : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID)
    }

    override fun afterPreStitch() {
-        Client.log(INFO, "Registered ${netherrackIcon.num} netherrack textures")
+        Client.log(DEBUG, "Registered ${netherrackIcon.num} netherrack textures")
    }

    override fun isEligible(ctx: BlockContext): Boolean {
        if (!Config.enabled || !Config.netherrack.enabled) return false
-        return Config.blocks.netherrack.matchesClass(ctx.block)
+        return BlockConfig.netherrack.matchesClass(ctx.block)
    }

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
+        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, layer)
        if (!layer.isCutout) return baseRender

-        if (ctx.blockState(down1).isOpaqueCube) return baseRender
+        if (ctx.isNormalCube(down1)) return baseRender

        modelRenderer.updateShading(Int3.zero, allFaces)

--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderReeds.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderReeds.kt
@@ -1,27 +1,30 @@
 package mods.betterfoliage.client.render

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 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.octarinecore.client.render.*
 import mods.octarinecore.common.Int3
 import mods.octarinecore.common.Rotation
 import mods.octarinecore.random
+import net.minecraft.block.Block
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.tags.BlockTags
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.UP
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
-import org.apache.logging.log4j.Level
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.client.model.data.IModelData
+import org.apache.logging.log4j.Level.DEBUG
+import java.util.*

-@SideOnly(Side.CLIENT)
-class RenderReeds : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
+class RenderReeds : AbstractBlockRenderingHandler(BetterFoliage.MOD_ID, BetterFoliage.modBus) {

    val noise = simplexNoise()
-    val reedIcons = iconSet(Client.genReeds.generatedResource("${BetterFoliageMod.LEGACY_DOMAIN}:blocks/better_reed_%d"))
+    val reedIcons = iconSet { idx -> Client.genReeds.registerResource(ResourceLocation(BetterFoliage.MOD_ID, "blocks/better_reed_$idx")) }
    val reedModels = modelSet(64) { modelIdx ->
        val height = random(Config.reed.heightMin, Config.reed.heightMax)
        val waterline = 0.875f
@@ -41,19 +44,19 @@ class RenderReeds : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
    }

    override fun afterPreStitch() {
-        Client.log(Level.INFO, "Registered ${reedIcons.num} reed textures")
+        Client.log(DEBUG, "Registered ${reedIcons.num} reed textures")
    }

    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.reed.enabled &&
        ctx.blockState(up2).material == Material.AIR &&
        ctx.blockState(up1).material == Material.WATER &&
-        Config.blocks.dirt.matchesClass(ctx.block) &&
-        ctx.biomeId in Config.reed.biomes &&
+        BlockTags.DIRT_LIKE.contains(ctx.block) &&
+        ctx.biome.let { it.downfall > Config.reed.minBiomeRainfall && it.defaultTemperature >= Config.reed.minBiomeTemp } &&
        noise[ctx.pos] < Config.reed.population

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
-        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, layer)
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {
+        val baseRender = renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, layer)
        if (!layer.isCutout) return baseRender

        modelRenderer.updateShading(Int3.zero, allFaces)
--- a/src/main/kotlin/mods/betterfoliage/client/render/Utils.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/Utils.kt
@@ -2,17 +2,20 @@
 package mods.betterfoliage.client.render

 import mods.octarinecore.PI2
-import mods.octarinecore.client.render.*
+import mods.octarinecore.client.render.Model
+import mods.octarinecore.client.render.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
-import net.minecraft.block.Block
+import net.minecraft.block.BlockState
 import net.minecraft.block.material.Material
-import net.minecraft.block.state.IBlockState
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing
-import net.minecraft.util.EnumFacing.*
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.*
+import kotlin.math.cos
+import kotlin.math.sin

 val up1 = Int3(1 to UP)
 val up2 = Int3(2 to UP)
@@ -25,15 +28,15 @@ val denseLeavesRot = arrayOf(Rotation.identity, Rotation.rot90[EAST.ordinal], Ro
 val whitewash: PostProcessLambda = { _, _, _, _, _ -> setGrey(1.4f) }
 val greywash: PostProcessLambda = { _, _, _, _, _ -> setGrey(1.0f) }

-val IBlockState.isSnow: Boolean get() = material.let { it == Material.SNOW || it == Material.CRAFTED_SNOW }
+val BlockState.isSnow: Boolean get() = material.let { it == Material.SNOW }

-fun Quad.toCross(rotAxis: EnumFacing, trans: (Quad)->Quad) =
+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: EnumFacing) = toCross(rotAxis) { it }
+fun Quad.toCross(rotAxis: Direction) = toCross(rotAxis) { it }

-fun xzDisk(modelIdx: Int) = (PI2 * modelIdx / 64.0).let { Double3(Math.cos(it), 0.0, Math.sin(it)) }
+fun xzDisk(modelIdx: Int) = (PI2 * modelIdx / 64.0).let { Double3(cos(it), 0.0, sin(it)) }

 val rotationFromUp = arrayOf(
    Rotation.rot90[EAST.ordinal] * 2,
@@ -58,5 +61,5 @@ fun Model.mix(first: Model, second: Model, predicate: (Int)->Boolean) {

 val BlockRenderLayer.isCutout: Boolean get() = (this == BlockRenderLayer.CUTOUT) || (this == BlockRenderLayer.CUTOUT_MIPPED)

-fun IBlockState.canRenderInLayer(layer: BlockRenderLayer) = this.block.canRenderInLayer(this, layer)
-fun IBlockState.canRenderInCutout() = this.block.canRenderInLayer(this, BlockRenderLayer.CUTOUT) || this.block.canRenderInLayer(this, BlockRenderLayer.CUTOUT_MIPPED)
+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)
--- a/src/main/kotlin/mods/betterfoliage/client/render/column/AbstractRenderer.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/column/AbstractRenderer.kt
@@ -1,31 +1,29 @@
 package mods.betterfoliage.client.render.column

 import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.chunk.ChunkOverlayLayer
 import mods.betterfoliage.client.chunk.ChunkOverlayManager
-import mods.betterfoliage.client.config.Config
 import mods.betterfoliage.client.integration.ShadersModIntegration.renderAs
 import mods.betterfoliage.client.render.*
 import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.BlockType.*
 import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.QuadrantType
 import mods.betterfoliage.client.render.column.ColumnLayerData.SpecialRender.QuadrantType.*
 import mods.octarinecore.client.render.*
-import mods.octarinecore.client.resource.ModelRenderRegistry
-import mods.octarinecore.common.*
-import net.minecraft.block.state.IBlockState
+import mods.octarinecore.common.Int3
+import mods.octarinecore.common.Rotation
+import mods.octarinecore.common.face
+import mods.octarinecore.common.rot
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.client.renderer.chunk.ChunkRenderCache
+import net.minecraft.client.world.ClientWorld
 import net.minecraft.util.BlockRenderLayer
-import net.minecraft.util.EnumFacing.*
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraft.util.Direction.*
+import net.minecraftforge.client.model.data.IModelData
+import net.minecraftforge.eventbus.api.IEventBus
+import java.util.*

-@SideOnly(Side.CLIENT)
@Suppress("NOTHING_TO_INLINE")
-abstract class AbstractRenderColumn(modId: String) : AbstractBlockRenderingHandler(modId) {
+abstract class AbstractRenderColumn(modId: String, modBus: IEventBus) : AbstractBlockRenderingHandler(modId, modBus) {

    /** The rotations necessary to bring the models in position for the 4 quadrants */
    val quadrantRotations = Array(4) { Rotation.rot90[UP.ordinal] * it }
@@ -96,21 +94,21 @@ abstract class AbstractRenderColumn(modId: String) : AbstractBlockRenderingHandl
        q1 == q2 || ((q1 == SQUARE || q1 == INVISIBLE) && (q2 == SQUARE || q2 == INVISIBLE))

    @Suppress("NON_EXHAUSTIVE_WHEN")
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, layer: BlockRenderLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: BufferBuilder, random: Random, modelData: IModelData, layer: BlockRenderLayer): Boolean {

-        val roundLog = ChunkOverlayManager.get(overlayLayer, ctx.world!!, ctx.pos)
+        val roundLog = ChunkOverlayManager.get(overlayLayer, ctx.reader!!, ctx.pos)
        when(roundLog) {
            ColumnLayerData.SkipRender -> return true
-            ColumnLayerData.NormalRender -> return renderWorldBlockBase(ctx, dispatcher, renderer, null)
+            ColumnLayerData.NormalRender -> return renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, null)
            ColumnLayerData.ResolveError, null -> {
                Client.logRenderError(ctx.blockState(Int3.zero), ctx.pos)
-                return renderWorldBlockBase(ctx, dispatcher, renderer, null)
+                return renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, null)
            }
        }

        // if log axis is not defined and "Default to vertical" config option is not set, render normally
        if ((roundLog as ColumnLayerData.SpecialRender).column.axis == null && !overlayLayer.defaultToY) {
-            return renderWorldBlockBase(ctx, dispatcher, renderer, null)
+            return renderWorldBlockBase(ctx, dispatcher, renderer, random, modelData, null)
        }

        // get AO data
--- a/src/main/kotlin/mods/betterfoliage/client/render/column/OverlayLayer.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/column/OverlayLayer.kt
@@ -2,6 +2,7 @@ package mods.betterfoliage.client.render.column

 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
@@ -13,12 +14,11 @@ import mods.octarinecore.common.Int3
 import mods.octarinecore.common.Rotation
 import mods.octarinecore.common.face
 import mods.octarinecore.common.plus
-import net.minecraft.block.state.IBlockState
-import net.minecraft.util.EnumFacing
+import net.minecraft.block.BlockState
+import net.minecraft.util.Direction.Axis
+import net.minecraft.util.Direction.AxisDirection
 import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraft.world.IEnviromentBlockReader

 /** Index of SOUTH-EAST quadrant. */
 const val SE = 0
@@ -32,13 +32,11 @@ const val SW = 3
 /**
 * Sealed class hierarchy for all possible render outcomes
 */
-@SideOnly(Side.CLIENT)
 sealed class ColumnLayerData {
    /**
     * Data structure to cache texture and world neighborhood data relevant to column rendering
     */
    @Suppress("ArrayInDataClass") // not used in comparisons anywhere
-    @SideOnly(Side.CLIENT)
    data class SpecialRender(
        val column: ColumnTextureInfo,
        val upType: BlockType,
@@ -52,15 +50,12 @@ sealed class ColumnLayerData {
    }

    /** Column block should not be rendered at all */
-    @SideOnly(Side.CLIENT)
    object SkipRender : ColumnLayerData()

    /** Column block must be rendered normally */
-    @SideOnly(Side.CLIENT)
    object NormalRender : ColumnLayerData()

    /** Error while resolving render data, column block must be rendered normally */
-    @SideOnly(Side.CLIENT)
    object ResolveError : ColumnLayerData()
 }

@@ -68,29 +63,29 @@ sealed class ColumnLayerData {
 abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {

    abstract val registry: ModelRenderRegistry<ColumnTextureInfo>
-    abstract val blockPredicate: (IBlockState)->Boolean
-    abstract val surroundPredicate: (IBlockState) -> Boolean
+    abstract val blockPredicate: (BlockState)->Boolean
+    abstract val surroundPredicate: (BlockState) -> Boolean
    abstract val connectSolids: Boolean
    abstract val lenientConnect: Boolean
    abstract val defaultToY: Boolean

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

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

-    override fun calculate(world: IBlockAccess, pos: BlockPos) = calculate(BlockContext(world, pos))
+    override fun calculate(reader: IEnviromentBlockReader, pos: BlockPos) = calculate(BlockContext(reader, pos))

    fun calculate(ctx: BlockContext): ColumnLayerData {
-        if (ctx.isSurroundedBy(surroundPredicate)) return ColumnLayerData.SkipRender
+        if (ctx.isSurroundedBy(surroundPredicate) && ctx.isSurroundedByNormal) return ColumnLayerData.SkipRender
        val columnTextures = registry[ctx] ?: return ColumnLayerData.ResolveError

        // if log axis is not defined and "Default to vertical" config option is not set, render normally
-        val logAxis = columnTextures.axis ?: if (defaultToY) EnumFacing.Axis.Y else return ColumnLayerData.NormalRender
+        val logAxis = columnTextures.axis ?: if (defaultToY) Axis.Y else return ColumnLayerData.NormalRender

        // check log neighborhood
-        val baseRotation = rotationFromUp[(logAxis to EnumFacing.AxisDirection.POSITIVE).face.ordinal]
+        val baseRotation = rotationFromUp[(logAxis to AxisDirection.POSITIVE).face.ordinal]

        val upType = ctx.blockType(baseRotation, logAxis, Int3(0, 1, 0))
        val downType = ctx.blockType(baseRotation, logAxis, Int3(0, -1, 0))
@@ -109,7 +104,7 @@ abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {
    }

    /** Fill the array of [QuadrantType]s based on the blocks to the sides of this one. */
-    fun Array<QuadrantType>.checkNeighbors(ctx: BlockContext, rotation: Rotation, logAxis: EnumFacing.Axis, yOff: Int): Array<QuadrantType> {
+    fun Array<QuadrantType>.checkNeighbors(ctx: BlockContext, rotation: Rotation, logAxis: Axis, yOff: Int): Array<QuadrantType> {
        val blkS = ctx.blockType(rotation, logAxis, Int3(0, yOff, 1))
        val blkE = ctx.blockType(rotation, logAxis, Int3(1, yOff, 0))
        val blkN = ctx.blockType(rotation, logAxis, Int3(0, yOff, -1))
@@ -176,13 +171,13 @@ abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {
    /**
     * Get the type of the block at the given offset in a rotated reference frame.
     */
-    fun BlockContext.blockType(rotation: Rotation, axis: EnumFacing.Axis, offset: Int3): ColumnLayerData.SpecialRender.BlockType {
+    fun BlockContext.blockType(rotation: Rotation, axis: Axis, offset: Int3): ColumnLayerData.SpecialRender.BlockType {
        val offsetRot = offset.rotate(rotation)
        val state = blockState(offsetRot)
        return if (!blockPredicate(state)) {
-            if (state.isOpaqueCube) SOLID else NONSOLID
+            if (isNormalCube(offsetRot)) SOLID else NONSOLID
        } else {
-            (registry[state, world!!, pos + offsetRot]?.axis ?: if (Config.roundLogs.defaultY) EnumFacing.Axis.Y else null)?.let {
+            (registry[state, reader!!, pos + offsetRot]?.axis ?: if (Config.roundLogs.defaultY) Axis.Y else null)?.let {
                if (it == axis) PARALLEL else PERPENDICULAR
            } ?: SOLID
        }
--- a/src/main/kotlin/mods/betterfoliage/client/render/column/RenderData.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/column/RenderData.kt
@@ -4,25 +4,22 @@ import mods.octarinecore.client.render.QuadIconResolver
 import mods.octarinecore.client.render.blockContext
 import mods.octarinecore.client.resource.ModelRenderKey
 import mods.octarinecore.client.resource.get
+import mods.octarinecore.client.resource.missingSprite
 import mods.octarinecore.common.rotate
+import net.minecraft.client.renderer.texture.AtlasTexture
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.client.renderer.texture.TextureMap
-import net.minecraft.util.EnumFacing
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
+import net.minecraft.util.Direction.*
 import org.apache.logging.log4j.Logger

-@SideOnly(Side.CLIENT)
 interface ColumnTextureInfo {
-    val axis: EnumFacing.Axis?
+    val axis: Axis?
    val top: QuadIconResolver
    val bottom: QuadIconResolver
    val side: QuadIconResolver
 }

-@SideOnly(Side.CLIENT)
 open class SimpleColumnInfo(
-    override val axis: EnumFacing.Axis?,
+    override val axis: Axis?,
    val topTexture: TextureAtlasSprite,
    val bottomTexture: TextureAtlasSprite,
    val sideTextures: List<TextureAtlasSprite>
@@ -34,17 +31,17 @@ open class SimpleColumnInfo(
    override val top: QuadIconResolver = { _, _, _ -> topTexture }
    override val bottom: QuadIconResolver = { _, _, _ -> bottomTexture }
    override val side: QuadIconResolver = { ctx, idx, _ ->
-        val worldFace = (if ((idx and 1) == 0) EnumFacing.SOUTH else EnumFacing.EAST).rotate(ctx.rotation)
+        val worldFace = (if ((idx and 1) == 0) SOUTH else EAST).rotate(ctx.rotation)
        val sideIdx = if (sideTextures.size > 1) (blockContext.random(1) + dirToIdx[worldFace.ordinal]) % sideTextures.size else 0
        sideTextures[sideIdx]
    }

-    class Key(override val logger: Logger, val axis: EnumFacing.Axis?, val textures: List<String>) : ModelRenderKey<ColumnTextureInfo> {
-        override fun resolveSprites(atlas: TextureMap) = SimpleColumnInfo(
+    class Key(override val logger: Logger, val axis: Axis?, val textures: List<String>) : ModelRenderKey<ColumnTextureInfo> {
+        override fun resolveSprites(atlas: AtlasTexture) = SimpleColumnInfo(
            axis,
-            atlas[textures[0]] ?: atlas.missingSprite,
-            atlas[textures[1]] ?: atlas.missingSprite,
-            textures.drop(2).map { atlas[it] ?: atlas.missingSprite }
+            atlas[textures[0]] ?: missingSprite,
+            atlas[textures[1]] ?: missingSprite,
+            textures.drop(2).map { atlas[it] ?: missingSprite }
        )
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/client/texture/GrassGenerator.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/GrassGenerator.kt
@@ -2,7 +2,9 @@ package mods.betterfoliage.client.texture

 import mods.octarinecore.client.resource.*
 import net.minecraft.util.ResourceLocation
+import net.minecraftforge.resource.VanillaResourceType.TEXTURES
 import java.awt.image.BufferedImage
+import java.io.InputStream

 /**
 * Generate Short Grass textures from [Blocks.tallgrass] block textures.
@@ -10,13 +12,16 @@ import java.awt.image.BufferedImage
 *
 * @param[domain] Resource domain of generator
 */
-class GrassGenerator(domain: String) : TextureGenerator(domain) {
+class GrassGenerator(domain: String) : GeneratorBase<GrassGenerator.Key>(domain, TEXTURES) {

-    override fun generate(params: ParameterList): BufferedImage? {
-        val target = targetResource(params)!!
-        val isSnowed = params["snowed"]?.toBoolean() ?: false
+    override val locationMapper = Atlas.BLOCKS::unwrap

-        val baseTexture = resourceManager[target.second]?.loadImage() ?: return null
+    fun register(texture: String, isSnowed: Boolean) = registerResource(Key(ResourceLocation(texture), isSnowed))
+
+    override fun exists(key: Key) = resourceManager.hasResource(Atlas.BLOCKS.wrap(key.texture))
+
+    override fun get(key: Key): InputStream? {
+        val baseTexture = resourceManager[Atlas.BLOCKS.wrap(key.texture)]?.loadImage() ?: return null

        val result = BufferedImage(baseTexture.width, baseTexture.height, BufferedImage.TYPE_4BYTE_ABGR)
        val graphics = result.createGraphics()
@@ -39,12 +44,14 @@ class GrassGenerator(domain: String) : TextureGenerator(domain) {
        }

        // blend with white if snowed
-        if (isSnowed && target.first == ResourceType.COLOR) {
+        if (key.isSnowed) {
            for (x in 0..result.width - 1) for (y in 0..result.height - 1) {
                result[x, y] = blendRGB(result[x, y], 16777215, 2, 3)
            }
        }

-        return result
+        return result.asStream
    }
+
+    data class Key(val texture: ResourceLocation, val isSnowed: Boolean)
 }
--- a/src/main/kotlin/mods/betterfoliage/client/texture/GrassRegistry.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/GrassRegistry.kt
@@ -1,25 +1,15 @@
 package mods.betterfoliage.client.texture

-import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.BlockContext
 import mods.octarinecore.client.render.HSB
 import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.Int3
 import mods.octarinecore.common.config.ConfigurableBlockMatcher
-import mods.octarinecore.common.config.IBlockMatcher
 import mods.octarinecore.common.config.ModelTextureList
-import mods.octarinecore.findFirst
-import net.minecraft.block.state.IBlockState
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.texture.AtlasTexture
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.client.renderer.texture.TextureMap
-import net.minecraft.util.EnumFacing
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
 import org.apache.logging.log4j.Level
 import org.apache.logging.log4j.Logger
 import java.lang.Math.min
@@ -43,16 +33,17 @@ class GrassInfo(
 object GrassRegistry : ModelRenderRegistryRoot<GrassInfo>()

 object StandardGrassRegistry : ModelRenderRegistryConfigurable<GrassInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-    override val matchClasses: ConfigurableBlockMatcher get() = Config.blocks.grassClasses
-    override val modelTextures: List<ModelTextureList> get() = Config.blocks.grassModels.list
-    override fun processModel(state: IBlockState, textures: List<String>) = StandardGrassKey(logger, textures[0])
+    override val logger = BetterFoliage.logDetail
+    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.grassBlocks
+    override val modelTextures: List<ModelTextureList> get() = BlockConfig.grassModels.modelList
+    override fun processModel(state: BlockState, textures: List<String>) = StandardGrassKey(logger, textures[0])
+    init { BetterFoliage.modBus.register(this) }
 }

 class StandardGrassKey(override val logger: Logger, val textureName: String) : ModelRenderKey<GrassInfo> {
-    override fun resolveSprites(atlas: TextureMap): GrassInfo {
+    override fun resolveSprites(atlas: AtlasTexture): GrassInfo {
        val logName = "StandardGrassKey"
-        val texture = atlas[textureName] ?: atlas.missingSprite
+        val texture = atlas[textureName] ?: missingSprite
        logger.log(Level.DEBUG, "$logName: texture $textureName")
        val hsb = HSB.fromColor(texture.averageColor ?: defaultGrassColor)
        val overrideColor = if (hsb.saturation >= Config.shortGrass.saturationThreshold) {
--- a/src/main/kotlin/mods/betterfoliage/client/texture/LeafGenerator.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/LeafGenerator.kt
@@ -1,10 +1,13 @@
 package mods.betterfoliage.client.texture

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.octarinecore.client.resource.*
 import mods.octarinecore.stripStart
+import net.minecraft.resources.IResource
 import net.minecraft.util.ResourceLocation
+import net.minecraftforge.resource.VanillaResourceType.TEXTURES
 import java.awt.image.BufferedImage
+import java.io.InputStream

 /**
 * Generate round leaf textures from leaf block textures.
@@ -14,22 +17,24 @@ import java.awt.image.BufferedImage
 *
 * @param[domain] Resource domain of generator
 */
-class LeafGenerator(domain: String) : TextureGenerator(domain) {
+class LeafGenerator(domain: String) : GeneratorBase<LeafGenerator.Key>(domain, TEXTURES) {

-    override fun generate(params: ParameterList): BufferedImage? {
-        val target = targetResource(params)!!
-        val leafType = params["type"] ?: "default"
+    override val locationMapper = Atlas.BLOCKS::unwrap

-        val handDrawnLoc = target.second.stripStart("textures/").stripStart("blocks/").let {
-            ResourceLocation(BetterFoliageMod.DOMAIN, "${it.namespace}/textures/blocks/${it.path}")
-        }
-        resourceManager[handDrawnLoc]?.loadImage()?.let { return it }
+    fun register(texture: ResourceLocation, leafType: String) = registerResource(Key(texture, leafType))

-        val baseTexture = resourceManager[target.second]?.loadImage() ?: return null
+    override fun exists(key: Key) = resourceManager.hasResource(Atlas.BLOCKS.wrap(key.texture))
+
+    override fun get(key: Key): InputStream? {
+
+//        val handDrawnLoc = Atlas.BLOCKS.wrap(key.texture)
+//        resourceManager[handDrawnLoc]?.loadImage()?.let { return it.asStream }
+
+        val baseTexture = resourceManager[Atlas.BLOCKS.wrap(key.texture)]?.loadImage() ?: return null
        val size = baseTexture.width
        val frames = baseTexture.height / size

-        val maskTexture = (getLeafMask(leafType, size * 2) ?: getLeafMask("default", size * 2))?.loadImage()
+        val maskTexture = (getLeafMask(key.leafType, size * 2) ?: getLeafMask("default", size * 2))?.loadImage()
        fun scale(i: Int) = i * maskTexture!!.width / (size * 2)

        val leafTexture = BufferedImage(size * 2, size * 2 * frames, BufferedImage.TYPE_4BYTE_ABGR)
@@ -49,7 +54,7 @@ class LeafGenerator(domain: String) : TextureGenerator(domain) {
            }

            // overlay alpha mask
-            if (target.first == ResourceType.COLOR && maskTexture != null) {
+            if (maskTexture != null) {
                for (x in 0 .. size * 2 - 1) for (y in 0 .. size * 2 - 1) {
                    val basePixel = leafFrame[x, y].toLong() and 0xFFFFFFFFL
                    val maskPixel = maskTexture[scale(x), scale(y)].toLong() and 0xFF000000L or 0xFFFFFFL
@@ -61,7 +66,7 @@ class LeafGenerator(domain: String) : TextureGenerator(domain) {
            graphics.drawImage(leafFrame, 0, size * frame * 2, null)
        }

-        return leafTexture
+        return leafTexture.asStream
    }

    /**
@@ -71,7 +76,22 @@ class LeafGenerator(domain: String) : TextureGenerator(domain) {
     * @param[maxSize] Preferred mask size.
     */
    fun getLeafMask(type: String, maxSize: Int) = getMultisizeTexture(maxSize) { size ->
-        ResourceLocation(BetterFoliageMod.DOMAIN, "textures/blocks/leafmask_${size}_${type}.png")
+        ResourceLocation(BetterFoliage.MOD_ID, "textures/blocks/leafmask_${size}_${type}.png")
    }

+    /**
+     * Get a texture resource when multiple sizes may exist.
+     *
+     * @param[maxSize] Maximum size to consider. This value is progressively halved when searching for smaller versions.
+     * @param[maskPath] Location of the texture of the given size
+     *
+     */
+    fun getMultisizeTexture(maxSize: Int, maskPath: (Int)->ResourceLocation): IResource? {
+        var size = maxSize
+        val sizes = mutableListOf<Int>()
+        while(size > 2) { sizes.add(size); size /= 2 }
+        return sizes.map { resourceManager[maskPath(it)] }.filterNotNull().firstOrNull()
+    }
+
+    data class Key(val texture: ResourceLocation, val leafType: String)
 }
--- a/src/main/kotlin/mods/betterfoliage/client/texture/LeafParticleRegistry.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/LeafParticleRegistry.kt
@@ -1,40 +1,42 @@
 package mods.betterfoliage.client.texture

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.octarinecore.client.resource.*
 import mods.octarinecore.stripStart
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
 import net.minecraft.util.ResourceLocation
 import net.minecraftforge.client.event.TextureStitchEvent
 import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.common.eventhandler.EventPriority
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+import net.minecraftforge.eventbus.api.EventPriority
+import net.minecraftforge.eventbus.api.SubscribeEvent

 object LeafParticleRegistry {
+    val targetAtlas = Atlas.PARTICLES
    val typeMappings = TextureMatcher()
    val particles = hashMapOf<String, IconSet>()

    operator fun get(type: String) = particles[type] ?: particles["default"]!!

-    init { MinecraftForge.EVENT_BUS.register(this) }
-
-    @SubscribeEvent(priority = EventPriority.HIGH)
-    fun handleLoadModelData(event: LoadModelDataEvent) {
-        particles.clear()
-        typeMappings.loadMappings(ResourceLocation(BetterFoliageMod.DOMAIN, "leaf_texture_mappings.cfg"))
-    }
+    init { BetterFoliage.modBus.register(this) }

    @SubscribeEvent
    fun handlePreStitch(event: TextureStitchEvent.Pre) {
+        if (!targetAtlas.matches(event)) return
+
+        particles.clear()
+        typeMappings.loadMappings(ResourceLocation(BetterFoliage.MOD_ID, "leaf_texture_mappings.cfg"))
+
        val allTypes = (typeMappings.mappings.map { it.type } + "default").distinct()
        allTypes.forEach { leafType ->
-            val particleSet = IconSet("betterfoliage", "blocks/falling_leaf_${leafType}_%d").apply { onPreStitch(event.map) }
+            val particleSet = IconSet(Atlas.PARTICLES) {
+                idx -> ResourceLocation(BetterFoliage.MOD_ID, "falling_leaf_${leafType}_$idx")
+            }.apply { onPreStitch(event) }
            if (leafType == "default" || particleSet.num > 0) particles[leafType] = particleSet
        }
    }

    @SubscribeEvent
    fun handlePostStitch(event: TextureStitchEvent.Post) {
+        if (!targetAtlas.matches(event)) return
        particles.forEach { (_, particleSet) -> particleSet.onPostStitch(event.map) }
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/client/texture/LeafRegistry.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/LeafRegistry.kt
@@ -1,28 +1,16 @@
 package mods.betterfoliage.client.texture

-import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.Config
-import mods.octarinecore.client.render.BlockContext
+import mods.betterfoliage.client.config.BlockConfig
 import mods.octarinecore.client.resource.*
-import mods.octarinecore.common.Int3
 import mods.octarinecore.common.config.ConfigurableBlockMatcher
-import mods.octarinecore.common.config.IBlockMatcher
 import mods.octarinecore.common.config.ModelTextureList
-import mods.octarinecore.findFirst
-import net.minecraft.block.state.IBlockState
+import net.minecraft.block.BlockState
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.client.renderer.texture.TextureMap
-import net.minecraft.util.EnumFacing
+import net.minecraft.client.renderer.texture.AtlasTexture
 import net.minecraft.util.ResourceLocation
-import net.minecraft.util.math.BlockPos
-import net.minecraft.world.IBlockAccess
 import net.minecraftforge.client.event.TextureStitchEvent
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.common.eventhandler.EventPriority
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
-import net.minecraftforge.fml.relauncher.Side
-import net.minecraftforge.fml.relauncher.SideOnly
 import org.apache.logging.log4j.Level
 import org.apache.logging.log4j.Logger

@@ -46,25 +34,26 @@ class LeafInfo(
 object LeafRegistry : ModelRenderRegistryRoot<LeafInfo>()

 object StandardLeafRegistry : ModelRenderRegistryConfigurable<LeafInfo>() {
-    override val logger = BetterFoliageMod.logDetail
-    override val matchClasses: ConfigurableBlockMatcher get() = Config.blocks.leavesClasses
-    override val modelTextures: List<ModelTextureList> get() = Config.blocks.leavesModels.list
-    override fun processModel(state: IBlockState, textures: List<String>) = StandardLeafKey(logger, textures[0])
+    override val logger = BetterFoliage.logDetail
+    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.leafBlocks
+    override val modelTextures: List<ModelTextureList> get() = BlockConfig.leafModels.modelList
+    override fun processModel(state: BlockState, textures: List<String>) = StandardLeafKey(logger, textures[0])
+    init { BetterFoliage.modBus.register(this) }
 }

 class StandardLeafKey(override val logger: Logger, val textureName: String) : ModelRenderKey<LeafInfo> {
    lateinit var leafType: String
    lateinit var generated: ResourceLocation

-    override fun onPreStitch(atlas: TextureMap) {
+    override fun onPreStitch(event: TextureStitchEvent.Pre) {
        val logName = "StandardLeafKey"
        leafType = LeafParticleRegistry.typeMappings.getType(textureName) ?: "default"
-        generated = Client.genLeaves.generatedResource(textureName, "type" to leafType)
-        atlas.registerSprite(generated)
+        generated = Client.genLeaves.register(ResourceLocation(textureName), leafType)
+        event.addSprite(generated)

        logger.log(Level.DEBUG, "$logName: leaf texture   $textureName")
        logger.log(Level.DEBUG, "$logName:      particle $leafType")
    }

-    override fun resolveSprites(atlas: TextureMap) = LeafInfo(atlas[generated] ?: atlas.missingSprite, leafType)
+    override fun resolveSprites(atlas: AtlasTexture) = LeafInfo(atlas[generated] ?: missingSprite, leafType)
 }
--- a/src/main/kotlin/mods/betterfoliage/loader/BetterFoliageCore.kt
+++ b/src/main/kotlin/mods/betterfoliage/loader/BetterFoliageCore.kt
@@ -1,31 +1,23 @@
 package mods.betterfoliage.loader

-import mods.octarinecore.metaprog.Transformer
+//import mods.octarinecore.metaprog.Transformer
 import mods.octarinecore.metaprog.allAvailable
-import net.minecraftforge.fml.relauncher.FMLLaunchHandler
-import org.objectweb.asm.ClassWriter
 import org.objectweb.asm.ClassWriter.COMPUTE_FRAMES
 import org.objectweb.asm.ClassWriter.COMPUTE_MAXS
 import org.objectweb.asm.Opcodes.*

+/*
 class BetterFoliageTransformer : Transformer() {

    val isOptifinePresent = allAvailable(Refs.OptifineClassTransformer)

    init {
-        if (FMLLaunchHandler.side().isClient) setupClient()
-    }
-
-    fun setupClient() {
-        // where: WorldClient.showBarrierParticles(), right after invoking Block.randomDisplayTick
+        // where: WorldClient.animateTick(), replacing invocation to Block.animateTick
        // what: invoke BF code for every random display tick
-        // why: allows us to catch random display ticks, without touching block code
-        transformMethod(Refs.showBarrierParticles) {
-            find(invokeRef(Refs.randomDisplayTick))?.insertAfter {
+        // why: allows us to catch random display ticks
+        transformMethod(Refs.WC_animeteTick) {
+            find(invokeRef(Refs.B_animateTick))?.replace {
                log.info("[BetterFoliageLoader] Applying random display tick call hook")
-                varinsn(ALOAD, 0)
-                varinsn(ALOAD, 11)
-                varinsn(ALOAD, 7)
                invokeStatic(Refs.onRandomDisplayTick)
            } ?: log.warn("[BetterFoliageLoader] Failed to apply random display tick call hook!")
        }
@@ -58,9 +50,7 @@ class BetterFoliageTransformer : Transformer() {
        transformMethod(Refs.doesSideBlockRendering) {
            find(IRETURN)?.insertBefore {
                log.info("[BetterFoliageLoader] Applying doesSideBlockRendering() override")
-                varinsn(ALOAD, 1)
-                varinsn(ALOAD, 2)
-                varinsn(ALOAD, 3)
+                varinsn(ALOAD, 0)
                invokeStatic(Refs.doesSideBlockRenderingOverride)
            } ?: log.warn("[BetterFoliageLoader] Failed to apply doesSideBlockRendering() override!")
        }
@@ -76,11 +66,11 @@ class BetterFoliageTransformer : Transformer() {
            } ?: log.warn("[BetterFoliageLoader] Failed to apply isOpaqueCube() override!")
        }

-        // where: ModelLoader.setupModelRegistry(), right before the textures are loaded
-        // what: invoke handler code with ModelLoader instance
-        // why: allows us to iterate the unbaked models in ModelLoader in time to register textures
+        // where: ModelBakery.setupModelRegistry(), after all models are loaded
+        // what: invoke handler code with ModelBakery instance
+        // why: allows us to iterate the unbaked models in ModelBakery in time to register textures
        transformMethod(Refs.setupModelRegistry) {
-            find(invokeName("addAll"))?.insertAfter {
+            find(invokeName("newLinkedHashSet"))?.insertBefore {
                log.info("[BetterFoliageLoader] Applying ModelLoader lifecycle callback")
                varinsn(ALOAD, 0)
                invokeStatic(Refs.onAfterLoadModelDefinitions)
@@ -135,4 +125,6 @@ class BetterFoliageTransformer : Transformer() {
            } ?: log.warn("[BetterFoliageLoader] Failed to apply SVertexBuilder.pushEntity() block ID override!")
        }
    }
-}
+}
+
+ */
--- a/src/main/kotlin/mods/betterfoliage/loader/Refs.kt
+++ b/src/main/kotlin/mods/betterfoliage/loader/Refs.kt
@@ -3,11 +3,10 @@ package mods.betterfoliage.loader
 import mods.octarinecore.metaprog.ClassRef
 import mods.octarinecore.metaprog.FieldRef
 import mods.octarinecore.metaprog.MethodRef
-import net.minecraftforge.fml.relauncher.FMLInjectionData

 /** Singleton object holding references to foreign code elements. */
 object Refs {
-    val mcVersion = FMLInjectionData.data()[4].toString()
+//    val mcVersion = FMLInjectionData.data()[4].toString()

    // Java
    val String = ClassRef("java.lang.String")
@@ -16,102 +15,44 @@ object Refs {
    val Random = ClassRef("java.util.Random")

    // Minecraft
-    val IBlockAccess = ClassRef("net.minecraft.world.IBlockAccess")
-    val IBlockState = ClassRef("net.minecraft.block.state.IBlockState")
-    val BlockStateBase = ClassRef("net.minecraft.block.state.BlockStateBase")
+    val IBlockReader = ClassRef("net.minecraft.world.IBlockReader")
+    val IEnvironmentBlockReader = ClassRef("net.minecraft.world.IEnvironmentBlockReader")
+    val BlockState = ClassRef("net.minecraft.block.state.BlockState")
    val BlockPos = ClassRef("net.minecraft.util.math.BlockPos")
-    val MutableBlockPos = ClassRef("net.minecraft.util.math.BlockPos\$MutableBlockPos")
    val BlockRenderLayer = ClassRef("net.minecraft.util.BlockRenderLayer")
-    val EnumFacing = ClassRef("net.minecraft.util.EnumFacing")
-
-    val World = ClassRef("net.minecraft.world.World")
-    val WorldClient = ClassRef("net.minecraft.client.multiplayer.WorldClient")
-    val ChunkCache = ClassRef("net.minecraft.world.ChunkCache")
-    val showBarrierParticles = MethodRef(WorldClient, "showBarrierParticles", "func_184153_a", ClassRef.void, ClassRef.int, ClassRef.int, ClassRef.int, ClassRef.int, Random, ClassRef.boolean, MutableBlockPos)
-
    val Block = ClassRef("net.minecraft.block.Block")
-    val StateImplementation = ClassRef("net.minecraft.block.state.BlockStateContainer\$StateImplementation")
-    val canRenderInLayer = MethodRef(Block, "canRenderInLayer", ClassRef.boolean, IBlockState, BlockRenderLayer)
-    val getAmbientOcclusionLightValue = MethodRef(StateImplementation, "getAmbientOcclusionLightValue", "func_185892_j", ClassRef.float)
-    val useNeighborBrightness = MethodRef(StateImplementation, "useNeighborBrightness", "func_185916_f", ClassRef.boolean)
-    val doesSideBlockRendering = MethodRef(StateImplementation, "doesSideBlockRendering", ClassRef.boolean, IBlockAccess, BlockPos, EnumFacing)
-    val isOpaqueCube = MethodRef(StateImplementation, "isOpaqueCube", "func_185914_p", ClassRef.boolean)
-    val randomDisplayTick = MethodRef(Block, "randomDisplayTick", "func_180655_c", ClassRef.void, IBlockState, World, BlockPos, Random)
-
-    val BlockModelRenderer = ClassRef("net.minecraft.client.renderer.BlockModelRenderer")
-    val AmbientOcclusionFace = ClassRef("net.minecraft.client.renderer.BlockModelRenderer\$AmbientOcclusionFace")
-    val ChunkCompileTaskGenerator = ClassRef("net.minecraft.client.renderer.chunk.ChunkCompileTaskGenerator")
    val BufferBuilder = ClassRef("net.minecraft.client.renderer.BufferBuilder")
-    val AOF_constructor = MethodRef(AmbientOcclusionFace, "<init>", ClassRef.void, BlockModelRenderer)
-
-    val RenderChunk = ClassRef("net.minecraft.client.renderer.chunk.RenderChunk")
-    val rebuildChunk = MethodRef(RenderChunk, "rebuildChunk", "func_178581_b", ClassRef.void, ClassRef.float, ClassRef.float, ClassRef.float, ChunkCompileTaskGenerator)
-
    val BlockRendererDispatcher = ClassRef("net.minecraft.client.renderer.BlockRendererDispatcher")
-    val renderBlock = MethodRef(BlockRendererDispatcher, "renderBlock", "func_175018_a", ClassRef.boolean, IBlockState, BlockPos, IBlockAccess, BufferBuilder)
-
+    val ChunkCache = ClassRef("net.minecraft.client.renderer.chunk.ChunkRenderCache")
    val TextureAtlasSprite = ClassRef("net.minecraft.client.renderer.texture.TextureAtlasSprite")
-
-    val IRegistry = ClassRef("net.minecraft.util.registry.IRegistry")
-    val ModelLoader = ClassRef("net.minecraftforge.client.model.ModelLoader")
-    val stateModels = FieldRef(ModelLoader, "stateModels", Map)
-    val setupModelRegistry = MethodRef(ModelLoader, "setupModelRegistry", "func_177570_a", IRegistry)
-
-    val IModel = ClassRef("net.minecraftforge.client.model.IModel")
-    val ModelBlock = ClassRef("net.minecraft.client.renderer.block.model.ModelBlock")
    val ResourceLocation = ClassRef("net.minecraft.util.ResourceLocation")
-    val ModelResourceLocation = ClassRef("net.minecraft.client.renderer.block.model.ModelResourceLocation")
-    val VanillaModelWrapper = ClassRef("net.minecraftforge.client.model.ModelLoader\$VanillaModelWrapper")
-    val model_VMW = FieldRef(VanillaModelWrapper, "model", ModelBlock)
-    val location_VMW = FieldRef(VanillaModelWrapper, "location", ModelBlock)
-    val WeightedRandomModel = ClassRef("net.minecraftforge.client.model.ModelLoader\$WeightedRandomModel")
-    val models_WRM = FieldRef(WeightedRandomModel, "models", List)
-    val MultiModel = ClassRef("net.minecraftforge.client.model.MultiModel")
-    val base_MM = FieldRef(MultiModel, "base", IModel)
-    val MultipartModel = ClassRef("net.minecraftforge.client.model.ModelLoader\$MultipartModel")
-    val partModels_MPM = FieldRef(MultipartModel, "partModels", List)
-
-    val BakedQuad = ClassRef("net.minecraft.client.renderer.block.model.BakedQuad")
-
-    val resetChangedState = MethodRef(ClassRef("net.minecraftforge.common.config.Configuration"), "resetChangedState", ClassRef.void)
-
-
-    // Better Foliage
-    val BetterFoliageHooks = ClassRef("mods.betterfoliage.client.Hooks")
-    val getAmbientOcclusionLightValueOverride = MethodRef(BetterFoliageHooks, "getAmbientOcclusionLightValueOverride", ClassRef.float, ClassRef.float, IBlockState)
-    val useNeighborBrightnessOverride = MethodRef(BetterFoliageHooks, "getUseNeighborBrightnessOverride", ClassRef.boolean, ClassRef.boolean, IBlockState)
-    val doesSideBlockRenderingOverride = MethodRef(BetterFoliageHooks, "doesSideBlockRenderingOverride", ClassRef.boolean, ClassRef.boolean, IBlockAccess, BlockPos, EnumFacing)
-    val isOpaqueCubeOverride = MethodRef(BetterFoliageHooks, "isOpaqueCubeOverride", ClassRef.boolean, ClassRef.boolean, IBlockState)
-    val onRandomDisplayTick = MethodRef(BetterFoliageHooks, "onRandomDisplayTick", ClassRef.void, World, IBlockState, BlockPos)
-    val onAfterLoadModelDefinitions = MethodRef(BetterFoliageHooks, "onAfterLoadModelDefinitions", ClassRef.void, ModelLoader)
-    val onAfterBakeModels = MethodRef(BetterFoliageHooks, "onAfterBakeModels", ClassRef.void, Map)
-    val renderWorldBlock = MethodRef(BetterFoliageHooks, "renderWorldBlock", ClassRef.boolean, BlockRendererDispatcher, IBlockState, BlockPos, IBlockAccess, BufferBuilder, BlockRenderLayer)
-    val canRenderBlockInLayer = MethodRef(BetterFoliageHooks, "canRenderBlockInLayer", ClassRef.boolean, Block, IBlockState, BlockRenderLayer)

    // Optifine
    val OptifineClassTransformer = ClassRef("optifine.OptiFineClassTransformer")
    val OptifineChunkCache = ClassRef("net.optifine.override.ChunkCacheOF")
    val CCOFChunkCache = FieldRef(OptifineChunkCache, "chunkCache", ChunkCache)

-    val getBlockId = MethodRef(BlockStateBase, "getBlockId", ClassRef.int);
-    val getMetadata = MethodRef(BlockStateBase, "getMetadata", ClassRef.int);
+    val getBlockId = MethodRef(BlockState, "getBlockId", ClassRef.int);
+    val getMetadata = MethodRef(BlockState, "getMetadata", ClassRef.int);

    // Optifine
    val RenderEnv = ClassRef("net.optifine.render.RenderEnv")
-    val RenderEnv_reset = MethodRef(RenderEnv, "reset", ClassRef.void, IBlockAccess, IBlockState, BlockPos)
+    val RenderEnv_reset = MethodRef(RenderEnv, "reset", ClassRef.void, IBlockReader, BlockState, BlockPos)
    val quadSprite = FieldRef(BufferBuilder, "quadSprite", TextureAtlasSprite)
+    val BlockPosM = ClassRef("net.optifine.BlockPosM")
+    val IColorizer = ClassRef("net.optifine.CustomColors\$IColorizer")

    // Optifine: custom colors
    val CustomColors = ClassRef("net.optifine.CustomColors")
-    val getColorMultiplier = MethodRef(CustomColors, "getColorMultiplier", ClassRef.int, BakedQuad, IBlockState, IBlockAccess, BlockPos, RenderEnv)
+    val getColorMultiplier = MethodRef(CustomColors, "getSmoothColorMultiplier", ClassRef.int, BlockState, IEnvironmentBlockReader, BlockPos, IColorizer, BlockPosM)

    // Optifine: shaders
    val SVertexBuilder = ClassRef("net.optifine.shaders.SVertexBuilder")
    val sVertexBuilder = FieldRef(BufferBuilder, "sVertexBuilder", SVertexBuilder)
-    val pushEntity_state = MethodRef(SVertexBuilder, "pushEntity", ClassRef.void, IBlockState, BlockPos, IBlockAccess, BufferBuilder)
+    val pushEntity_state = MethodRef(SVertexBuilder, "pushEntity", ClassRef.void, BlockState, BlockPos, IBlockReader, BufferBuilder)
    val pushEntity_num = MethodRef(SVertexBuilder, "pushEntity", ClassRef.void, ClassRef.long)
    val popEntity = MethodRef(SVertexBuilder, "popEntity", ClassRef.void)

    val ShadersModIntegration = ClassRef("mods.betterfoliage.client.integration.ShadersModIntegration")
-    val getBlockIdOverride = MethodRef(ShadersModIntegration, "getBlockIdOverride", ClassRef.long, ClassRef.long, IBlockState)
+    val getBlockIdOverride = MethodRef(ShadersModIntegration, "getBlockIdOverride", ClassRef.long, ClassRef.long, BlockState)
 }