[WIP] start port to 1.15.2

2021-04-29 11:33:23 +02:00
parent f1fa629c5c
commit b46fdeaeef
44 changed files with 442 additions and 468 deletions
--- a/src/main/kotlin/mods/betterfoliage/render/AbstractParticle.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/AbstractParticle.kt
@@ -2,15 +2,15 @@ package mods.betterfoliage.render

 import mods.betterfoliage.util.Double3
 import net.minecraft.client.MinecraftClient
-import net.minecraft.client.particle.ParticleTextureSheet
 import net.minecraft.client.particle.SpriteBillboardParticle
-import net.minecraft.client.render.BufferBuilder
 import net.minecraft.client.render.Camera
+import net.minecraft.client.render.VertexConsumer
 import net.minecraft.client.texture.Sprite
+import net.minecraft.client.util.math.Vector3f
+import net.minecraft.util.math.MathHelper
 import net.minecraft.world.World
-import kotlin.math.cos
-import kotlin.math.sin

+fun VertexConsumer.vertex(v: Double3) = vertex(v.x, v.y, v.z)

 abstract class AbstractParticle(world: World, x: Double, y: Double, z: Double) : SpriteBillboardParticle(world, x, y, z) {

@@ -34,9 +34,6 @@ abstract class AbstractParticle(world: World, x: Double, y: Double, z: Double) :
        velocityX = velocity.x; velocityY = velocity.y; velocityZ = velocity.z;
    }

-    /** Render the particle. */
-    abstract fun render(worldRenderer: BufferBuilder, partialTickTime: Float)
-
    /** Update particle on world tick. */
    abstract fun update()

@@ -46,81 +43,57 @@ abstract class AbstractParticle(world: World, x: Double, y: Double, z: Double) :
    /** Add the particle to the effect renderer if it is valid. */
    fun addIfValid() { if (isValid) MinecraftClient.getInstance().particleManager.addParticle(this) }

-    override fun buildGeometry(buffer: BufferBuilder, camera: Camera, tickDelta: Float, rotX: Float, rotZ: Float, rotYZ: Float, rotXY: Float, rotXZ: Float) {
-        billboardRot.first.setTo(rotX + rotXY, rotZ, rotYZ + rotXZ)
-        billboardRot.second.setTo(rotX - rotXY, -rotZ, rotYZ - rotXZ)
-        render(buffer, tickDelta)
+    override fun buildGeometry(vertexConsumer: VertexConsumer, camera: Camera, tickDelta: Float) {
+        renderParticleQuad(vertexConsumer, camera, tickDelta)
    }

    /**
     * Render a particle quad.
     *
     * @param[tessellator] the [Tessellator] instance to use
-     * @param[partialTickTime] partial tick time
+     * @param[tickDelta] partial tick time
     * @param[currentPos] render position
     * @param[prevPos] previous tick position for interpolation
     * @param[size] particle size
-     * @param[rotation] viewpoint-dependent particle rotation (64 steps)
+     * @param[currentAngle] viewpoint-dependent particle rotation (64 steps)
     * @param[sprite] particle texture
     * @param[isMirrored] mirror particle texture along V-axis
     * @param[alpha] aplha blending
     */
-    fun renderParticleQuad(worldRenderer: BufferBuilder,
-                           partialTickTime: Float,
+    fun renderParticleQuad(vertexConsumer: VertexConsumer,
+                           camera: Camera,
+                           tickDelta: Float,
                           currentPos: Double3 = this.currentPos,
                           prevPos: Double3 = this.prevPos,
                           size: Double = scale.toDouble(),
-                           rotation: Double = 0.0,
+                           currentAngle: Float = this.angle,
+                           prevAngle: Float = this.prevAngle,
                           sprite: Sprite = this.sprite,
-                           isMirrored: Boolean = false,
                           alpha: Float = this.colorAlpha) {

-        val minU = (if (isMirrored) sprite.minU else sprite.maxU).toDouble()
-        val maxU = (if (isMirrored) sprite.maxU else sprite.minU).toDouble()
-        val minV = sprite.minV.toDouble()
-        val maxV = sprite.maxV.toDouble()
+        val center = Double3.lerp(tickDelta.toDouble(), prevPos, currentPos)
+        val angle = MathHelper.lerp(tickDelta, prevAngle, currentAngle)
+        val rotation = camera.rotation.copy().apply { hamiltonProduct(Vector3f.POSITIVE_Z.getRadialQuaternion(angle)) }
+        val lightmapCoord = getColorMultiplier(tickDelta)

-        val center = currentPos.copy().sub(prevPos).mul(partialTickTime.toDouble()).add(prevPos).sub(cameraX, cameraY, cameraZ)
+        val coords = arrayOf(
+            Double3(-1.0, -1.0, 0.0),
+            Double3(-1.0, 1.0, 0.0),
+            Double3(1.0, 1.0, 0.0),
+            Double3(1.0, -1.0, 0.0)
+        ).map { it.rotate(rotation).mul(size).add(center).sub(camera.pos.x, camera.pos.y, camera.pos.z) }

-        val cosRotation = cos(rotation); val sinRotation = sin(rotation)
-        val v1 = Double3.weight(billboardRot.first, cosRotation * size, billboardRot.second, sinRotation * size)
-        val v2 = Double3.weight(billboardRot.first, -sinRotation * size, billboardRot.second, cosRotation * size)
-
-        val renderBrightness = this.getColorMultiplier(partialTickTime)
-        val brHigh = renderBrightness shr 16 and 65535
-        val brLow = renderBrightness and 65535
-
-        worldRenderer
-            .vertex(center.x - v1.x, center.y - v1.y, center.z - v1.z)
-            .texture(maxU, maxV)
-            .color(colorRed, colorGreen, colorBlue, alpha)
-            .texture(brHigh, brLow)
+        fun renderVertex(vertex: Double3, u: Float, v: Float) = vertexConsumer
+            .vertex(vertex.x, vertex.y, vertex.z).texture(u, v)
+            .color(colorRed, colorGreen, colorBlue, alpha).light(lightmapCoord)
            .next()

-        worldRenderer
-            .vertex(center.x - v2.x, center.y - v2.y, center.z - v2.z)
-            .texture(maxU, minV)
-            .color(colorRed, colorGreen, colorBlue, alpha)
-            .texture(brHigh, brLow)
-            .next()
-
-        worldRenderer
-            .vertex(center.x + v1.x, center.y + v1.y, center.z + v1.z)
-            .texture(minU, minV)
-            .color(colorRed, colorGreen, colorBlue, alpha)
-            .texture(brHigh, brLow)
-            .next()
-
-        worldRenderer
-            .vertex(center.x + v2.x, center.y + v2.y, center.z + v2.z)
-            .texture(minU, maxV)
-            .color(colorRed, colorGreen, colorBlue, alpha)
-            .texture(brHigh, brLow)
-            .next()
+        renderVertex(coords[0], sprite.maxU, sprite.maxV)
+        renderVertex(coords[1], sprite.maxU, sprite.minV)
+        renderVertex(coords[2], sprite.minU, sprite.minV)
+        renderVertex(coords[3], sprite.minU, sprite.maxV)
    }

-    override fun getType() = ParticleTextureSheet.PARTICLE_SHEET_OPAQUE
-
    fun setColor(color: Int) {
        colorBlue = (color and 255) / 256.0f
        colorGreen = ((color shr 8) and 255) / 256.0f
--- a/src/main/kotlin/mods/betterfoliage/render/Misc.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/Misc.kt
@@ -4,9 +4,9 @@ import net.minecraft.block.Blocks
 import net.minecraft.block.Material
 import net.minecraft.world.biome.Biome

-val DIRT_BLOCKS = listOf(Blocks.DIRT, Blocks.COARSE_DIRT)
+val DIRT_BLOCKS = listOf(Blocks.DIRT, Blocks.COARSE_DIRT, Blocks.PODZOL)
 val SAND_BLOCKS = listOf(Blocks.SAND, Blocks.RED_SAND)

 val SALTWATER_BIOMES = listOf(Biome.Category.BEACH, Biome.Category.OCEAN)

-val SNOW_MATERIALS = listOf(Material.SNOW, Material.SNOW_BLOCK)
+val SNOW_MATERIALS = listOf(Material.SNOW_BLOCK)
--- a/src/main/kotlin/mods/betterfoliage/render/ShadersModIntegration.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/ShadersModIntegration.kt
@@ -4,11 +4,10 @@ import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.render.lighting.getBufferBuilder
 import mods.betterfoliage.util.getAllMethods
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
-import net.minecraft.block.BlockRenderLayer
-import net.minecraft.block.BlockRenderLayer.CUTOUT_MIPPED
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.client.render.BufferBuilder
+import net.minecraft.client.render.RenderLayer

 /**
 * Integration for ShadersMod.
@@ -32,7 +31,7 @@ object ShadersModIntegration {
    }

    /** Quads rendered inside this block will use the given block entity data in shader programs. */
-    inline fun renderAs(ctx: RenderContext, state: BlockState, layer: BlockRenderLayer, enabled: Boolean = true, func: ()->Unit) {
+    inline fun renderAs(ctx: RenderContext, state: BlockState, layer: RenderLayer, enabled: Boolean = true, func: ()->Unit) {
        if (isAvailable && enabled) {
            val sVertexBuilder = BufferBuilder_SVertexBuilder!!.get(ctx.getBufferBuilder(layer))
            val aliasBlockId = BlockAliases_getAliasBlockId!!.invoke(null, state)
@@ -46,9 +45,9 @@ object ShadersModIntegration {

    /** Quads rendered inside this block will behave as tallgrass blocks in shader programs. */
    inline fun grass(ctx: RenderContext, enabled: Boolean = true, func: ()->Unit) =
-        renderAs(ctx, defaultGrass, CUTOUT_MIPPED, enabled, func)
+        renderAs(ctx, defaultGrass, RenderLayer.getCutoutMipped(), enabled, func)

    /** Quads rendered inside this block will behave as leaf blocks in shader programs. */
    inline fun leaves(ctx: RenderContext, enabled: Boolean = true, func: ()->Unit) =
-        renderAs(ctx, defaultLeaves, CUTOUT_MIPPED, enabled, func)
+        renderAs(ctx, defaultLeaves, RenderLayer.getCutoutMipped(), enabled, func)
 }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Cactus.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Cactus.kt
@@ -1,13 +1,31 @@
 package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.lighting.grassTuftLighting
 import mods.betterfoliage.render.lighting.roundLeafLighting
+import mods.betterfoliage.render.lighting.withLighting
+import mods.betterfoliage.resource.discovery.BlockRenderKey
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelTextureList
+import mods.betterfoliage.resource.discovery.SimpleBlockMatcher
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.SpriteDelegate
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.WrappedBakedModel
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.crossModelsRaw
+import mods.betterfoliage.model.crossModelsTextured
+import mods.betterfoliage.model.meshifyStandard
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
 import mods.betterfoliage.util.Atlas
-import mods.betterfoliage.resource.discovery.*
-import mods.betterfoliage.resource.model.*
-import mods.betterfoliage.util.*
+import mods.betterfoliage.util.LazyMap
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.horizontalDirections
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.randomI
 import net.fabricmc.fabric.api.renderer.v1.model.FabricBakedModel
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
 import net.minecraft.block.BlockState
@@ -16,8 +34,8 @@ import net.minecraft.client.render.model.BakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.DOWN
-import net.minecraft.world.ExtendedBlockView
-import java.util.*
+import net.minecraft.world.BlockRenderView
+import java.util.Random
 import java.util.function.Consumer
 import java.util.function.Supplier

@@ -33,9 +51,8 @@ object StandardCactusDiscovery : ConfigurableModelDiscovery() {
    override val matchClasses = SimpleBlockMatcher(CactusBlock::class.java)
    override val modelTextures = listOf(ModelTextureList("block/cactus", "top", "bottom", "side"))

-    override fun processModel(state: BlockState, textures: List<String>, atlas: Consumer<Identifier>): BlockRenderKey? {
-        val sprites = textures.map { Identifier(it) }
-        return CactusModel.Key(sprites[0], sprites[1], sprites[2])
+    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: Consumer<Identifier>): BlockRenderKey? {
+        return CactusModel.Key(textures[0], textures[1], textures[2])
    }
 }

@@ -46,7 +63,7 @@ class CactusModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wrapped
    val armLighting = horizontalDirections.map { grassTuftLighting(it) }
    val crossLighting = roundLeafLighting()

-    override fun emitBlockQuads(blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
+    override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
        (wrapped as FabricBakedModel).emitBlockQuads(blockView, state, pos, randomSupplier, context)
        if (!BetterFoliage.config.enabled || !BetterFoliage.config.cactus.enabled) return

--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt
@@ -14,18 +14,17 @@ import mods.betterfoliage.resource.discovery.BlockRenderKey
 import mods.betterfoliage.resource.discovery.ModelDiscoveryBase
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.resource.generated.CenteredSprite
-import mods.betterfoliage.resource.model.*
+import mods.betterfoliage.model.*
 import mods.betterfoliage.util.*
+import net.fabricmc.fabric.api.renderer.v1.material.BlendMode
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
-import net.minecraft.block.BlockRenderLayer
 import net.minecraft.block.BlockState
 import net.minecraft.block.Material
-import net.minecraft.client.MinecraftClient
 import net.minecraft.client.render.model.BakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.UP
-import net.minecraft.world.ExtendedBlockView
+import net.minecraft.world.BlockRenderView
 import java.util.*
 import java.util.function.Consumer
 import java.util.function.Supplier
@@ -46,7 +45,7 @@ class DirtModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
    val algaeLighting = grassTuftLighting(UP)
    val reedLighting = reedLighting()

-    override fun emitBlockQuads(blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
+    override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
        if (!BetterFoliage.config.enabled) return super.emitBlockQuads(blockView, state, pos, randomSupplier, context)

        val ctx = BasicBlockCtx(blockView, pos)
@@ -56,7 +55,7 @@ class DirtModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
        val isWater = stateUp.material == Material.WATER
        val isDeepWater = isWater && ctx.offset(Int3(2 to UP)).state.material == Material.WATER
        val isShallowWater = isWater && ctx.offset(Int3(2 to UP)).state.isAir
-        val isSaltWater = isWater && ctx.biome.category in SALTWATER_BIOMES
+        val isSaltWater = isWater && ctx.biome?.category in SALTWATER_BIOMES

        if (BetterFoliage.config.connectedGrass.enabled && keyUp is GrassKey) {
            val grassBaseModel = (ctx.model(UP) as WrappedBakedModel).wrapped
@@ -93,14 +92,14 @@ class DirtModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
            val shapes = BetterFoliage.config.algae.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
            tuftModelSet(shapes, Color.white.asInt) { algaeSprites[randomI()] }
                .withOpposites()
-                .build(BlockRenderLayer.CUTOUT_MIPPED, flatLighting = false)
+                .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)

        }
        val reedModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
            val shapes = BetterFoliage.config.reed.let { tuftShapeSet(2.0, it.heightMin, it.heightMax, it.hOffset) }
            tuftModelSet(shapes, Color.white.asInt) { reedSprites[randomI()] }
                .withOpposites()
-                .build(BlockRenderLayer.CUTOUT_MIPPED, flatLighting = false)
+                .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)
        }
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt
@@ -4,22 +4,20 @@ import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.chunk.BasicBlockCtx
 import mods.betterfoliage.render.SNOW_MATERIALS
 import mods.betterfoliage.render.ShadersModIntegration
-import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.lighting.grassTuftLighting
-import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.resource.discovery.*
-import mods.betterfoliage.resource.model.*
+import mods.betterfoliage.model.*
 import mods.betterfoliage.util.*
+import net.fabricmc.fabric.api.renderer.v1.material.BlendMode
 import net.fabricmc.fabric.api.renderer.v1.model.FabricBakedModel
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
-import net.minecraft.block.BlockRenderLayer
 import net.minecraft.block.BlockState
 import net.minecraft.client.render.model.BakedModel
-import net.minecraft.tag.BlockTags
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.*
-import net.minecraft.world.ExtendedBlockView
+import net.minecraft.world.BlockRenderView
 import java.util.*
 import java.util.function.Consumer
 import java.util.function.Supplier
@@ -41,8 +39,8 @@ object StandardGrassDiscovery : ConfigurableModelDiscovery() {
    override val matchClasses: ConfigurableBlockMatcher get() = BetterFoliage.blockConfig.grassBlocks
    override val modelTextures: List<ModelTextureList> get() = BetterFoliage.blockConfig.grassModels.modelList

-    override fun processModel(state: BlockState, textures: List<String>, atlas: Consumer<Identifier>): BlockRenderKey? {
-        val grassId = Identifier(textures[0])
+    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: Consumer<Identifier>): BlockRenderKey? {
+        val grassId = textures[0]
        log(" block state $state")
        log("       texture $grassId")
        return GrassBlockModel.Key(grassId, getAndLogColorOverride(grassId, Atlas.BLOCKS, BetterFoliage.config.shortGrass.saturationThreshold))
@@ -57,7 +55,7 @@ class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wra

    val tuftLighting = grassTuftLighting(UP)

-    override fun emitBlockQuads(blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
+    override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
        if (!BetterFoliage.config.enabled) return super.emitBlockQuads(blockView, state, pos, randomSupplier, context)

        val ctx = BasicBlockCtx(blockView, pos)
@@ -67,8 +65,7 @@ class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wra
        val isSnowed = stateAbove.material in SNOW_MATERIALS
        val connected = BetterFoliage.config.connectedGrass.enabled &&
            (!isSnowed || BetterFoliage.config.connectedGrass.snowEnabled) && (
-                BlockTags.DIRT_LIKE.contains(stateBelow.block) ||
-                BetterFoliage.modelReplacer.getTyped<GrassKey>(stateBelow) != null
+                BetterFoliage.modelReplacer[stateBelow].let { it is DirtKey || it is GrassKey }
            )

        val random = randomSupplier.get()
@@ -107,12 +104,12 @@ class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wra
        val grassTuftMeshesNormal = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
            tuftModelSet(grassTuftShapes[key], key.overrideColor) { idx -> grassTuftSpritesNormal[randomI()] }
                .withOpposites()
-                .build(BlockRenderLayer.CUTOUT_MIPPED, flatLighting = false)
+                .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)
        }
        val grassTuftMeshesSnowed = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
            tuftModelSet(grassTuftShapes[key], Color.white.asInt) { idx -> grassTuftSpritesSnowed[randomI()] }
                .withOpposites()
-                .build(BlockRenderLayer.CUTOUT_MIPPED, flatLighting = false)
+                .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)
        }
        val grassFullBlockMeshes = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
            Array(64) { fullCubeTextured(key.grassTopTexture, key.overrideColor) }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Leaf.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Leaf.kt
@@ -1,33 +1,26 @@
 package mods.betterfoliage.render.block.vanilla

-import it.unimi.dsi.fastutil.ints.Int2ObjectFunction
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.chunk.BasicBlockCtx
 import mods.betterfoliage.render.SNOW_MATERIALS
 import mods.betterfoliage.render.ShadersModIntegration
-import mods.betterfoliage.render.lighting.getBufferBuilder
 import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.lighting.roundLeafLighting
 import mods.betterfoliage.render.particle.LeafParticleRegistry
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.resource.discovery.*
 import mods.betterfoliage.resource.generated.GeneratedLeafSprite
-import mods.betterfoliage.resource.model.*
+import mods.betterfoliage.model.*
 import mods.betterfoliage.util.*
+import net.fabricmc.fabric.api.renderer.v1.material.BlendMode
 import net.fabricmc.fabric.api.renderer.v1.model.FabricBakedModel
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
-import net.fabricmc.fabric.impl.client.indigo.renderer.accessor.AccessBufferBuilder
-import net.fabricmc.fabric.impl.client.indigo.renderer.render.BlockRenderInfo
-import net.fabricmc.fabric.impl.client.indigo.renderer.render.TerrainMeshConsumer
-import net.fabricmc.fabric.impl.client.indigo.renderer.render.TerrainRenderContext
-import net.minecraft.block.BlockRenderLayer
-import net.minecraft.block.BlockRenderLayer.CUTOUT_MIPPED
 import net.minecraft.block.BlockState
 import net.minecraft.client.render.model.BakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.*
-import net.minecraft.world.ExtendedBlockView
+import net.minecraft.world.BlockRenderView
 import java.util.*
 import java.util.function.Consumer
 import java.util.function.Supplier
@@ -47,8 +40,8 @@ object StandardLeafDiscovery : ConfigurableModelDiscovery() {
    override val matchClasses: ConfigurableBlockMatcher get() = BetterFoliage.blockConfig.leafBlocks
    override val modelTextures: List<ModelTextureList> get() = BetterFoliage.blockConfig.leafModels.modelList

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

 }

@@ -84,7 +77,7 @@ class NormalLeavesModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(w
    val leafSnowed by leafModelsSnowed.delegate(key)
    val leafLighting = roundLeafLighting()

-    override fun emitBlockQuads(blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
+    override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
        ShadersModIntegration.leaves(context, BetterFoliage.config.leaves.shaderWind) {
            super.emitBlockQuads(blockView, state, pos, randomSupplier, context)
            if (!BetterFoliage.config.enabled || !BetterFoliage.config.leaves.enabled) return
@@ -106,7 +99,7 @@ class NormalLeavesModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(w
        override val leafType: String,
        override val overrideColor: Int?
    ) : LeafKey {
-        override fun replace(model: BakedModel, state: BlockState) = NormalLeavesModel(this, meshifyStandard(model, state, renderLayerOverride = CUTOUT_MIPPED))
+        override fun replace(model: BakedModel, state: BlockState) = NormalLeavesModel(this, meshifyStandard(model, state, blendModeOverride = BlendMode.CUTOUT_MIPPED))
    }

    companion object {
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Lilypad.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Lilypad.kt
@@ -2,16 +2,20 @@ package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.render.ShadersModIntegration
-import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.resource.discovery.BlockRenderKey
 import mods.betterfoliage.resource.discovery.ModelDiscoveryBase
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
-import mods.betterfoliage.resource.discovery.RenderKeyFactory
-import mods.betterfoliage.resource.model.*
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.WrappedBakedModel
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.meshifyStandard
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.get
-import mods.betterfoliage.util.semiRandom
-import net.fabricmc.fabric.api.renderer.v1.model.FabricBakedModel
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
@@ -19,8 +23,8 @@ import net.minecraft.client.render.model.BakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.DOWN
-import net.minecraft.world.ExtendedBlockView
-import java.util.*
+import net.minecraft.world.BlockRenderView
+import java.util.Random
 import java.util.function.Consumer
 import java.util.function.Supplier

@@ -35,7 +39,7 @@ object LilyPadDiscovery : ModelDiscoveryBase() {
 }

 class LilypadModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
-    override fun emitBlockQuads(blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
+    override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
        super.emitBlockQuads(blockView, state, pos, randomSupplier, context)
        if (!BetterFoliage.config.enabled || !BetterFoliage.config.lilypad.enabled) return

--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt
@@ -2,15 +2,24 @@ package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.render.ShadersModIntegration
-import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.lighting.grassTuftLighting
-import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.resource.discovery.BlockRenderKey
 import mods.betterfoliage.resource.discovery.ModelDiscoveryBase
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
-import mods.betterfoliage.resource.discovery.RenderKeyFactory
-import mods.betterfoliage.resource.model.*
-import mods.betterfoliage.util.*
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.WrappedBakedModel
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.meshifyStandard
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.offset
+import mods.betterfoliage.util.plus
+import mods.betterfoliage.util.randomI
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
@@ -18,8 +27,8 @@ import net.minecraft.client.render.model.BakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.UP
-import net.minecraft.world.ExtendedBlockView
-import java.util.*
+import net.minecraft.world.BlockRenderView
+import java.util.Random
 import java.util.function.Consumer
 import java.util.function.Supplier

@@ -38,7 +47,7 @@ class MyceliumModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {

    val tuftLighting = grassTuftLighting(UP)

-    override fun emitBlockQuads(blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
+    override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
        super.emitBlockQuads(blockView, state, pos, randomSupplier, context)

        val random = randomSupplier.get()
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt
@@ -1,24 +1,22 @@
 package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.lighting.grassTuftLighting
-import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.resource.discovery.BlockRenderKey
 import mods.betterfoliage.resource.discovery.ModelDiscoveryBase
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
-import mods.betterfoliage.resource.discovery.RenderKeyFactory
-import mods.betterfoliage.resource.model.*
+import mods.betterfoliage.model.*
 import mods.betterfoliage.util.*
+import net.fabricmc.fabric.api.renderer.v1.material.BlendMode
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
-import net.minecraft.block.BlockRenderLayer
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.client.render.model.BakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.DOWN
-import net.minecraft.world.ExtendedBlockView
+import net.minecraft.world.BlockRenderView
 import java.util.*
 import java.util.function.Consumer
 import java.util.function.Supplier
@@ -38,7 +36,7 @@ class NetherrackModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {

    val tuftLighting = grassTuftLighting(DOWN)

-    override fun emitBlockQuads(blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
+    override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
        super.emitBlockQuads(blockView, state, pos, randomSupplier, context)
        if (BetterFoliage.config.enabled &&
            BetterFoliage.config.netherrack.enabled &&
@@ -60,7 +58,7 @@ class NetherrackModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
            tuftModelSet(shapes, Color.white.asInt) { netherrackTuftSprites[randomI()] }
                .transform { rotate(Rotation.fromUp[DOWN.ordinal]).rotateUV(2) }
                .withOpposites()
-                .build(BlockRenderLayer.CUTOUT_MIPPED, flatLighting = false)
+                .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)
        }
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt
@@ -4,14 +4,13 @@ import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.render.column.*
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.resource.discovery.*
-import mods.betterfoliage.resource.model.meshifyStandard
+import mods.betterfoliage.model.meshifyStandard
 import mods.betterfoliage.util.LazyMap
 import mods.betterfoliage.util.get
 import mods.betterfoliage.util.tryDefault
 import net.minecraft.block.BlockState
 import net.minecraft.block.LogBlock
 import net.minecraft.client.render.model.BakedModel
-import net.minecraft.client.texture.SpriteAtlasTexture
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.Direction.Axis
 import java.util.function.Consumer
@@ -28,10 +27,10 @@ object StandardLogDiscovery : ConfigurableModelDiscovery() {
    override val matchClasses: ConfigurableBlockMatcher get() = BetterFoliage.blockConfig.logBlocks
    override val modelTextures: List<ModelTextureList> get() = BetterFoliage.blockConfig.logModels.modelList

-    override fun processModel(state: BlockState, textures: List<String>, atlas: Consumer<Identifier>): BlockRenderKey? {
+    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: Consumer<Identifier>): BlockRenderKey? {
        val axis = getAxis(state)
        log("       axis $axis")
-        return RoundLogModel.Key(axis, Identifier(textures[0]), Identifier(textures[1]))
+        return RoundLogModel.Key(axis, textures[0], textures[1])
    }

    fun getAxis(state: BlockState): Axis? {
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt
@@ -4,24 +4,39 @@ import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.chunk.CachedBlockCtx
 import mods.betterfoliage.render.SALTWATER_BIOMES
 import mods.betterfoliage.render.SAND_BLOCKS
-import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.lighting.grassTuftLighting
-import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.resource.discovery.BlockRenderKey
 import mods.betterfoliage.resource.discovery.ModelDiscoveryBase
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
-import mods.betterfoliage.resource.model.*
-import mods.betterfoliage.util.*
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.WrappedBakedModel
+import mods.betterfoliage.model.build
+import mods.betterfoliage.model.horizontalRectangle
+import mods.betterfoliage.model.meshifyStandard
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.model.withOpposites
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.randomB
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.randomI
+import net.fabricmc.fabric.api.renderer.v1.material.BlendMode
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
-import net.minecraft.block.BlockRenderLayer.CUTOUT_MIPPED
 import net.minecraft.block.BlockState
 import net.minecraft.block.Material
 import net.minecraft.client.render.model.BakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.UP
-import net.minecraft.world.ExtendedBlockView
-import java.util.*
+import net.minecraft.world.BlockRenderView
+import java.util.Random
 import java.util.function.Consumer
 import java.util.function.Supplier

@@ -40,14 +55,14 @@ class SandModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {

    val coralLighting = allDirections.map { grassTuftLighting(it) }.toTypedArray()

-    override fun emitBlockQuads(blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
+    override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
        super.emitBlockQuads(blockView, state, pos, randomSupplier, context)

        val ctx = CachedBlockCtx(blockView, pos)

        val random = randomSupplier.get()
        if (!BetterFoliage.config.enabled || !BetterFoliage.config.coral.enabled(random)) return
-        if (ctx.biome.category !in SALTWATER_BIOMES) return
+        if (ctx.biome?.category !in SALTWATER_BIOMES) return

        allDirections.filter { random.nextInt(64) < BetterFoliage.config.coral.chance }.forEach { face ->
            val isWater = ctx.state(face).material == Material.WATER
@@ -76,7 +91,7 @@ class SandModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
                tuftModelSet(shapes, Color.white.asInt) { coralTuftSprites[randomI()] }
                    .transform { rotate(Rotation.fromUp[face]) }
                    .withOpposites()
-                    .build(CUTOUT_MIPPED)
+                    .build(BlendMode.CUTOUT_MIPPED)
            }.toTypedArray()
        }
        val coralCrustModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
@@ -88,7 +103,7 @@ class SandModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
                        .rotate(Rotation.fromUp[face])
                        .mirrorUV(randomB(), randomB()).rotateUV(randomI(max = 4))
                        .sprite(coralCrustSprites[idx]).colorAndIndex(null)
-                    ).build(CUTOUT_MIPPED)
+                    ).build(BlendMode.CUTOUT_MIPPED)
                }
            }.toTypedArray()
        }
--- a/src/main/kotlin/mods/betterfoliage/render/column/ColumnMeshSet.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/column/ColumnMeshSet.kt
@@ -2,13 +2,25 @@ package mods.betterfoliage.render.column

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType
-import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.*
-import mods.betterfoliage.resource.model.*
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.INVISIBLE
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.LARGE_RADIUS
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SMALL_RADIUS
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SQUARE
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.Quad
+import mods.betterfoliage.model.UV
+import mods.betterfoliage.model.Vertex
+import mods.betterfoliage.model.build
+import mods.betterfoliage.model.horizontalRectangle
+import mods.betterfoliage.model.verticalRectangle
 import mods.betterfoliage.util.Double3
 import mods.betterfoliage.util.Rotation
-import net.minecraft.block.BlockRenderLayer.SOLID
+import net.fabricmc.fabric.api.renderer.v1.material.BlendMode.SOLID
 import net.minecraft.client.texture.Sprite
-import net.minecraft.util.math.Direction.*
+import net.minecraft.util.math.Direction.Axis
+import net.minecraft.util.math.Direction.EAST
+import net.minecraft.util.math.Direction.SOUTH
+import net.minecraft.util.math.Direction.UP

 /**
 * Collection of dynamically generated meshes used to render rounded columns.
--- a/src/main/kotlin/mods/betterfoliage/render/column/ColumnModel.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/column/ColumnModel.kt
@@ -5,13 +5,13 @@ import mods.betterfoliage.chunk.ChunkOverlayManager
 import mods.betterfoliage.render.column.ColumnLayerData.NormalRender
 import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.*
 import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.*
-import mods.betterfoliage.resource.model.WrappedBakedModel
+import mods.betterfoliage.model.WrappedBakedModel
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
 import net.minecraft.block.BlockState
 import net.minecraft.client.render.model.BakedModel
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.Axis
-import net.minecraft.world.ExtendedBlockView
+import net.minecraft.world.BlockRenderView
 import java.util.*
 import java.util.function.Supplier

@@ -21,7 +21,7 @@ abstract class ColumnModelBase(wrapped: BakedModel) : WrappedBakedModel(wrapped)
    abstract val connectPerpendicular: Boolean
    abstract fun getMeshSet(axis: Axis, quadrant: Int): ColumnMeshSet

-    override fun emitBlockQuads(blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
+    override fun emitBlockQuads(blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) {
        val ctx = CachedBlockCtx(blockView, pos)
        val roundLog = ChunkOverlayManager.get(overlayLayer, ctx)

--- a/src/main/kotlin/mods/betterfoliage/render/column/ColumnOverlayLayer.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/column/ColumnOverlayLayer.kt
@@ -1,20 +1,30 @@
 package mods.betterfoliage.render.column

 import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.chunk.BlockCtx
 import mods.betterfoliage.chunk.ChunkOverlayLayer
 import mods.betterfoliage.chunk.ChunkOverlayManager
 import mods.betterfoliage.chunk.dimType
-import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.*
-import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType
-import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.*
-import mods.betterfoliage.chunk.BlockCtx
 import mods.betterfoliage.render.block.vanilla.RoundLogKey
-import mods.betterfoliage.util.*
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.NONSOLID
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.PARALLEL
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.PERPENDICULAR
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.BlockType.SOLID
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.INVISIBLE
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.LARGE_RADIUS
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SMALL_RADIUS
+import mods.betterfoliage.render.column.ColumnLayerData.SpecialRender.QuadrantType.SQUARE
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.face
+import mods.betterfoliage.util.plus
 import net.minecraft.block.BlockState
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.Axis
 import net.minecraft.util.math.Direction.AxisDirection
-import net.minecraft.world.ExtendedBlockView
+import net.minecraft.world.WorldView

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

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

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

--- a/src/main/kotlin/mods/betterfoliage/render/lighting/Indigo.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/lighting/Indigo.kt
@@ -1,43 +1,53 @@
 package mods.betterfoliage.render.lighting

-import it.unimi.dsi.fastutil.ints.Int2ObjectFunction
+import mods.betterfoliage.util.YarnHelper
+import mods.betterfoliage.util.get
 import mods.betterfoliage.util.reflectField
 import net.fabricmc.fabric.api.renderer.v1.mesh.Mesh
 import net.fabricmc.fabric.api.renderer.v1.model.FabricBakedModel
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
-import net.fabricmc.fabric.impl.client.indigo.renderer.accessor.AccessBufferBuilder
 import net.fabricmc.fabric.impl.client.indigo.renderer.aocalc.AoCalculator
 import net.fabricmc.fabric.impl.client.indigo.renderer.render.*
-import net.minecraft.block.BlockRenderLayer
 import net.minecraft.block.BlockState
+import net.minecraft.client.render.RenderLayer
+import net.minecraft.client.render.VertexConsumer
 import net.minecraft.client.render.model.BakedModel
 import net.minecraft.util.math.BlockPos
-import net.minecraft.world.ExtendedBlockView
+import net.minecraft.world.BlockRenderView
 import java.util.*
 import java.util.function.Consumer
 import java.util.function.Supplier

+val AbstractQuadRenderer_blockInfo2 = YarnHelper.requiredField<TerrainBlockRenderInfo>(
+    "net.fabricmc.fabric.impl.client.indigo.renderer.render.AbstractQuadRenderer",
+    "blockInfo", "Lnet/fabricmc/fabric/impl/client/indigo/renderer/render/TerrainBlockRenderInfo;"
+)
+val AbstractQuadRenderer_bufferFunc2 = YarnHelper.requiredField<java.util.function.Function<RenderLayer, VertexConsumer>>(
+    "net.fabricmc.fabric.impl.client.indigo.renderer.render.AbstractQuadRenderer",
+    "bufferFunc", "Ljava/util/function/Function;"
+)
+val AbstractQuadRenderer_aoCalc = YarnHelper.requiredField<AoCalculator>(
+    "net.fabricmc.fabric.impl.client.indigo.renderer.render.AbstractQuadRenderer",
+    "aoCalc", "Lnet/fabricmc/fabric/impl/client/indigo/renderer/aocalc/AoCalculator;"
+)
+val AbstractQuadRenderer_transform = YarnHelper.requiredField<RenderContext.QuadTransform>(
+    "net.fabricmc.fabric.impl.client.indigo.renderer.render.AbstractQuadRenderer",
+    "transform", "Lnet/fabricmc/fabric/api/renderer/v1/render/RenderContext\$QuadTransform;"
+)
+
 val MODIFIED_CONSUMER_POOL = ThreadLocal<ModifiedTerrainMeshConsumer>()

-fun TerrainMeshConsumer.modified() = MODIFIED_CONSUMER_POOL.get() ?: let {
-    val blockInfo = reflectField<TerrainBlockRenderInfo>("blockInfo")
-    val chunkInfo = reflectField<ChunkRenderInfo>("chunkInfo")
-    val aoCalc = reflectField<AoCalculator>("aoCalc")
-    val transform = reflectField<RenderContext.QuadTransform>("transform")
-    ModifiedTerrainMeshConsumer(blockInfo, chunkInfo, aoCalc, transform)
+fun AbstractMeshConsumer.modified() = MODIFIED_CONSUMER_POOL.get() ?: let {
+    ModifiedTerrainMeshConsumer(this)
 }.apply { MODIFIED_CONSUMER_POOL.set(this) }

-val TerrainRenderContext_blockInfo = TerrainRenderContext::class.java.declaredFields.find { it.name == "blockInfo" }?.apply { isAccessible = true }
-val BlockRenderInfo_layerIndexOrDefault = BlockRenderInfo::class.java.declaredMethods.find { it.name == "layerIndexOrDefault" }?.apply { isAccessible = true }
-val AbstractQuadRenderer_bufferFunc = AbstractQuadRenderer::class.java.declaredFields.find { it.name == "bufferFunc" }?.apply { isAccessible = true }
-
 /**
 * Render the given model at the given position.
 * Mutates the state of the [RenderContext]!!
 */
-fun RenderContext.renderMasquerade(model: BakedModel, blockView: ExtendedBlockView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) = when(this) {
+fun RenderContext.renderMasquerade(model: BakedModel, blockView: BlockRenderView, state: BlockState, pos: BlockPos, randomSupplier: Supplier<Random>, context: RenderContext) = when(this) {
    is TerrainRenderContext -> {
-        val blockInfo = TerrainRenderContext_blockInfo!!.get(this) as BlockRenderInfo
+        val blockInfo = meshConsumer()[AbstractQuadRenderer_blockInfo2]!!
        blockInfo.prepareForBlock(state, pos, model.useAmbientOcclusion())
        (model as FabricBakedModel).emitBlockQuads(blockView, state, pos, randomSupplier, context)
    }
@@ -49,7 +59,7 @@ fun RenderContext.renderMasquerade(model: BakedModel, blockView: ExtendedBlockVi
 /** Execute the provided block with a mesh consumer using the given custom lighting. */
 fun RenderContext.withLighting(lighter: CustomLighting, func: (Consumer<Mesh>)->Unit) = when(this) {
    is TerrainRenderContext -> {
-        val consumer = (meshConsumer() as TerrainMeshConsumer).modified()
+        val consumer = (meshConsumer() as AbstractMeshConsumer).modified()
        consumer.clearLighting()
        consumer.lighter = lighter
        func(consumer)
@@ -59,12 +69,10 @@ fun RenderContext.withLighting(lighter: CustomLighting, func: (Consumer<Mesh>)->
 }

 /** Get the [BufferBuilder] responsible for a given [BlockRenderLayer] */
-fun RenderContext.getBufferBuilder(layer: BlockRenderLayer) = when(this) {
+fun RenderContext.getBufferBuilder(layer: RenderLayer) = when(this) {
    is TerrainRenderContext -> {
-        val blockInfo = TerrainRenderContext_blockInfo!!.get(this) as BlockRenderInfo
-        val layerIdx = BlockRenderInfo_layerIndexOrDefault!!.invoke(blockInfo, layer) as Int
-        val bufferFunc = AbstractQuadRenderer_bufferFunc!!.get(meshConsumer()) as Int2ObjectFunction<AccessBufferBuilder>
-        bufferFunc[layerIdx]
+        val bufferFunc = meshConsumer()[AbstractQuadRenderer_bufferFunc2]!!
+        bufferFunc.apply(layer)
    }
    else -> null
 }
--- a/src/main/kotlin/mods/betterfoliage/render/particle/FallingLeaves.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/particle/FallingLeaves.kt
@@ -29,19 +29,20 @@ class FallingLeafParticle(
    }

    var rotationSpeed = randomF(min = PI2 / 80.0, max = PI2 / 50.0)
-    var rotPositive = true
    val isMirrored = randomB()
    var wasCollided = false

    init {
        angle = randomF(max = PI2)
+        prevAngle = angle - rotationSpeed
+
        maxAge = MathHelper.floor(randomD(0.6, 1.0) * BetterFoliage.config.fallingLeaves.lifetime * 20.0)
        velocityY = -BetterFoliage.config.fallingLeaves.speed

        scale = BetterFoliage.config.fallingLeaves.size.toFloat() * 0.1f

        val state = world.getBlockState(pos)
-        val blockColor = MinecraftClient.getInstance().blockColorMap.getColorMultiplier(state, world, pos, 0)
+        val blockColor = MinecraftClient.getInstance().blockColorMap.getColor(state, world, pos, 0)
        sprite = LeafParticleRegistry[leafKey.leafType][randomI(max = 1024)]
        setParticleColor(leafKey.overrideColor, blockColor)
    }
@@ -49,11 +50,12 @@ class FallingLeafParticle(
    override val isValid: Boolean get() = (sprite != null)

    override fun update() {
-        if (randomF() > 0.95f) rotPositive = !rotPositive
+        if (randomF() > 0.95f) rotationSpeed = -rotationSpeed
        if (age > maxAge - 20) colorAlpha = 0.05f * (maxAge - age)

        if (onGround || wasCollided) {
            velocity.setTo(0.0, 0.0, 0.0)
+            prevAngle = angle
            if (!wasCollided) {
                age = age.coerceAtLeast(maxAge - 20)
                wasCollided = true
@@ -62,14 +64,15 @@ class FallingLeafParticle(
            val cosRotation = cos(angle).toDouble(); val sinRotation = sin(angle).toDouble()
            velocity.setTo(cosRotation, 0.0, sinRotation).mul(BetterFoliage.config.fallingLeaves.perturb)
                    .add(LeafWindTracker.current).add(0.0, -1.0, 0.0).mul(BetterFoliage.config.fallingLeaves.speed)
-            angle += if (rotPositive) rotationSpeed else -rotationSpeed
+            prevAngle = angle
+            angle += rotationSpeed
        }
    }

-    override fun render(worldRenderer: BufferBuilder, partialTickTime: Float) {
-        val tickAngle = angle + partialTickTime * (if (rotPositive) rotationSpeed else -rotationSpeed)
-        renderParticleQuad(worldRenderer, partialTickTime, rotation = tickAngle.toDouble(), isMirrored = isMirrored)
-    }
+//    override fun render(worldRenderer: BufferBuilder, partialTickTime: Float) {
+//        val tickAngle = angle + partialTickTime * (if (rotPositive) rotationSpeed else -rotationSpeed)
+//        renderParticleQuad(worldRenderer, partialTickTime, rotation = tickAngle.toDouble(), isMirrored = isMirrored)
+//    }

    fun setParticleColor(overrideColor: Int?, blockColor: Int) {
        val color =  overrideColor ?: blockColor
--- a/src/main/kotlin/mods/betterfoliage/render/particle/LeafParticleRegistry.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/particle/LeafParticleRegistry.kt
@@ -1,8 +1,8 @@
 package mods.betterfoliage.render.particle

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.resource.model.FixedSpriteSet
-import mods.betterfoliage.resource.model.SpriteSet
+import mods.betterfoliage.model.FixedSpriteSet
+import mods.betterfoliage.model.SpriteSet
 import mods.betterfoliage.util.*
 import net.fabricmc.fabric.api.event.client.ClientSpriteRegistryCallback
 import net.minecraft.client.texture.SpriteAtlasTexture
@@ -19,7 +19,7 @@ object LeafParticleRegistry : ClientSpriteRegistryCallback {
        spriteSets.clear()
        typeMappings.loadMappings(Identifier(BetterFoliage.MOD_ID, "leaf_texture_mappings.cfg"))
        (typeMappings.mappings.map { it.type } + "default").distinct().forEach { leafType ->
-            val validIds = (0 until 16).map { idx -> Identifier(BetterFoliage.MOD_ID, "falling_leaf_${leafType}_$idx") }
+            val validIds = (0 until 16).map { idx -> Identifier(BetterFoliage.MOD_ID, "particle/falling_leaf_${leafType}_$idx") }
                .filter { resourceManager.containsResource(Atlas.PARTICLES.wrap(it)) }
            ids[leafType] = validIds
            validIds.forEach { registry.register(it) }
--- a/src/main/kotlin/mods/betterfoliage/render/particle/RisingSouls.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/particle/RisingSouls.kt
@@ -2,11 +2,12 @@ package mods.betterfoliage.render.particle

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.render.AbstractParticle
-import mods.betterfoliage.resource.model.SpriteDelegate
-import mods.betterfoliage.resource.model.SpriteSetDelegate
+import mods.betterfoliage.model.SpriteDelegate
+import mods.betterfoliage.model.SpriteSetDelegate
 import mods.betterfoliage.util.*
 import net.minecraft.client.particle.ParticleTextureSheet
-import net.minecraft.client.render.BufferBuilder
+import net.minecraft.client.render.Camera
+import net.minecraft.client.render.VertexConsumer
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.MathHelper
@@ -34,8 +35,9 @@ class RisingSoulParticle(
    override val isValid: Boolean get() = true

    override fun update() {
-        val phase = initialPhase + (age.toDouble() * PI2 / 64.0 )
-        val cosPhase = cos(phase); val sinPhase = sin(phase)
+        val phase = initialPhase + (age.toDouble() * PI2 / 64.0)
+        val cosPhase = cos(phase);
+        val sinPhase = sin(phase)
        velocity.setTo(BetterFoliage.config.risingSoul.perturb.let { Double3(cosPhase * it, 0.1, sinPhase * it) })

        particleTrail.addFirst(currentPos.copy())
@@ -44,11 +46,12 @@ class RisingSoulParticle(
        if (!BetterFoliage.config.enabled) markDead()
    }

-    override fun render(worldRenderer: BufferBuilder, partialTickTime: Float) {
+    override fun buildGeometry(vertexConsumer: VertexConsumer, camera: Camera, tickDelta: Float) {
        var alpha = BetterFoliage.config.risingSoul.opacity.toFloat()
        if (age > maxAge - 40) alpha *= (maxAge - age) / 40.0f

-        renderParticleQuad(worldRenderer, partialTickTime,
+        renderParticleQuad(
+            vertexConsumer, camera, tickDelta,
            size = BetterFoliage.config.risingSoul.headSize * 0.25,
            alpha = alpha
        )
@@ -57,20 +60,24 @@ class RisingSoulParticle(
        particleTrail.forEachPairIndexed { idx, current, previous ->
            scale *= BetterFoliage.config.risingSoul.sizeDecay
            alpha *= BetterFoliage.config.risingSoul.opacityDecay.toFloat()
-            if (idx % BetterFoliage.config.risingSoul.trailDensity == 0) renderParticleQuad(worldRenderer, partialTickTime,
-                currentPos = current,
-                prevPos = previous,
-                size = scale,
-                alpha = alpha,
-                sprite = trackIcon
-            )
+            if (idx % BetterFoliage.config.risingSoul.trailDensity == 0)
+                renderParticleQuad(
+                    vertexConsumer, camera, tickDelta,
+                    currentPos = current,
+                    prevPos = previous,
+                    size = scale,
+                    alpha = alpha,
+                    sprite = trackIcon
+                )
        }
    }

    override fun getType() = ParticleTextureSheet.PARTICLE_SHEET_TRANSLUCENT

    companion object {
-        val headIcons by SpriteSetDelegate(Atlas.PARTICLES) { idx -> Identifier(BetterFoliage.MOD_ID, "rising_soul_$idx") }
-        val trackIcon by SpriteDelegate(Atlas.PARTICLES) { Identifier(BetterFoliage.MOD_ID, "soul_track") }
+        val headIcons by SpriteSetDelegate(Atlas.PARTICLES) { idx ->
+            Identifier(BetterFoliage.MOD_ID, "particle/rising_soul_$idx")
+        }
+        val trackIcon by SpriteDelegate(Atlas.PARTICLES) { Identifier(BetterFoliage.MOD_ID, "particle/soul_track") }
    }
 }