[WIP] adopt model replacement from Forge vesion

+ bunch of renames to bring the 2 version closer + at-least-not-crashing levels of Optifine support
2021-05-13 21:13:10 +02:00
parent 9dacdde761
commit 40fd46b278
51 changed files with 1082 additions and 749 deletions
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Cactus.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Cactus.kt
@@ -1,26 +1,29 @@
 package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
-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.config.CACTUS_BLOCKS
 import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.ModelWrapKey
 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.meshifyCutoutMipped
 import mods.betterfoliage.model.meshifyStandard
 import mods.betterfoliage.model.transform
 import mods.betterfoliage.model.tuftModelSet
 import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.grassTuftLighting
+import mods.betterfoliage.render.lighting.roundLeafLighting
+import mods.betterfoliage.render.lighting.withLighting
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.util.Atlas
-import mods.betterfoliage.util.LazyMap
+import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.Rotation
 import mods.betterfoliage.util.get
 import mods.betterfoliage.util.horizontalDirections
@@ -29,37 +32,36 @@ 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
-import net.minecraft.block.CactusBlock
+import net.minecraft.block.Blocks
 import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.render.model.BasicBakedModel
+import net.minecraft.client.render.model.json.JsonUnbakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.DOWN
 import net.minecraft.world.BlockRenderView
 import java.util.Random
-import java.util.function.Consumer
 import java.util.function.Supplier


-interface CactusKey : BlockRenderKey {
-    val cactusTop: Identifier
-    val cactusBottom: Identifier
-    val cactusSide: Identifier
-}
-
-object StandardCactusDiscovery : ConfigurableModelDiscovery() {
-    override val logger = BetterFoliage.logDetail
-    override val matchClasses = SimpleBlockMatcher(CactusBlock::class.java)
-    override val modelTextures = listOf(ModelTextureList("block/cactus", "top", "bottom", "side"))
-
-    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: Consumer<Identifier>): BlockRenderKey? {
-        return CactusModel.Key(textures[0], textures[1], textures[2])
+object StandardCactusDiscovery : AbstractModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        val model = ctx.getUnbaked()
+        if (model is JsonUnbakedModel && ctx.blockState.block in CACTUS_BLOCKS) {
+            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardCactusKey)
+            ctx.sprites.add(StandardCactusModel.cactusCrossSprite)
+        }
+        super.processModel(ctx)
    }
 }

-class CactusModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wrapped), FabricBakedModel {
+object StandardCactusKey : ModelWrapKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel) = StandardCactusModel(meshifyCutoutMipped(wrapped))
+}
+
+class StandardCactusModel(wrapped: BakedModel) : WrappedBakedModel(wrapped), FabricBakedModel {

-    val crossModels by cactusCrossModels.delegate(key)
-    val armModels by cactusArmModels.delegate(key)
    val armLighting = horizontalDirections.map { grassTuftLighting(it) }
    val crossLighting = roundLeafLighting()

@@ -71,36 +73,26 @@ class CactusModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wrapped
        val armSide = random.nextInt() and 3

        context.withLighting(armLighting[armSide]) {
-            it.accept(armModels[armSide][random])
+            it.accept(cactusArmModels[armSide][random])
        }
        context.withLighting(crossLighting) {
-            it.accept(crossModels[random])
+            it.accept(cactusCrossModels[random])
        }
    }

-    data class Key(
-        override val cactusTop: Identifier,
-        override val cactusBottom: Identifier,
-        override val cactusSide: Identifier
-    ) : CactusKey {
-        override fun replace(model: BakedModel, state: BlockState) = CactusModel(this, meshifyStandard(model, state))
-    }
-
    companion object {
-        val cactusCrossSprite by SpriteDelegate(Atlas.BLOCKS) {
-            Identifier(BetterFoliage.MOD_ID, "blocks/better_cactus")
-        }
+        val cactusCrossSprite = Identifier(BetterFoliage.MOD_ID, "blocks/better_cactus")
        val cactusArmSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
            Identifier(BetterFoliage.MOD_ID, "blocks/better_cactus_arm_$idx")
        }
-        val cactusArmModels = LazyMap(BetterFoliage.modelReplacer) { key: CactusKey ->
+        val cactusArmModels by LazyInvalidatable(BakeWrapperManager) {
            val shapes = BetterFoliage.config.cactus.let { tuftShapeSet(0.8, 0.8, 0.8, 0.2) }
            val models = tuftModelSet(shapes, Color.white.asInt) { cactusArmSprites[randomI()] }
            horizontalDirections.map { side ->
                models.transform { move(0.0625 to DOWN).rotate(Rotation.fromUp[side.ordinal]) }.buildTufts()
            }.toTypedArray()
        }
-        val cactusCrossModels = LazyMap(BetterFoliage.modelReplacer) { key: CactusKey ->
+        val cactusCrossModels by LazyInvalidatable(BakeWrapperManager) {
            val models = BetterFoliage.config.cactus.let { config ->
                crossModelsRaw(64, config.size, 0.0, 0.0)
                    .transform { rotateZ(randomD(-config.sizeVariation, config.sizeVariation)) }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt
@@ -2,42 +2,72 @@ package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.chunk.BasicBlockCtx
-import mods.betterfoliage.render.DIRT_BLOCKS
-import mods.betterfoliage.render.SALTWATER_BIOMES
+import mods.betterfoliage.config.DIRT_BLOCKS
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.ModelWrapKey
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.WrappedBakedModel
+import mods.betterfoliage.model.build
+import mods.betterfoliage.model.meshifyStandard
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.model.withOpposites
+import mods.betterfoliage.config.SALTWATER_BIOMES
+import mods.betterfoliage.model.getUnderlyingModel
+import mods.betterfoliage.model.meshifySolid
 import mods.betterfoliage.render.ShadersModIntegration
-import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.lighting.grassTuftLighting
 import mods.betterfoliage.render.lighting.reedLighting
 import mods.betterfoliage.render.lighting.renderMasquerade
-import mods.betterfoliage.util.Atlas
-import mods.betterfoliage.resource.discovery.BlockRenderKey
-import mods.betterfoliage.resource.discovery.ModelDiscoveryBase
+import mods.betterfoliage.render.lighting.withLighting
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.resource.generated.CenteredSprite
-import mods.betterfoliage.model.*
-import mods.betterfoliage.util.*
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.get
+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.BlockState
+import net.minecraft.block.Blocks
 import net.minecraft.block.Material
+import net.minecraft.client.render.RenderLayer
 import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.render.model.BasicBakedModel
+import net.minecraft.client.render.model.json.JsonUnbakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.UP
 import net.minecraft.world.BlockRenderView
-import java.util.*
-import java.util.function.Consumer
+import java.util.Random
 import java.util.function.Supplier

-object DirtKey : BlockRenderKey {
-    override fun replace(model: BakedModel, state: BlockState) = DirtModel(meshifyStandard(model, state))
+object StandardDirtDiscovery : AbstractModelDiscovery() {
+    fun canRenderInLayer(layer: RenderLayer) = when {
+        !BetterFoliage.config.enabled -> layer == RenderLayer.getSolid()
+        (!BetterFoliage.config.connectedGrass.enabled &&
+                !BetterFoliage.config.algae.enabled &&
+                !BetterFoliage.config.reed.enabled
+                ) -> layer == RenderLayer.getSolid()
+        else -> layer == RenderLayer.getCutoutMipped()
+    }
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is JsonUnbakedModel && ctx.blockState.block in DIRT_BLOCKS) {
+            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardDirtKey)
+//            RenderTypeLookup.setRenderLayer(ctx.blockState.block, ::canRenderInLayer)
+        }
+        super.processModel(ctx)
+    }
 }

-object DirtDiscovery : ModelDiscoveryBase() {
-    override val logger = BetterFoliage.logDetail
-
-    override fun processModel(ctx: ModelDiscoveryContext, atlas: Consumer<Identifier>) =
-        if (ctx.state.block in DIRT_BLOCKS) DirtKey else null
+object StandardDirtKey : ModelWrapKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel) = DirtModel(meshifySolid(wrapped))
 }

 class DirtModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
@@ -45,26 +75,32 @@ class DirtModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
    val algaeLighting = grassTuftLighting(UP)
    val reedLighting = reedLighting()

-    override fun emitBlockQuads(blockView: BlockRenderView, 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)
        val stateUp = ctx.offset(UP).state
-        val keyUp = BetterFoliage.modelReplacer[stateUp]
+        val isGrassUp = stateUp in BetterFoliage.blockTypes.grass

        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

-        if (BetterFoliage.config.connectedGrass.enabled && keyUp is GrassKey) {
-            val grassBaseModel = (ctx.model(UP) as WrappedBakedModel).wrapped
+        val random = randomSupplier.get()
+        if (BetterFoliage.config.connectedGrass.enabled && isGrassUp) {
+            val grassBaseModel = getUnderlyingModel(ctx.model(UP), random)
            context.renderMasquerade(grassBaseModel, blockView, stateUp, pos, randomSupplier, context)
        } else {
            super.emitBlockQuads(blockView, state, pos, randomSupplier, context)
        }

-        val random = randomSupplier.get()
        if (BetterFoliage.config.algae.enabled(random) && isDeepWater) {
            ShadersModIntegration.grass(context, BetterFoliage.config.algae.shaderWind) {
                context.withLighting(algaeLighting) {
@@ -88,14 +124,15 @@ class DirtModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
            idFunc = { idx -> Identifier(BetterFoliage.MOD_ID, "blocks/better_reed_$idx") },
            idRegister = { id -> CenteredSprite(id, aspectHeight = 2).register(BetterFoliage.generatedPack) }
        )
-        val algaeModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
-            val shapes = BetterFoliage.config.algae.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
+        val algaeModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes =
+                BetterFoliage.config.algae.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
            tuftModelSet(shapes, Color.white.asInt) { algaeSprites[randomI()] }
                .withOpposites()
                .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)

        }
-        val reedModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
+        val reedModels by LazyInvalidatable(BakeWrapperManager) {
            val shapes = BetterFoliage.config.reed.let { tuftShapeSet(2.0, it.heightMin, it.heightMax, it.hOffset) }
            tuftModelSet(shapes, Color.white.asInt) { reedSprites[randomI()] }
                .withOpposites()
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt
@@ -2,7 +2,8 @@ package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.chunk.BasicBlockCtx
-import mods.betterfoliage.render.SNOW_MATERIALS
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.SNOW_MATERIALS
 import mods.betterfoliage.render.ShadersModIntegration
 import mods.betterfoliage.render.lighting.grassTuftLighting
 import mods.betterfoliage.render.lighting.withLighting
@@ -14,6 +15,7 @@ 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.client.render.model.BakedModel
+import net.minecraft.client.render.model.BasicBakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.*
@@ -22,32 +24,32 @@ import java.util.*
 import java.util.function.Consumer
 import java.util.function.Supplier

-interface GrassKey : BlockRenderKey {
-    val grassTopTexture: Identifier
-
-    /**
-     * Color to use for Short Grass rendering instead of the biome color.
-     *
-     * Value is null if the texture is mostly grey (the saturation of its average color is under a configurable limit),
-     * the average color of the texture otherwise.
-     */
-    val overrideColor: Int?
-}
-
 object StandardGrassDiscovery : ConfigurableModelDiscovery() {
-    override val logger = BetterFoliage.logDetail
    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<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))
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<Identifier>) {
+        ctx.addReplacement(StandardGrassKey(textureMatch[0], null))
+        BetterFoliage.blockTypes.grass.add(ctx.blockState)
    }
 }

-class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wrapped), FabricBakedModel {
+data class StandardGrassKey(
+    val grassLocation: Identifier,
+    val overrideColor: Color?
+) : ModelWrapKey() {
+    val tintIndex: Int get() = if (overrideColor == null) 0 else -1
+
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel): BakedModel {
+        val grassSpriteColor = Atlas.BLOCKS[grassLocation].averageColor.let { hsb ->
+            logColorOverride(detailLogger, BetterFoliage.config.shortGrass.saturationThreshold, hsb)
+            hsb.colorOverride(BetterFoliage.config.shortGrass.saturationThreshold)
+        }
+        return StandardGrassModel(meshifyCutoutMipped(wrapped), this.copy(overrideColor = grassSpriteColor))
+    }
+}
+
+class StandardGrassModel(wrapped: BakedModel, val key: StandardGrassKey) : WrappedBakedModel(wrapped) {

    val tuftNormal by grassTuftMeshesNormal.delegate(key)
    val tuftSnowed by grassTuftMeshesSnowed.delegate(key)
@@ -64,9 +66,8 @@ 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) && (
-                BetterFoliage.modelReplacer[stateBelow].let { it is DirtKey || it is GrassKey }
-            )
+            (!isSnowed || BetterFoliage.config.connectedGrass.snowEnabled) &&
+            (stateBelow in BetterFoliage.blockTypes.dirt || stateBelow in BetterFoliage.blockTypes.grass)

        val random = randomSupplier.get()
        if (connected) {
@@ -84,13 +85,6 @@ class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wra
        }
    }

-    data class Key(
-        override val grassTopTexture: Identifier,
-        override val overrideColor: Int?
-    ) : GrassKey {
-        override fun replace(model: BakedModel, state: BlockState) = GrassBlockModel(this, meshifyStandard(model, state))
-    }
-
    companion object {
        val grassTuftSpritesNormal by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
            Identifier(BetterFoliage.MOD_ID, "blocks/better_grass_long_$idx")
@@ -98,23 +92,23 @@ class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wra
        val grassTuftSpritesSnowed by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
            Identifier(BetterFoliage.MOD_ID, "blocks/better_grass_long_$idx")
        }
-        val grassTuftShapes = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
+        val grassTuftShapes = LazyMap(BakeWrapperManager) { key: StandardGrassKey ->
            BetterFoliage.config.shortGrass.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
        }
-        val grassTuftMeshesNormal = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
-            tuftModelSet(grassTuftShapes[key], key.overrideColor) { idx -> grassTuftSpritesNormal[randomI()] }
+        val grassTuftMeshesNormal = LazyMap(BakeWrapperManager) { key: StandardGrassKey ->
+            tuftModelSet(grassTuftShapes[key], key.tintIndex) { idx -> grassTuftSpritesNormal[randomI()] }
                .withOpposites()
                .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)
        }
-        val grassTuftMeshesSnowed = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
+        val grassTuftMeshesSnowed = LazyMap(BakeWrapperManager) { key: StandardGrassKey ->
            tuftModelSet(grassTuftShapes[key], Color.white.asInt) { idx -> grassTuftSpritesSnowed[randomI()] }
                .withOpposites()
                .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)
        }
-        val grassFullBlockMeshes = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
-            Array(64) { fullCubeTextured(key.grassTopTexture, key.overrideColor) }
+        val grassFullBlockMeshes = LazyMap(BakeWrapperManager) { key: StandardGrassKey ->
+            Array(64) { fullCubeTextured(key.grassLocation, key.tintIndex) }
        }
-        val snowFullBlockMeshes by LazyInvalidatable(BetterFoliage.modelReplacer) {
+        val snowFullBlockMeshes by LazyInvalidatable(BakeWrapperManager) {
            Array(64) { fullCubeTextured(Identifier("block/snow"), Color.white.asInt) }
        }
    }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Leaf.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Leaf.kt
@@ -2,76 +2,87 @@ package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.chunk.BasicBlockCtx
-import mods.betterfoliage.render.SNOW_MATERIALS
+import mods.betterfoliage.config.SNOW_MATERIALS
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.ModelWrapKey
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.WrappedBakedModel
+import mods.betterfoliage.model.crossModelsRaw
+import mods.betterfoliage.model.crossModelsTextured
+import mods.betterfoliage.model.meshifyCutoutMipped
 import mods.betterfoliage.render.ShadersModIntegration
-import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.lighting.roundLeafLighting
+import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.particle.LeafParticleRegistry
-import mods.betterfoliage.util.Atlas
-import mods.betterfoliage.resource.discovery.*
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ConfigurableBlockMatcher
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ModelTextureList
 import mods.betterfoliage.resource.generated.GeneratedLeafSprite
-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 mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyMap
+import mods.betterfoliage.util.averageColor
+import mods.betterfoliage.util.colorOverride
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.logColorOverride
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
 import net.minecraft.block.BlockState
 import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.render.model.BasicBakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
-import net.minecraft.util.math.Direction.*
+import net.minecraft.util.math.Direction.UP
 import net.minecraft.world.BlockRenderView
-import java.util.*
-import java.util.function.Consumer
+import org.apache.logging.log4j.Level
+import java.util.Random
 import java.util.function.Supplier

-interface LeafKey : BlockRenderKey {
-    val roundLeafTexture: Identifier
+interface LeafBlockModel {
+    val key: LeafParticleKey
+}

-    /** Type of the leaf block (configurable by user). */
+interface LeafParticleKey {
    val leafType: String
-
-    /** Average color of the round leaf texture. */
-    val overrideColor: Int?
+    val overrideColor: Color?
 }

 object StandardLeafDiscovery : ConfigurableModelDiscovery() {
-    override val logger = BetterFoliage.logDetail
    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<Identifier>, atlas: Consumer<Identifier>) =
-        defaultRegisterLeaf(textures[0], atlas)
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<Identifier>) {
+        val leafType = LeafParticleRegistry.typeMappings.getType(textureMatch[0]) ?: "default"
+        val generated = GeneratedLeafSprite(textureMatch[0], leafType)
+            .register(BetterFoliage.generatedPack)
+            .apply { ctx.sprites.add(this) }

-}
-
-fun HasLogger.defaultRegisterLeaf(sprite: Identifier, atlas: Consumer<Identifier>): BlockRenderKey? {
-    val leafType = LeafParticleRegistry.typeMappings.getType(sprite) ?: "default"
-    val leafId = GeneratedLeafSprite(sprite, leafType).register(BetterFoliage.generatedPack)
-    atlas.accept(leafId)
-
-    log(" leaf texture $sprite")
-    log("     particle $leafType")
-
-    return NormalLeavesModel.Key(
-        leafId, leafType,
-        getAndLogColorOverride(leafId, Atlas.BLOCKS, BetterFoliage.config.shortGrass.saturationThreshold)
-    )
-}
-
-fun HasLogger.getAndLogColorOverride(sprite: Identifier, atlas: Atlas, threshold: Double): Int? {
-    val hsb = resourceManager.averageImageColorHSB(sprite, atlas)
-    return if (hsb.saturation >= threshold) {
-        log("         brightness ${hsb.brightness}")
-        log("         saturation ${hsb.saturation} >= ${threshold}, using texture color")
-        hsb.copy(brightness = 0.9f.coerceAtMost(hsb.brightness * 2.0f)).asColor
-    } else {
-        log("         saturation ${hsb.saturation} < ${threshold}, using block color")
-        null
+        detailLogger.log(Level.INFO, "     particle $leafType")
+        ctx.addReplacement(StandardLeafKey(generated, leafType, null))
    }
 }

-class NormalLeavesModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wrapped), FabricBakedModel {
+data class StandardLeafKey(
+    val roundLeafTexture: Identifier,
+    override val leafType: String,
+    override val overrideColor: Color?
+) : ModelWrapKey(), LeafParticleKey {
+    val tintIndex: Int get() = if (overrideColor == null) 0 else -1
+
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel): BakedModel {
+        val leafSpriteColor = Atlas.BLOCKS[roundLeafTexture].averageColor.let { hsb ->
+            logColorOverride(detailLogger, BetterFoliage.config.leaves.saturationThreshold, hsb)
+            hsb.colorOverride(BetterFoliage.config.leaves.saturationThreshold)
+        }
+        return StandardLeafModel(meshifyCutoutMipped(wrapped), this.copy(overrideColor = leafSpriteColor))
+    }
+}
+
+class StandardLeafModel(
+    wrapped: BakedModel,
+    override val key: StandardLeafKey
+) : WrappedBakedModel(wrapped), LeafBlockModel {

    val leafNormal by leafModelsNormal.delegate(key)
    val leafSnowed by leafModelsSnowed.delegate(key)
@@ -94,26 +105,18 @@ class NormalLeavesModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(w
        }
    }

-    data class Key(
-        override val roundLeafTexture: Identifier,
-        override val leafType: String,
-        override val overrideColor: Int?
-    ) : LeafKey {
-        override fun replace(model: BakedModel, state: BlockState) = NormalLeavesModel(this, meshifyStandard(model, state, blendModeOverride = BlendMode.CUTOUT_MIPPED))
-    }
-
    companion object {
        val leafSpritesSnowed by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
            Identifier(BetterFoliage.MOD_ID, "blocks/better_leaves_snowed_$idx")
        }
-        val leafModelsBase = LazyMap(BetterFoliage.modelReplacer) { key: LeafKey ->
+        val leafModelsBase = LazyMap(BakeWrapperManager) { key: StandardLeafKey ->
            BetterFoliage.config.leaves.let { crossModelsRaw(64, it.size, it.hOffset, it.vOffset) }
        }
-        val leafModelsNormal = LazyMap(BetterFoliage.modelReplacer) { key: LeafKey ->
-            crossModelsTextured(leafModelsBase[key], key.overrideColor, true) { Atlas.BLOCKS.atlas[key.roundLeafTexture]!! }
+        val leafModelsNormal = LazyMap(BakeWrapperManager) { key: StandardLeafKey ->
+            crossModelsTextured(leafModelsBase[key], key.tintIndex, true) { key.roundLeafTexture }
        }
-        val leafModelsSnowed = LazyMap(BetterFoliage.modelReplacer) { key: LeafKey ->
-            crossModelsTextured(leafModelsBase[key], Color.white.asInt, false) { leafSpritesSnowed[it] }
+        val leafModelsSnowed = LazyMap(BakeWrapperManager) { key: StandardLeafKey ->
+            crossModelsTextured(leafModelsBase[key], Color.white.asInt, false) { leafSpritesSnowed[it].id }
        }
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Lilypad.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Lilypad.kt
@@ -1,18 +1,21 @@
 package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.render.ShadersModIntegration
-import mods.betterfoliage.resource.discovery.BlockRenderKey
-import mods.betterfoliage.resource.discovery.ModelDiscoveryBase
-import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.ModelWrapKey
 import mods.betterfoliage.model.SpriteSetDelegate
 import mods.betterfoliage.model.WrappedBakedModel
 import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.meshifyCutoutMipped
 import mods.betterfoliage.model.meshifyStandard
 import mods.betterfoliage.model.transform
 import mods.betterfoliage.model.tuftModelSet
 import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.ShadersModIntegration
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.get
@@ -20,25 +23,31 @@ import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.render.model.BasicBakedModel
+import net.minecraft.client.render.model.json.JsonUnbakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.DOWN
 import net.minecraft.world.BlockRenderView
 import java.util.Random
-import java.util.function.Consumer
 import java.util.function.Supplier

-object LilypadKey : BlockRenderKey {
-    override fun replace(model: BakedModel, state: BlockState) = LilypadModel(meshifyStandard(model, state))
+object StandardLilypadDiscovery : AbstractModelDiscovery() {
+    val LILYPAD_BLOCKS = listOf(Blocks.LILY_PAD)
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is JsonUnbakedModel && ctx.blockState.block in LILYPAD_BLOCKS) {
+            ctx.addReplacement(StandardLilypadKey)
+        }
+        super.processModel(ctx)
+    }
 }

-object LilyPadDiscovery : ModelDiscoveryBase() {
-    override val logger = BetterFoliage.logDetail
-    override fun processModel(ctx: ModelDiscoveryContext, atlas: Consumer<Identifier>) =
-        if (ctx.state.block == Blocks.LILY_PAD) LilypadKey else null
+object StandardLilypadKey : ModelWrapKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel) = StandardLilypadModel(meshifyCutoutMipped(wrapped))
 }

-class LilypadModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
+class StandardLilypadModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
    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
@@ -59,13 +68,13 @@ class LilypadModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
        val lilypadFlowerSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
            Identifier(BetterFoliage.MOD_ID, "blocks/better_lilypad_flower_$idx")
        }
-        val lilypadRootModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
+        val lilypadRootModels by LazyInvalidatable(BakeWrapperManager) {
            val shapes = tuftShapeSet(1.0, 1.0, 1.0, BetterFoliage.config.lilypad.hOffset)
            tuftModelSet(shapes, Color.white.asInt) { lilypadRootSprites[it] }
                .transform { move(2.0 to DOWN) }
                .buildTufts()
        }
-        val lilypadFlowerModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
+        val lilypadFlowerModels by LazyInvalidatable(BakeWrapperManager) {
            val shapes = tuftShapeSet(0.5, 0.5, 0.5, BetterFoliage.config.lilypad.hOffset)
            tuftModelSet(shapes, Color.white.asInt) { lilypadFlowerSprites[it] }
                .transform { move(1.0 to DOWN) }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt
@@ -1,19 +1,22 @@
 package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.render.ShadersModIntegration
-import mods.betterfoliage.render.lighting.grassTuftLighting
-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.model.Color
+import mods.betterfoliage.model.ModelWrapKey
 import mods.betterfoliage.model.SpriteSetDelegate
 import mods.betterfoliage.model.WrappedBakedModel
 import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.meshifyCutoutMipped
 import mods.betterfoliage.model.meshifyStandard
 import mods.betterfoliage.model.tuftModelSet
 import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.ShadersModIntegration
+import mods.betterfoliage.render.lighting.grassTuftLighting
+import mods.betterfoliage.render.lighting.withLighting
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.get
@@ -24,26 +27,32 @@ import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.render.model.BasicBakedModel
+import net.minecraft.client.render.model.json.JsonUnbakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.UP
 import net.minecraft.world.BlockRenderView
 import java.util.Random
-import java.util.function.Consumer
 import java.util.function.Supplier

-object MyceliumKey : BlockRenderKey {
-    override fun replace(model: BakedModel, state: BlockState) = MyceliumModel(meshifyStandard(model, state))
+object StandardMyceliumDiscovery : AbstractModelDiscovery() {
+    val MYCELIUM_BLOCKS = listOf(Blocks.MYCELIUM)
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is JsonUnbakedModel && ctx.blockState.block in MYCELIUM_BLOCKS) {
+            ctx.addReplacement(StandardMyceliumKey)
+//            RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.getCutout())
+        }
+        super.processModel(ctx)
+    }
 }

-object MyceliumDiscovery : ModelDiscoveryBase() {
-    override val logger = BetterFoliage.logDetail
-    val myceliumBlocks = listOf(Blocks.MYCELIUM)
-    override fun processModel(ctx: ModelDiscoveryContext, atlas: Consumer<Identifier>) =
-        if (ctx.state.block in myceliumBlocks) MyceliumKey else null
+object StandardMyceliumKey : ModelWrapKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel) = StandardMyceliumModel(meshifyCutoutMipped(wrapped))
 }

-class MyceliumModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
+class StandardMyceliumModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {

    val tuftLighting = grassTuftLighting(UP)

@@ -67,7 +76,7 @@ class MyceliumModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
        val myceliumTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
            Identifier(BetterFoliage.MOD_ID, "blocks/better_mycel_$idx")
        }
-        val myceliumTuftModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
+        val myceliumTuftModels by LazyInvalidatable(BakeWrapperManager) {
            val shapes = BetterFoliage.config.shortGrass.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
            tuftModelSet(shapes, Color.white.asInt) { idx -> myceliumTuftSprites[randomI()] }.buildTufts()
        }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt
@@ -1,38 +1,68 @@
 package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.config.NETHERRACK_BLOCKS
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.ModelWrapKey
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.WrappedBakedModel
+import mods.betterfoliage.model.build
+import mods.betterfoliage.model.meshifyCutoutMipped
+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.render.lighting.grassTuftLighting
 import mods.betterfoliage.render.lighting.withLighting
-import mods.betterfoliage.resource.discovery.BlockRenderKey
-import mods.betterfoliage.resource.discovery.ModelDiscoveryBase
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
-import mods.betterfoliage.model.*
-import mods.betterfoliage.util.*
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyInvalidatable
+import mods.betterfoliage.util.Rotation
+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.material.BlendMode
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
 import net.minecraft.block.BlockState
-import net.minecraft.block.Blocks
+import net.minecraft.client.render.RenderLayer
 import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.render.model.BasicBakedModel
+import net.minecraft.client.render.model.json.JsonUnbakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.DOWN
 import net.minecraft.world.BlockRenderView
-import java.util.*
-import java.util.function.Consumer
+import java.util.Random
 import java.util.function.Supplier

-object NetherrackKey : BlockRenderKey {
-    override fun replace(model: BakedModel, state: BlockState) = NetherrackModel(meshifyStandard(model, state))
+object StandardNetherrackDiscovery : AbstractModelDiscovery() {
+
+    fun canRenderInLayer(layer: RenderLayer) = when {
+        !BetterFoliage.config.enabled -> layer == RenderLayer.getSolid()
+        !BetterFoliage.config.netherrack.enabled -> layer == RenderLayer.getSolid()
+        else -> layer == RenderLayer.getCutoutMipped()
+    }
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is JsonUnbakedModel && ctx.blockState.block in NETHERRACK_BLOCKS) {
+            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardNetherrackKey)
+//            RenderTypeLookup.setRenderLayer(ctx.blockState.block, ::canRenderInLayer)
+        }
+        super.processModel(ctx)
+    }
 }

-object NetherrackDiscovery : ModelDiscoveryBase() {
-    override val logger = BetterFoliage.logDetail
-    val netherrackBlocks = listOf(Blocks.NETHERRACK)
-    override fun processModel(ctx: ModelDiscoveryContext, atlas: Consumer<Identifier>) =
-        if (ctx.state.block in netherrackBlocks) NetherrackKey else null
+object StandardNetherrackKey : ModelWrapKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel) = StandardNetherrackModel(meshifyCutoutMipped(wrapped))
 }

-class NetherrackModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
+class StandardNetherrackModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {

    val tuftLighting = grassTuftLighting(DOWN)

@@ -53,7 +83,7 @@ class NetherrackModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
        val netherrackTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
            Identifier(BetterFoliage.MOD_ID, "blocks/better_netherrack_$idx")
        }
-        val netherrackTuftModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
+        val netherrackTuftModels by LazyInvalidatable(BakeWrapperManager) {
            val shapes = BetterFoliage.config.netherrack.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
            tuftModelSet(shapes, Color.white.asInt) { netherrackTuftSprites[randomI()] }
                .transform { rotate(Rotation.fromUp[DOWN.ordinal]).rotateUV(2) }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt
@@ -1,36 +1,51 @@
 package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.render.column.*
-import mods.betterfoliage.util.Atlas
-import mods.betterfoliage.resource.discovery.*
+import mods.betterfoliage.model.ModelWrapKey
+import mods.betterfoliage.model.meshifySolid
 import mods.betterfoliage.model.meshifyStandard
+import mods.betterfoliage.render.column.ColumnBlockKey
+import mods.betterfoliage.render.column.ColumnMeshSet
+import mods.betterfoliage.render.column.ColumnModelBase
+import mods.betterfoliage.render.column.ColumnRenderLayer
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ConfigurableBlockMatcher
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelBakingKey
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ModelTextureList
+import mods.betterfoliage.util.Atlas
 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.render.model.BasicBakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.Direction.Axis
-import java.util.function.Consumer
+import org.apache.logging.log4j.Level
+
+interface RoundLogKey : ColumnBlockKey, ModelBakingKey {
+    val barkSprite: Identifier
+    val endSprite: Identifier
+}

 object RoundLogOverlayLayer : ColumnRenderLayer() {
-    override fun getColumnKey(state: BlockState) = BetterFoliage.modelReplacer.getTyped<ColumnBlockKey>(state)
+    override fun getColumnKey(state: BlockState) = BetterFoliage.blockTypes.getTyped<ColumnBlockKey>(state)
    override val connectSolids: Boolean get() = BetterFoliage.config.roundLogs.connectSolids
    override val lenientConnect: Boolean get() = BetterFoliage.config.roundLogs.lenientConnect
    override val defaultToY: Boolean get() = BetterFoliage.config.roundLogs.defaultY
 }

-object StandardLogDiscovery : ConfigurableModelDiscovery() {
-    override val logger = BetterFoliage.logDetail
+object StandardRoundLogDiscovery : 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<Identifier>, atlas: Consumer<Identifier>): BlockRenderKey? {
-        val axis = getAxis(state)
-        log("       axis $axis")
-        return RoundLogModel.Key(axis, textures[0], textures[1])
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<Identifier>) {
+        val axis = getAxis(ctx.blockState)
+        detailLogger.log(Level.INFO, "       axis $axis")
+        ctx.addReplacement(StandardRoundLogKey(axis, textureMatch[0], textureMatch[1]))
    }

    fun getAxis(state: BlockState): Axis? {
@@ -45,12 +60,15 @@ object StandardLogDiscovery : ConfigurableModelDiscovery() {
    }
 }

-interface RoundLogKey : ColumnBlockKey, BlockRenderKey {
-    val barkSprite: Identifier
-    val endSprite: Identifier
+data class StandardRoundLogKey(
+    override val axis: Axis?,
+    override val barkSprite: Identifier,
+    override val endSprite: Identifier
+) : RoundLogKey, ModelWrapKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel) = StandardRoundLogModel(meshifySolid(wrapped), this)
 }

-class RoundLogModel(val key: Key, wrapped: BakedModel) : ColumnModelBase(wrapped) {
+class StandardRoundLogModel(wrapped: BakedModel, val key: StandardRoundLogKey) : ColumnModelBase(wrapped) {
    override val enabled: Boolean get() = BetterFoliage.config.enabled && BetterFoliage.config.roundLogs.enabled
    override val overlayLayer: ColumnRenderLayer get() = RoundLogOverlayLayer
    override val connectPerpendicular: Boolean get() = BetterFoliage.config.roundLogs.connectPerpendicular
@@ -58,18 +76,10 @@ class RoundLogModel(val key: Key, wrapped: BakedModel) : ColumnModelBase(wrapped
    val modelSet by modelSets.delegate(key)
    override fun getMeshSet(axis: Axis, quadrant: Int) = modelSet

-    data class Key(
-        override val axis: Axis?,
-        override val barkSprite: Identifier,
-        override val endSprite: Identifier
-    ) : RoundLogKey {
-        override fun replace(model: BakedModel, state: BlockState) = RoundLogModel(this, meshifyStandard(model, state))
-    }
-
    companion object {
-        val modelSets = LazyMap(BetterFoliage.modelReplacer) { key: Key ->
-            val barkSprite = Atlas.BLOCKS.atlas[key.barkSprite]!!
-            val endSprite = Atlas.BLOCKS.atlas[key.endSprite]!!
+        val modelSets = LazyMap(BakeWrapperManager) { key: StandardRoundLogKey ->
+            val barkSprite = Atlas.BLOCKS[key.barkSprite]!!
+            val endSprite = Atlas.BLOCKS[key.endSprite]!!
            BetterFoliage.config.roundLogs.let { config ->
                ColumnMeshSet(
                    config.radiusSmall, config.radiusLarge, config.zProtection,
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt
@@ -2,23 +2,26 @@ package mods.betterfoliage.render.block.vanilla

 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.grassTuftLighting
-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.config.SALTWATER_BIOMES
+import mods.betterfoliage.config.SAND_BLOCKS
 import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.ModelWrapKey
 import mods.betterfoliage.model.SpriteSetDelegate
 import mods.betterfoliage.model.WrappedBakedModel
 import mods.betterfoliage.model.build
 import mods.betterfoliage.model.horizontalRectangle
+import mods.betterfoliage.model.meshifySolid
 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.render.lighting.grassTuftLighting
+import mods.betterfoliage.render.lighting.withLighting
+import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.Rotation
@@ -30,28 +33,36 @@ 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.BlockState
+import net.minecraft.block.Blocks
 import net.minecraft.block.Material
 import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.render.model.BasicBakedModel
+import net.minecraft.client.render.model.json.JsonUnbakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.UP
 import net.minecraft.world.BlockRenderView
 import java.util.Random
-import java.util.function.Consumer
 import java.util.function.Supplier

-object SandKey : BlockRenderKey {
-    override fun replace(model: BakedModel, state: BlockState) = SandModel(meshifyStandard(model, state))
+object StandardSandDiscovery : AbstractModelDiscovery() {
+
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is JsonUnbakedModel && ctx.blockState.block in SAND_BLOCKS) {
+            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardSandKey)
+//            RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.getCutoutMipped())
+        }
+        super.processModel(ctx)
+    }
 }

-object SandDiscovery : ModelDiscoveryBase() {
-    override val logger = BetterFoliage.logDetail
-
-    override fun processModel(ctx: ModelDiscoveryContext, atlas: Consumer<Identifier>) =
-        if (ctx.state.block in SAND_BLOCKS) SandKey else null
+object StandardSandKey : ModelWrapKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel) = StandardSandModel(meshifySolid(wrapped))
 }

-class SandModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
+class StandardSandModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {

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

@@ -85,7 +96,7 @@ class SandModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
        val coralCrustSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
            Identifier(BetterFoliage.MOD_ID, "blocks/better_crust_$idx")
        }
-        val coralTuftModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
+        val coralTuftModels by LazyInvalidatable(BakeWrapperManager) {
            val shapes = BetterFoliage.config.coral.let { tuftShapeSet(it.size, 1.0, 1.0, it.hOffset) }
            allDirections.map { face ->
                tuftModelSet(shapes, Color.white.asInt) { coralTuftSprites[randomI()] }
@@ -94,7 +105,7 @@ class SandModel(wrapped: BakedModel) : WrappedBakedModel(wrapped) {
                    .build(BlendMode.CUTOUT_MIPPED)
            }.toTypedArray()
        }
-        val coralCrustModels by LazyInvalidatable(BetterFoliage.modelReplacer) {
+        val coralCrustModels by LazyInvalidatable(BakeWrapperManager) {
            allDirections.map { face ->
                Array(64) { idx ->
                    listOf(horizontalRectangle(x1 = -0.5, x2 = 0.5, z1 = -0.5, z2 = 0.5, y = 0.0)