port to MC 1.9

2016-03-21 20:54:06 +01:00
parent 42c14790af
commit 6ee27c2a99
41 changed files with 208 additions and 216 deletions
--- a/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt
+++ b/src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt
@@ -24,7 +24,7 @@ object BetterFoliageMod {
    const val MOD_NAME = "Better Foliage"
    const val DOMAIN = "betterfoliage"
    const val LEGACY_DOMAIN = "bettergrassandleaves"
-    const val MC_VERSIONS = "[1.8.8,1.8.9]"
+    const val MC_VERSIONS = "[1.9]"
    const val GUI_FACTORY = "mods.betterfoliage.client.gui.ConfigGuiFactory"

    lateinit var log: Logger
--- a/src/main/kotlin/mods/betterfoliage/client/Client.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/Client.kt
@@ -71,6 +71,6 @@ object Client {
        OptifineCTM
    )

-    fun log(level: Level, msg: String) = BetterFoliageMod.log!!.log(level, msg)
+    fun log(level: Level, msg: String) = BetterFoliageMod.log.log(level, msg)
 }

--- a/src/main/kotlin/mods/betterfoliage/client/Hooks.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/Hooks.kt
@@ -13,13 +13,12 @@ import mods.octarinecore.common.plus
 import net.minecraft.block.Block
 import net.minecraft.block.state.IBlockState
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
 import net.minecraft.init.Blocks
-import net.minecraft.util.BlockPos
+import net.minecraft.util.BlockRenderLayer
+import net.minecraft.util.BlockRenderLayer.*
 import net.minecraft.util.EnumFacing
-import net.minecraft.util.EnumWorldBlockLayer
-import net.minecraft.util.EnumWorldBlockLayer.CUTOUT
-import net.minecraft.util.EnumWorldBlockLayer.CUTOUT_MIPPED
+import net.minecraft.util.math.BlockPos
 import net.minecraft.world.IBlockAccess
 import net.minecraft.world.World
 import net.minecraftforge.client.model.ModelLoader
@@ -28,16 +27,16 @@ import net.minecraftforge.fml.relauncher.Side
 import net.minecraftforge.fml.relauncher.SideOnly

 fun shouldRenderBlockSideOverride(original: Boolean, blockAccess: IBlockAccess, pos: BlockPos, side: EnumFacing): Boolean {
-    return original || (Config.enabled && Config.roundLogs.enabled && Config.blocks.logs.matchesID(blockAccess.getBlockState(pos).block));
+    return original && !(Config.enabled && Config.roundLogs.enabled && Config.blocks.logs.matchesID(blockAccess.getBlockState(pos).block));
 }

-fun getAmbientOcclusionLightValueOverride(original: Float, block: Block): Float {
-    if (Config.enabled && Config.roundLogs.enabled && Config.blocks.logs.matchesID(block)) return Config.roundLogs.dimming;
+fun getAmbientOcclusionLightValueOverride(original: Float, state: IBlockState): Float {
+    if (Config.enabled && Config.roundLogs.enabled && Config.blocks.logs.matchesID(state.block)) return Config.roundLogs.dimming;
    return original;
 }

-fun getUseNeighborBrightnessOverride(original: Boolean, block: Block): Boolean {
-    return original || (Config.enabled && Config.roundLogs.enabled && Config.blocks.logs.matchesID(block));
+fun getUseNeighborBrightnessOverride(original: Boolean, state: IBlockState): Boolean {
+    return original || (Config.enabled && Config.roundLogs.enabled && Config.blocks.logs.matchesID(state.block));
 }

 fun onRandomDisplayTick(world: World, state: IBlockState, pos: BlockPos) {
@@ -66,13 +65,14 @@ fun renderWorldBlock(dispatcher: BlockRendererDispatcher,
                     state: IBlockState,
                     pos: BlockPos,
                     blockAccess: IBlockAccess,
-                     worldRenderer: WorldRenderer,
-                     layer: EnumWorldBlockLayer
+                     worldRenderer: VertexBuffer,
+                     layer: BlockRenderLayer
 ): Boolean {
    val isCutout = layer == CUTOUT_MIPPED || layer == CUTOUT
    val needsCutout = state.block.canRenderInLayer(CUTOUT_MIPPED) || state.block.canRenderInLayer(CUTOUT)
    val canRender = (isCutout && needsCutout) || state.block.canRenderInLayer(layer)

+
    blockContext.let { ctx ->
        ctx.set(blockAccess, pos)
        Client.renderers.forEach { renderer ->
@@ -88,7 +88,7 @@ fun renderWorldBlock(dispatcher: BlockRendererDispatcher,
    return if (canRender) dispatcher.renderBlock(state, pos, blockAccess, worldRenderer) else false
 }

-fun canRenderBlockInLayer(block: Block, layer: EnumWorldBlockLayer): Boolean {
+fun canRenderBlockInLayer(block: Block, layer: BlockRenderLayer): Boolean {
    if (layer == CUTOUT_MIPPED && !block.canRenderInLayer(CUTOUT)) {
        return true
    }
--- a/src/main/kotlin/mods/betterfoliage/client/config/Config.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/config/Config.kt
@@ -3,7 +3,6 @@ package mods.betterfoliage.client.config
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.client.gui.BiomeListConfigEntry
 import mods.octarinecore.common.config.*
-import mods.octarinecore.metaprog.reflectField
 import net.minecraft.client.Minecraft
 import net.minecraft.world.biome.BiomeGenBase
 import net.minecraftforge.fml.client.event.ConfigChangedEvent
@@ -14,7 +13,10 @@ import net.minecraftforge.fml.relauncher.SideOnly
 private fun featureEnable() = boolean(true).lang("enabled")
 private fun distanceLimit() = int(min=1, max=1000, default=1000).lang("distance")
 fun biomeList(defaults: (BiomeGenBase) -> Boolean) = intList {
-    BiomeGenBase.getBiomeGenArray().filter { it != null && defaults(it) }.map { it.biomeID }.toTypedArray()
+    BiomeGenBase.biomeRegistry
+        .filter { it != null && defaults(it) }
+        .map { BiomeGenBase.biomeRegistry.getIDForObject(it) }
+        .toTypedArray()
 }.apply { guiClass = BiomeListConfigEntry::class.java }

 // Biome filter methods
--- a/src/main/kotlin/mods/betterfoliage/client/gui/BiomeListConfigEntry.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/gui/BiomeListConfigEntry.kt
@@ -13,7 +13,7 @@ class BiomeListConfigEntry(
    configElement: IConfigElement)
 : IdListConfigEntry<BiomeGenBase>(owningScreen, owningEntryList, configElement) {

-    override val baseSet: List<BiomeGenBase> get() = BiomeGenBase.getBiomeGenArray().filterNotNull()
-    override val BiomeGenBase.itemId: Int get() = this.biomeID
+    override val baseSet: List<BiomeGenBase> get() = BiomeGenBase.biomeRegistry.filterNotNull()
+    override val BiomeGenBase.itemId: Int get() = BiomeGenBase.biomeRegistry.getIDForObject(this)
    override val BiomeGenBase.itemName: String get() = this.biomeName
 }
--- a/src/main/kotlin/mods/betterfoliage/client/integration/OptifineCTM.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/OptifineCTM.kt
@@ -5,12 +5,11 @@ import mods.betterfoliage.loader.Refs
 import mods.octarinecore.ThreadLocalDelegate
 import mods.octarinecore.client.render.BlockContext
 import mods.octarinecore.metaprog.allAvailable
-import net.minecraft.block.Block
 import net.minecraft.block.state.BlockStateBase
 import net.minecraft.block.state.IBlockState
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.util.BlockPos
 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
--- a/src/main/kotlin/mods/betterfoliage/client/integration/ShadersModIntegration.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/integration/ShadersModIntegration.kt
@@ -7,7 +7,7 @@ import mods.octarinecore.metaprog.allAvailable
 import net.minecraft.block.Block
 import net.minecraft.block.BlockTallGrass
 import net.minecraft.block.state.IBlockState
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
 import net.minecraft.init.Blocks
 import net.minecraftforge.fml.relauncher.Side
 import net.minecraftforge.fml.relauncher.SideOnly
@@ -25,7 +25,7 @@ object ShadersModIntegration {

    fun entityDataFor(blockState: IBlockState) =
        (Block.blockRegistry.getIDForObject(blockState.block).toLong() and 65535) or
-        ((blockState.block.renderType.toLong() and 65535) shl 16) or
+        ((blockState.renderType.ordinal.toLong() and 65535) shl 16) or
        (blockState.block.getMetaFromState(blockState).toLong() shl 32)


@@ -47,7 +47,7 @@ object ShadersModIntegration {
    }

    /** Quads rendered inside this block will behave as tallgrass blocks in shader programs. */
-    inline fun grass(renderer: WorldRenderer, enabled: Boolean = true, func: ()->Unit) {
+    inline fun grass(renderer: VertexBuffer, enabled: Boolean = true, func: ()->Unit) {
        if ((isPresent && enabled)) {
            val vertexBuilder = Refs.sVertexBuilder.get(renderer)!!
            Refs.pushEntity_num.invoke(vertexBuilder, tallGrassEntityData)
@@ -59,7 +59,7 @@ object ShadersModIntegration {
    }

    /** Quads rendered inside this block will behave as leaf blocks in shader programs. */
-    inline fun leaves(renderer: WorldRenderer, enabled: Boolean = true, func: ()->Unit) {
+    inline fun leaves(renderer: VertexBuffer, enabled: Boolean = true, func: ()->Unit) {
        if ((isPresent && enabled)) {
            val vertexBuilder = Refs.sVertexBuilder.get(renderer)!!
            Refs.pushEntity_num.invoke(vertexBuilder, leavesEntityData.toLong())
--- a/src/main/kotlin/mods/betterfoliage/client/render/AbstractRenderColumn.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/AbstractRenderColumn.kt
@@ -11,12 +11,12 @@ import mods.octarinecore.common.face
 import mods.octarinecore.common.rot
 import net.minecraft.block.state.IBlockState
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
 import net.minecraft.client.renderer.texture.TextureMap
+import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing
 import net.minecraft.util.EnumFacing.*
-import net.minecraft.util.EnumWorldBlockLayer

 data class ColumnInfo(val topTexture: TextureAtlasSprite,
                      val bottomTexture: TextureAtlasSprite,
@@ -125,7 +125,7 @@ abstract class AbstractRenderColumn(modId: String) : AbstractBlockRenderingHandl
    abstract val downTexture: (ShadingContext, Int, Quad)->TextureAtlasSprite?

    @Suppress("NON_EXHAUSTIVE_WHEN")
-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        if (ctx.isSurroundedBy(surroundPredicate) ) return false

        // get AO data
@@ -324,7 +324,7 @@ abstract class AbstractRenderColumn(modId: String) : AbstractBlockRenderingHandl
        val offsetRot = offset.rotate(rotation)
        val state = blockState(offsetRot)
        return if (!blockPredicate(state)) {
-            if (state.block.isOpaqueCube) SOLID else NONSOLID
+            if (state.isOpaqueCube) SOLID else NONSOLID
        } else {
            axisFunc(state)?.let { if (it == axis) PARALLEL else PERPENDICULAR } ?: SOLID
        }
--- a/src/main/kotlin/mods/betterfoliage/client/render/EntityFallingLeavesFX.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/EntityFallingLeavesFX.kt
@@ -9,14 +9,13 @@ import mods.octarinecore.common.Double3
 import mods.octarinecore.minmax
 import mods.octarinecore.random
 import net.minecraft.client.Minecraft
-import net.minecraft.client.renderer.WorldRenderer
-import net.minecraft.util.BlockPos
-import net.minecraft.util.EnumFacing.*
-import net.minecraft.util.MathHelper
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.EnumFacing.DOWN
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.MathHelper
 import net.minecraft.world.World
 import net.minecraftforge.common.MinecraftForge
 import net.minecraftforge.event.world.WorldEvent
-import net.minecraftforge.fml.common.FMLCommonHandler
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
 import net.minecraftforge.fml.common.gameevent.TickEvent
 import net.minecraftforge.fml.relauncher.Side
@@ -35,31 +34,31 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble(), pos.z.toDouble
    var particleRot = rand.nextInt(64)
    var rotPositive = true
    val isMirrored = (rand.nextInt() and 1) == 1
-    var wasOnGround = false
+    var wasCollided = false

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

        val state = world.getBlockState(pos)
        LeafRegistry[state, world, pos, DOWN]?.let {
-            particleIcon = it.particleTextures[rand.nextInt(1024)]
-            calculateParticleColor(it.averageColor, state.block.colorMultiplier(world, pos))
+            particleTexture = it.particleTextures[rand.nextInt(1024)]
+            calculateParticleColor(it.averageColor, Minecraft.getMinecraft().blockColors.colorMultiplier(state, world, pos, 0))
        }
    }

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

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

-        if (onGround || wasOnGround) {
+        if (isCollided || wasCollided) {
            velocity.setTo(0.0, 0.0, 0.0)
-            if (!wasOnGround) {
+            if (!wasCollided) {
                particleAge = Math.max(particleAge, particleMaxAge - 20)
-                wasOnGround = true
+                wasCollided = true
            }
        } else {
            velocity.setTo(cos[particleRot], 0.0, sin[particleRot]).mul(Config.fallingLeaves.perturb)
@@ -68,7 +67,7 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble(), pos.z.toDouble
        }
    }

-    override fun render(worldRenderer: WorldRenderer, partialTickTime: Float) {
+    override fun render(worldRenderer: VertexBuffer, partialTickTime: Float) {
        if (Config.fallingLeaves.opacityHack) GL11.glDepthMask(true)
        renderParticleQuad(worldRenderer, partialTickTime, rotation = particleRot, isMirrored = isMirrored)
    }
--- a/src/main/kotlin/mods/betterfoliage/client/render/EntityRisingSoulFX.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/EntityRisingSoulFX.kt
@@ -7,9 +7,9 @@ import mods.octarinecore.client.render.AbstractEntityFX
 import mods.octarinecore.client.resource.ResourceHandler
 import mods.octarinecore.common.Double3
 import mods.octarinecore.forEachPairIndexed
-import net.minecraft.client.renderer.WorldRenderer
-import net.minecraft.util.BlockPos
-import net.minecraft.util.MathHelper
+import net.minecraft.client.renderer.VertexBuffer
+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
@@ -23,9 +23,9 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.to
    val initialPhase = rand.nextInt(64)

    init {
-        motionY = 0.1
+        ySpeed = 0.1
        particleGravity = 0.0f
-        particleIcon = RisingSoulTextures.headIcons[rand.nextInt(256)]
+        particleTexture = RisingSoulTextures.headIcons[rand.nextInt(256)]
        particleMaxAge = MathHelper.floor_double((0.6 + 0.4 * rand.nextDouble()) * Config.risingSoul.lifetime * 20.0)
    }

@@ -38,10 +38,10 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.to
        particleTrail.addFirst(currentPos.copy())
        while (particleTrail.size > Config.risingSoul.trailLength) particleTrail.removeLast()

-        if (!Config.enabled) setDead()
+        if (!Config.enabled) setExpired()
    }

-    override fun render(worldRenderer: WorldRenderer, partialTickTime: Float) {
+    override fun render(worldRenderer: VertexBuffer, partialTickTime: Float) {
        var alpha = Config.risingSoul.opacity
        if (particleAge > particleMaxAge - 40) alpha *= (particleMaxAge - particleAge) / 40.0f

--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderAlgae.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderAlgae.kt
@@ -9,8 +9,8 @@ import mods.octarinecore.common.Int3
 import mods.octarinecore.common.Rotation
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
-import net.minecraft.util.EnumWorldBlockLayer
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.BlockRenderLayer
 import org.apache.logging.log4j.Level.INFO

 class RenderAlgae : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
@@ -27,13 +27,13 @@ class RenderAlgae : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.algae.enabled &&
        ctx.cameraDistance < Config.algae.distance &&
-        ctx.block(up2).material == Material.water &&
-        ctx.block(up1).material == Material.water &&
+        ctx.blockState(up2).material == Material.water &&
+        ctx.blockState(up1).material == Material.water &&
        Config.blocks.dirt.matchesID(ctx.block) &&
        ctx.biomeId in Config.algae.biomes &&
        noise[ctx.pos] < Config.algae.population

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        renderWorldBlockBase(ctx, dispatcher, renderer, null)
        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
@@ -4,13 +4,12 @@ import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.config.Config
 import mods.octarinecore.client.render.*
-import mods.octarinecore.client.resource.BlockTextureInspector
 import mods.octarinecore.common.Int3
 import mods.octarinecore.common.Rotation
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing.*
-import net.minecraft.util.EnumWorldBlockLayer
 import org.apache.logging.log4j.Level

 class RenderCactus : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
@@ -63,7 +62,7 @@ class RenderCactus : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        ctx.cameraDistance < Config.cactus.distance &&
        Config.blocks.cactus.matchesID(ctx.block)

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        // get AO data
        modelRenderer.updateShading(Int3.zero, allFaces)
        val icons = iconBase[ctx.blockState(Int3.zero)] ?: return renderWorldBlockBase(ctx, dispatcher, renderer, null)
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrass.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrass.kt
@@ -7,17 +7,17 @@ import mods.octarinecore.client.render.BlockContext
 import mods.octarinecore.client.render.withOffset
 import mods.octarinecore.common.Int3
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
-import net.minecraft.util.EnumWorldBlockLayer
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.BlockRenderLayer

 class RenderConnectedGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.connectedGrass.enabled &&
        Config.blocks.dirt.matchesID(ctx.block) &&
        Config.blocks.grass.matchesID(ctx.block(up1)) &&
-        (Config.connectedGrass.snowEnabled || !ctx.block(up2).isSnow)
+        (Config.connectedGrass.snowEnabled || !ctx.blockState(up2).isSnow)

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        return ctx.withOffset(Int3.zero, up1) {
            ctx.withOffset(up1, up2) {
                renderWorldBlockBase(ctx, dispatcher, renderer, null)
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrassLog.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderConnectedGrassLog.kt
@@ -8,9 +8,9 @@ import mods.octarinecore.client.render.withOffset
 import mods.octarinecore.common.Int3
 import mods.octarinecore.common.offset
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing.*
-import net.minecraft.util.EnumWorldBlockLayer

 class RenderConnectedGrassLog : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {

@@ -21,7 +21,7 @@ class RenderConnectedGrassLog : AbstractBlockRenderingHandler(BetterFoliageMod.M
        Config.blocks.dirt.matchesID(ctx.block) &&
        Config.blocks.logs.matchesID(ctx.block(up1))

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        val grassDir = grassCheckDirs.find {
            Config.blocks.grass.matchesID(ctx.block(it.offset))
        }
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderCoral.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderCoral.kt
@@ -10,10 +10,10 @@ import mods.octarinecore.common.forgeDirs
 import mods.octarinecore.random
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing.Axis
 import net.minecraft.util.EnumFacing.UP
-import net.minecraft.util.EnumWorldBlockLayer
 import org.apache.logging.log4j.Level.INFO

 class RenderCoral : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
@@ -45,18 +45,18 @@ class RenderCoral : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.coral.enabled &&
        ctx.cameraDistance < Config.coral.distance &&
-        ctx.block(up2).material == Material.water &&
-        ctx.block(up1).material == Material.water &&
+        ctx.blockState(up2).material == Material.water &&
+        ctx.blockState(up1).material == Material.water &&
        Config.blocks.sand.matchesID(ctx.block) &&
        ctx.biomeId in Config.coral.biomes &&
        noise[ctx.pos] < Config.coral.population

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        renderWorldBlockBase(ctx, dispatcher, renderer, null)
        modelRenderer.updateShading(Int3.zero, allFaces)

        forgeDirs.forEachIndexed { idx, face ->
-            if (!ctx.block(forgeDirOffsets[idx]).isOpaqueCube && blockContext.random(idx) < Config.coral.chance) {
+            if (!ctx.blockState(forgeDirOffsets[idx]).isOpaqueCube && 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
@@ -11,12 +11,11 @@ import mods.octarinecore.common.Double3
 import mods.octarinecore.common.Int3
 import mods.octarinecore.common.Rotation
 import mods.octarinecore.random
-import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing.Axis
 import net.minecraft.util.EnumFacing.UP
-import net.minecraft.util.EnumWorldBlockLayer
 import org.apache.logging.log4j.Level.INFO

 class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
@@ -50,15 +49,15 @@ class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        (Config.shortGrass.grassEnabled || Config.connectedGrass.enabled) &&
        Config.blocks.grass.matchesID(ctx.block)

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        val isConnected = ctx.block(down1).let { Config.blocks.dirt.matchesID(it) || Config.blocks.grass.matchesID(it) }
-        val isSnowed = ctx.block(up1).isSnow
+        val isSnowed = ctx.blockState(up1).isSnow
        val connectedGrass = isConnected && Config.connectedGrass.enabled && (!isSnowed || Config.connectedGrass.snowEnabled)

        val grassInfo = GrassRegistry[ctx.blockState(Int3.zero)] ?: return renderWorldBlockBase(ctx, dispatcher, renderer, layer)
        val grassTopTexture = OptifineCTM.override(grassInfo.grassTopTexture, ctx, UP)

-        val blockColor = ctx.blockData(Int3.zero, 0).color
+        val blockColor = ctx.blockData(Int3.zero).color

        if (connectedGrass) {
            // get full AO data
@@ -86,7 +85,7 @@ class RenderGrass : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {

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

        // render grass quads
        val iconset = if (isSnowed) snowedIcons else normalIcons
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderLeaves.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderLeaves.kt
@@ -2,7 +2,6 @@ package mods.betterfoliage.client.render

 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.integration.OptifineCTM
 import mods.betterfoliage.client.integration.ShadersModIntegration
 import mods.betterfoliage.client.texture.LeafRegistry
 import mods.octarinecore.PI2
@@ -14,10 +13,10 @@ import mods.octarinecore.common.vec
 import mods.octarinecore.random
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
-import net.minecraft.util.EnumFacing
-import net.minecraft.util.EnumFacing.*
-import net.minecraft.util.EnumWorldBlockLayer
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.BlockRenderLayer
+import net.minecraft.util.EnumFacing.DOWN
+import net.minecraft.util.EnumFacing.UP
 import java.lang.Math.cos
 import java.lang.Math.sin

@@ -44,13 +43,13 @@ class RenderLeaves : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        ctx.cameraDistance < Config.leaves.distance &&
        Config.blocks.leaves.matchesID(ctx.block)

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
-        val isSnowed = ctx.block(up1).material.let {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
+        val isSnowed = ctx.blockState(up1).material.let {
            it == Material.snow || it == Material.craftedSnow
        }
        renderWorldBlockBase(ctx, dispatcher, renderer, null)
        val leafInfo = LeafRegistry[ctx, DOWN] ?: return false
-        val blockColor = ctx.blockData(Int3.zero, 0).color
+        val blockColor = ctx.blockData(Int3.zero).color

        modelRenderer.updateShading(Int3.zero, allFaces)
        ShadersModIntegration.leaves(renderer) {
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderLilypad.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderLilypad.kt
@@ -8,10 +8,10 @@ import mods.octarinecore.client.render.*
 import mods.octarinecore.common.Int3
 import mods.octarinecore.common.Rotation
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing.DOWN
 import net.minecraft.util.EnumFacing.UP
-import net.minecraft.util.EnumWorldBlockLayer
 import org.apache.logging.log4j.Level

 class RenderLilypad : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
@@ -41,7 +41,7 @@ class RenderLilypad : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        ctx.cameraDistance < Config.lilypad.distance &&
        Config.blocks.lilypad.matchesID(ctx.block)

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        renderWorldBlockBase(ctx, dispatcher, renderer, null)
        modelRenderer.updateShading(Int3.zero, allFaces)

--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderLog.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderLog.kt
@@ -41,7 +41,7 @@ class RenderLog : AbstractRenderColumn(BetterFoliageMod.MOD_ID) {
    }

    override val blockPredicate = { state: IBlockState -> Config.blocks.logs.matchesID(state.block) }
-    override val surroundPredicate = { state: IBlockState -> state.block.isOpaqueCube && !Config.blocks.logs.matchesID(state.block) }
+    override val surroundPredicate = { state: IBlockState -> state.isOpaqueCube && !Config.blocks.logs.matchesID(state.block) }

    override val connectPerpendicular: Boolean get() = Config.roundLogs.connectPerpendicular
    override val connectSolids: Boolean get() = Config.roundLogs.connectSolids
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderMycelium.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderMycelium.kt
@@ -9,11 +9,10 @@ import mods.octarinecore.client.render.modelRenderer
 import mods.octarinecore.client.render.noPost
 import mods.octarinecore.common.Double3
 import mods.octarinecore.common.Rotation
-import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
 import net.minecraft.init.Blocks
-import net.minecraft.util.EnumWorldBlockLayer
+import net.minecraft.util.BlockRenderLayer
 import org.apache.logging.log4j.Level.INFO

 class RenderMycelium : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
@@ -31,13 +30,13 @@ class RenderMycelium : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
        ctx.cameraDistance < Config.shortGrass.distance
    }

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
-        val isSnowed = ctx.block(up1).isSnow
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
+        val isSnowed = ctx.blockState(up1).isSnow

        renderWorldBlockBase(ctx, dispatcher, renderer, null)

        if (isSnowed && !Config.shortGrass.snowEnabled) return true
-        if (ctx.block(up1).isOpaqueCube) return true
+        if (ctx.blockState(up1).isOpaqueCube) 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
@@ -8,9 +8,9 @@ import mods.octarinecore.common.Int3
 import mods.octarinecore.common.Rotation
 import mods.octarinecore.random
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
 import net.minecraft.init.Blocks
-import net.minecraft.util.EnumWorldBlockLayer
+import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing.*
 import org.apache.logging.log4j.Level.INFO

@@ -36,9 +36,9 @@ class RenderNetherrack : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID)
        ctx.cameraDistance < Config.netherrack.distance
    }

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        renderWorldBlockBase(ctx, dispatcher, renderer, null)
-        if (ctx.block(down1).isOpaqueCube) return true
+        if (ctx.blockState(down1).isOpaqueCube) return true
        modelRenderer.updateShading(Int3.zero, allFaces)

        val rand = ctx.semiRandomArray(2)
--- a/src/main/kotlin/mods/betterfoliage/client/render/RenderReeds.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/render/RenderReeds.kt
@@ -10,9 +10,9 @@ import mods.octarinecore.common.Rotation
 import mods.octarinecore.random
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.BlockRendererDispatcher
-import net.minecraft.client.renderer.WorldRenderer
+import net.minecraft.client.renderer.VertexBuffer
+import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing.UP
-import net.minecraft.util.EnumWorldBlockLayer
 import org.apache.logging.log4j.Level

 class RenderReeds : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
@@ -44,13 +44,13 @@ class RenderReeds : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
    override fun isEligible(ctx: BlockContext) =
        Config.enabled && Config.reed.enabled &&
        ctx.cameraDistance < Config.reed.distance &&
-        ctx.block(up2).material == Material.air &&
-        ctx.block(up1).material == Material.water &&
+        ctx.blockState(up2).material == Material.air &&
+        ctx.blockState(up1).material == Material.water &&
        Config.blocks.dirt.matchesID(ctx.block) &&
        ctx.biomeId in Config.reed.biomes &&
        noise[ctx.pos] < Config.reed.population

-    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: WorldRenderer, layer: EnumWorldBlockLayer): Boolean {
+    override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
        renderWorldBlockBase(ctx, dispatcher, renderer, null)
        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
@@ -9,6 +9,7 @@ import mods.octarinecore.common.Rotation
 import mods.octarinecore.common.times
 import net.minecraft.block.Block
 import net.minecraft.block.material.Material
+import net.minecraft.block.state.IBlockState
 import net.minecraft.util.EnumFacing
 import net.minecraft.util.EnumFacing.*

@@ -23,7 +24,7 @@ val denseLeavesRot = arrayOf(Rotation.identity, Rotation.rot90[EAST.ordinal], Ro
 val whitewash: RenderVertex.(ShadingContext, Int, Quad, Int, Vertex)->Unit = { ctx, qi, q, vi, v -> setGrey(1.4f) }
 val greywash: RenderVertex.(ShadingContext, Int, Quad, Int, Vertex)->Unit = { ctx, qi, q, vi, v -> setGrey(1.0f) }

-val Block.isSnow: Boolean get() = material.let { it == Material.snow || it == Material.craftedSnow }
+val IBlockState.isSnow: Boolean get() = material.let { it == Material.snow || it == Material.craftedSnow }

 fun Quad.toCross(rotAxis: EnumFacing, trans: (Quad)->Quad) =
    (0..3).map { rotIdx ->
--- a/src/main/kotlin/mods/betterfoliage/client/texture/LeafRegistry.kt
+++ b/src/main/kotlin/mods/betterfoliage/client/texture/LeafRegistry.kt
@@ -11,13 +11,10 @@ import mods.octarinecore.common.Int3
 import net.minecraft.block.state.IBlockState
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
 import net.minecraft.client.renderer.texture.TextureMap
-import net.minecraft.util.BlockPos
 import net.minecraft.util.EnumFacing
 import net.minecraft.util.ResourceLocation
+import net.minecraft.util.math.BlockPos
 import net.minecraft.world.IBlockAccess
-import net.minecraftforge.client.event.TextureStitchEvent
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
 import net.minecraftforge.fml.relauncher.Side
 import net.minecraftforge.fml.relauncher.SideOnly
 import org.apache.logging.log4j.Level.INFO
--- a/src/main/kotlin/mods/betterfoliage/loader/BetterFoliageCore.kt
+++ b/src/main/kotlin/mods/betterfoliage/loader/BetterFoliageCore.kt
@@ -24,54 +24,54 @@ class BetterFoliageTransformer : Transformer() {
    }

    fun setupClient() {
-        // where: WorldClient.doVoidFogParticles(), right before the end of the loop
+        // where: WorldClient.showBarrierParticles(), right after invoking Block.randomDisplayTick
        // what: invoke BF code for every random display tick
        // why: allows us to catch random display ticks, without touching block code
-        transformMethod(Refs.doVoidFogParticles) {
+        transformMethod(Refs.showBarrierParticles) {
            find(invokeRef(Refs.randomDisplayTick))?.insertAfter {
                log.info("Applying random display tick call hook")
                varinsn(ALOAD, 0)
-                varinsn(ALOAD, 13)
-                varinsn(ALOAD, 8)
+                varinsn(ALOAD, 11)
+                varinsn(ALOAD, 7)
                invokeStatic(Refs.onRandomDisplayTick)
            } ?: log.warn("Failed to apply random display tick call hook!")
        }

-        // where: Block.getAmbientOcclusionLightValue()
+        // where: BlockStateContainer$StateImplementation.getAmbientOcclusionLightValue()
        // what: invoke BF code to overrule AO transparency value
        // why: allows us to have light behave properly on non-solid log blocks without
        //      messing with isOpaqueBlock(), which could have gameplay effects
        transformMethod(Refs.getAmbientOcclusionLightValue) {
            find(FRETURN)?.insertBefore {
-                log.info("Applying Block.getAmbientOcclusionLightValue() override")
+                log.info("Applying getAmbientOcclusionLightValue() override")
                varinsn(ALOAD, 0)
                invokeStatic(Refs.getAmbientOcclusionLightValueOverride)
-            } ?: log.warn("Failed to apply Block.getAmbientOcclusionLightValue() override!")
+            } ?: log.warn("Failed to apply getAmbientOcclusionLightValue() override!")
        }

-        // where: Block.getUseNeighborBrightness()
+        // where: BlockStateContainer$StateImplementation.useNeighborBrightness()
        // what: invoke BF code to overrule _useNeighborBrightness_
        // why: allows us to have light behave properly on non-solid log blocks
-        transformMethod(Refs.getUseNeighborBrightness) {
+        transformMethod(Refs.useNeighborBrightness) {
            find(IRETURN)?.insertBefore {
-                log.info("Applying Block.getUseNeighborBrightness() override")
+                log.info("Applying useNeighborBrightness() override")
                varinsn(ALOAD, 0)
-                invokeStatic(Refs.getUseNeighborBrightnessOverride)
-            } ?: log.warn("Failed to apply Block.getUseNeighborBrightness() override!")
+                invokeStatic(Refs.useNeighborBrightnessOverride)
+            } ?: log.warn("Failed to apply useNeighborBrightness() override!")
        }

-        // where: Block.shouldSideBeRendered()
+        // where: BlockStateContainer$StateImplementation.doesSideBlockRendering()
        // what: invoke BF code to overrule condition
        // why: allows us to make log blocks non-solid without
        //      messing with isOpaqueBlock(), which could have gameplay effects
-        transformMethod(Refs.shouldSideBeRendered) {
+        transformMethod(Refs.doesSideBlockRendering) {
            find(IRETURN)?.insertBefore {
-                log.info("Applying Block.shouldSideBeRendered() override")
+                log.info("Applying doesSideBlockRendering() override")
                varinsn(ALOAD, 1)
                varinsn(ALOAD, 2)
                varinsn(ALOAD, 3)
                invokeStatic(Refs.shouldRenderBlockSideOverride)
-            } ?: log.warn("Failed to apply Block.shouldSideBeRendered() override!")
+            } ?: log.warn("Failed to apply doesSideBlockRendering() override!")
        }

        // where: ModelLoader.setupModelRegistry(), right before the textures are loaded
@@ -82,7 +82,7 @@ class BetterFoliageTransformer : Transformer() {
                log.info("Applying ModelLoader lifecycle callback")
                varinsn(ALOAD, 0)
                invokeStatic(Refs.onAfterLoadModelDefinitions)
-            }
+            } ?: log.warn("Failed to apply ModelLoader lifecycle callback!")
        }

        // where: RenderChunk.rebuildChunk()
--- a/src/main/kotlin/mods/betterfoliage/loader/Refs.kt
+++ b/src/main/kotlin/mods/betterfoliage/loader/Refs.kt
@@ -15,50 +15,49 @@ object Refs {
    val Random = ClassRef("java.util.Random")

    // Minecraft
-    val IBlockAccess = ClassRef("net.minecraft.world.IBlockAccess", "adq")
-    val IBlockState = ClassRef("net.minecraft.block.state.IBlockState", "alz")
-    val BlockStateBase = ClassRef("net.minecraft.block.state.BlockStateBase", "aly")
-    val BlockPos = ClassRef("net.minecraft.util.BlockPos", "cj")
-    val EnumWorldBlockLayer = ClassRef("net.minecraft.util.EnumWorldBlockLayer", "adf")
+    val IBlockAccess = ClassRef("net.minecraft.world.IBlockAccess", "ahx")
+    val IBlockState = ClassRef("net.minecraft.block.state.IBlockState", "arc")
+    val BlockStateBase = ClassRef("net.minecraft.block.state.BlockStateBase", "ara")
+    val BlockPos = ClassRef("net.minecraft.util.math.BlockPos", "cj")
+    val MutableBlockPos = ClassRef("net.minecraft.util.math.BlockPos\$MutableBlockPos", "cj\$a")
+    val BlockRenderLayer = ClassRef("net.minecraft.util.BlockRenderLayer", "ahm")
    val EnumFacing = ClassRef("net.minecraft.util.EnumFacing", "cq")

-    val World = ClassRef("net.minecraft.world.World", "adm")
-    val WorldClient = ClassRef("net.minecraft.client.multiplayer.WorldClient", "bdb")
-    val doVoidFogParticles = MethodRef(WorldClient, "doVoidFogParticles", "func_73029_E", "b", ClassRef.void, ClassRef.int, ClassRef.int, ClassRef.int)
+    val World = ClassRef("net.minecraft.world.World", "aht")
+    val WorldClient = ClassRef("net.minecraft.client.multiplayer.WorldClient", "bku")
+    val showBarrierParticles = MethodRef(WorldClient, "showBarrierParticles", "func_184153_a", "a", ClassRef.void, ClassRef.int, ClassRef.int, ClassRef.int, ClassRef.int, Random, ClassRef.boolean, MutableBlockPos)

-    val Block = ClassRef("net.minecraft.block.Block", "afh")
-    val canRenderInLayer = MethodRef(Block, "canRenderInLayer", ClassRef.boolean, EnumWorldBlockLayer)
-    val getAmbientOcclusionLightValue = MethodRef(Block, "getAmbientOcclusionLightValue", "func_149685_I", "f", ClassRef.float)
-    val getUseNeighborBrightness = MethodRef(Block, "getUseNeighborBrightness", "func_149710_n", "q", ClassRef.boolean)
-    val shouldSideBeRendered = MethodRef(Block, "shouldSideBeRendered", "func_149646_a", "a", ClassRef.boolean, IBlockAccess, BlockPos, EnumFacing)
+    val Block = ClassRef("net.minecraft.block.Block", "ajt")
+    val StateImplementation = ClassRef("net.minecraft.block.state.BlockStateContainer\$StateImplementation", "ard\$a")
+    val canRenderInLayer = MethodRef(Block, "canRenderInLayer", ClassRef.boolean, BlockRenderLayer)
+    val getAmbientOcclusionLightValue = MethodRef(StateImplementation, "getAmbientOcclusionLightValue", "func_185892_j", "j", ClassRef.float)
+    val useNeighborBrightness = MethodRef(StateImplementation, "useNeighborBrightness", "func_185916_f", "f", ClassRef.boolean)
+    val shouldSideBeRendered = MethodRef(StateImplementation, "shouldSideBeRendered", "func_185894_c", "c", ClassRef.boolean, IBlockAccess, BlockPos, EnumFacing)
+    val doesSideBlockRendering = MethodRef(StateImplementation, "doesSideBlockRendering", ClassRef.boolean, IBlockAccess, BlockPos, EnumFacing)
    val randomDisplayTick = MethodRef(Block, "randomDisplayTick", "func_180655_c", "c", ClassRef.void, World, BlockPos, IBlockState, Random)

-    val BlockModelRenderer = ClassRef("net.minecraft.client.renderer.BlockModelRenderer", "bgf")
-    val AmbientOcclusionFace = ClassRef("net.minecraft.client.renderer.BlockModelRenderer\$AmbientOcclusionFace", "bgf\$b")
-    val ChunkCompileTaskGenerator = ClassRef("net.minecraft.client.renderer.chunk.ChunkCompileTaskGenerator", "bhn")
-    val WorldRenderer = ClassRef("net.minecraft.client.renderer.WorldRenderer", "bfd")
+    val BlockModelRenderer = ClassRef("net.minecraft.client.renderer.BlockModelRenderer", "boe")
+    val AmbientOcclusionFace = ClassRef("net.minecraft.client.renderer.BlockModelRenderer\$AmbientOcclusionFace", "boe\$b")
+    val ChunkCompileTaskGenerator = ClassRef("net.minecraft.client.renderer.chunk.ChunkCompileTaskGenerator", "bpz")
+    val VertexBuffer = ClassRef("net.minecraft.client.renderer.VertexBuffer", "bmz")
    val AOF_constructor = MethodRef(AmbientOcclusionFace, "<init>", ClassRef.void, BlockModelRenderer)

-    val RenderChunk = ClassRef("net.minecraft.client.renderer.chunk.RenderChunk", "bht")
+    val RenderChunk = ClassRef("net.minecraft.client.renderer.chunk.RenderChunk", "bqf")
    val rebuildChunk = MethodRef(RenderChunk, "rebuildChunk", "func_178581_b", "b", ClassRef.void, ClassRef.float, ClassRef.float, ClassRef.float, ChunkCompileTaskGenerator)

-    val BlockRendererDispatcher = ClassRef("net.minecraft.client.renderer.BlockRendererDispatcher", "bgd")
-    val renderBlock = MethodRef(BlockRendererDispatcher, "renderBlock", "func_175018_a", "a", ClassRef.boolean, IBlockState, BlockPos, IBlockAccess, WorldRenderer)
+    val BlockRendererDispatcher = ClassRef("net.minecraft.client.renderer.BlockRendererDispatcher", "boc")
+    val renderBlock = MethodRef(BlockRendererDispatcher, "renderBlock", "func_175018_a", "a", ClassRef.boolean, IBlockState, BlockPos, IBlockAccess, VertexBuffer)

-    //    val IMetadataSerializer = ClassRef("net.minecraft.client.resources.data.IMetadataSerializer", "brw")
-    //    val SimpleReloadableResourceManager = ClassRef("net.minecraft.client.resources.SimpleReloadableResourceManager", "brg")
-    //    val metadataSerializer = FieldRef(SimpleReloadableResourceManager, "rmMetadataSerializer", "field_110547_c", "f", IMetadataSerializer)
+    val TextureAtlasSprite = ClassRef("net.minecraft.client.renderer.texture.TextureAtlasSprite", "bvh")

-    val TextureAtlasSprite = ClassRef("net.minecraft.client.renderer.texture.TextureAtlasSprite", "bmi")
-
-    val IRegistry = ClassRef("net.minecraft.util.IRegistry", "db")
+    val IRegistry = ClassRef("net.minecraft.util.registry.IRegistry", "db")
    val ModelLoader = ClassRef("net.minecraftforge.client.model.ModelLoader")
    val stateModels = FieldRef(ModelLoader, "stateModels", Map)
    val setupModelRegistry = MethodRef(ModelLoader, "setupModelRegistry", "func_177570_a", "a", IRegistry)

-    val IModel = ClassRef("net.minecraftforge.client.model.IModel", "")
-    val ModelBlock = ClassRef("net.minecraft.client.renderer.block.model.ModelBlock", "bgl")
-    val ModelResourceLocation = ClassRef("net.minecraft.client.renderer.block.model.ModelResourceLocation", "bov")
+    val IModel = ClassRef("net.minecraftforge.client.model.IModel")
+    val ModelBlock = ClassRef("net.minecraft.client.renderer.block.model.ModelBlock", "bok")
+    val ModelResourceLocation = ClassRef("net.minecraft.client.renderer.block.model.ModelResourceLocation", "bxt")
    val VanillaModelWrapper = ClassRef("net.minecraftforge.client.model.ModelLoader\$VanillaModelWrapper")
    val model_VMW = FieldRef(VanillaModelWrapper, "model", ModelBlock)
    val location_VMW = FieldRef(VanillaModelWrapper, "location", ModelBlock)
@@ -69,13 +68,13 @@ object Refs {

    // Better Foliage
    val BetterFoliageHooks = ClassRef("mods.betterfoliage.client.Hooks")
-    val getAmbientOcclusionLightValueOverride = MethodRef(BetterFoliageHooks, "getAmbientOcclusionLightValueOverride", ClassRef.float, ClassRef.float, Block)
-    val getUseNeighborBrightnessOverride = MethodRef(BetterFoliageHooks, "getUseNeighborBrightnessOverride", ClassRef.boolean, ClassRef.boolean, Block)
+    val getAmbientOcclusionLightValueOverride = MethodRef(BetterFoliageHooks, "getAmbientOcclusionLightValueOverride", ClassRef.float, ClassRef.float, IBlockState)
+    val useNeighborBrightnessOverride = MethodRef(BetterFoliageHooks, "getUseNeighborBrightnessOverride", ClassRef.boolean, ClassRef.boolean, IBlockState)
    val shouldRenderBlockSideOverride = MethodRef(BetterFoliageHooks, "shouldRenderBlockSideOverride", ClassRef.boolean, ClassRef.boolean, IBlockAccess, BlockPos, EnumFacing)
    val onRandomDisplayTick = MethodRef(BetterFoliageHooks, "onRandomDisplayTick", ClassRef.void, World, IBlockState, BlockPos)
    val onAfterLoadModelDefinitions = MethodRef(BetterFoliageHooks, "onAfterLoadModelDefinitions", ClassRef.void, ModelLoader)
-    val renderWorldBlock = MethodRef(BetterFoliageHooks, "renderWorldBlock", ClassRef.boolean, BlockRendererDispatcher, IBlockState, BlockPos, IBlockAccess, WorldRenderer, EnumWorldBlockLayer)
-    val canRenderBlockInLayer = MethodRef(BetterFoliageHooks, "canRenderBlockInLayer", ClassRef.boolean, Block, EnumWorldBlockLayer)
+    val renderWorldBlock = MethodRef(BetterFoliageHooks, "renderWorldBlock", ClassRef.boolean, BlockRendererDispatcher, IBlockState, BlockPos, IBlockAccess, VertexBuffer, BlockRenderLayer)
+    val canRenderBlockInLayer = MethodRef(BetterFoliageHooks, "canRenderBlockInLayer", ClassRef.boolean, Block, BlockRenderLayer)

    // Optifine
    val OptifineClassTransformer = ClassRef("optifine.OptiFineClassTransformer")
@@ -94,8 +93,8 @@ object Refs {

    // ShadersMod
    val SVertexBuilder = ClassRef("shadersmod.client.SVertexBuilder")
-    val sVertexBuilder = FieldRef(WorldRenderer, "sVertexBuilder", SVertexBuilder)
-    val pushEntity_state = MethodRef(SVertexBuilder, "pushEntity", ClassRef.void, IBlockState, BlockPos, IBlockAccess, WorldRenderer)
+    val sVertexBuilder = FieldRef(VertexBuffer, "sVertexBuilder", SVertexBuilder)
+    val pushEntity_state = MethodRef(SVertexBuilder, "pushEntity", ClassRef.void, IBlockState, BlockPos, IBlockAccess, VertexBuffer)
    val pushEntity_num = MethodRef(SVertexBuilder, "pushEntity", ClassRef.void, ClassRef.long)
    val popEntity = MethodRef(SVertexBuilder, "popEntity", ClassRef.void)