[WIP] Cactus, netherrack, round logs work

+ lots more cleanup + Optifine x-ray fix
2021-05-13 00:44:45 +02:00
parent dbc421c18e
commit 9899816029
40 changed files with 1059 additions and 401 deletions
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Cactus.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Cactus.kt
@@ -0,0 +1,93 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.Client
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteDelegate
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.crossModelsRaw
+import mods.betterfoliage.model.crossModelsTextured
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.LightingPreferredFace
+import mods.betterfoliage.render.lighting.RoundLeafLighting
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+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
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.horizontalDirections
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.randomI
+import net.minecraft.block.Blocks
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.ResourceLocation
+
+object StandardCactusDiscovery : AbstractModelDiscovery() {
+    val CACTUS_BLOCKS = listOf(Blocks.CACTUS)
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        val model = ctx.getUnbaked()
+        if (model is BlockModel && ctx.blockState.block in CACTUS_BLOCKS) {
+            Client.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardCactusKey)
+        }
+        super.processModel(ctx)
+    }
+}
+
+object StandardCactusKey : HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardCactusModel(wrapped)
+}
+
+class StandardCactusModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+
+    val armLighting = horizontalDirections.map { LightingPreferredFace(it) }.toTypedArray()
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        ctx.checkSides = false
+        super.render(ctx, noDecorations)
+        if (!Config.enabled || !Config.cactus.enabled) return
+
+        val armSide = ctx.random.nextInt() and 3
+        ctx.vertexLighter = armLighting[armSide]
+        ctx.renderQuads(cactusArmModels[armSide][ctx.random])
+        ctx.vertexLighter = RoundLeafLighting
+        ctx.renderQuads(cactusCrossModels[ctx.random])
+    }
+
+    companion object {
+        val cactusCrossSprite by SpriteDelegate(Atlas.BLOCKS) {
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_cactus")
+        }
+        val cactusArmSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_cactus_arm_$idx")
+        }
+        val cactusArmModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.cactus.let { tuftShapeSet(0.8, 0.8, 0.8, 0.2) }
+            val models = tuftModelSet(shapes, -1) { cactusArmSprites[randomI()] }
+            horizontalDirections.map { side ->
+                models.transform { move(0.0625 to DOWN).rotate(Rotation.fromUp[side.ordinal]) }.buildTufts()
+            }.toTypedArray()
+        }
+        val cactusCrossModels by LazyInvalidatable(BakeWrapperManager) {
+            val models = Config.cactus.let { config ->
+                crossModelsRaw(64, config.size, 0.0, 0.0)
+                    .transform { rotateZ(randomD(-config.sizeVariation, config.sizeVariation)) }
+            }
+            crossModelsTextured(models, -1, true) { cactusCrossSprite.name }
+        }
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt
@@ -15,7 +15,8 @@ import mods.betterfoliage.render.pipeline.RenderCtxBase
 import mods.betterfoliage.render.pipeline.RenderCtxVanilla
 import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
-import mods.betterfoliage.resource.discovery.ModelBakingKey
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.resource.generated.CenteredSprite
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.Int3
@@ -23,40 +24,36 @@ import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.get
 import mods.betterfoliage.util.offset
 import mods.betterfoliage.util.randomI
-import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.RenderTypeLookup
 import net.minecraft.client.renderer.model.BlockModel
-import net.minecraft.client.renderer.model.ModelBakery
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
 import net.minecraft.world.biome.Biome

 object StandardDirtDiscovery : AbstractModelDiscovery() {
    val DIRT_BLOCKS = listOf(Blocks.DIRT, Blocks.COARSE_DIRT, Blocks.PODZOL)
-    override fun processModel(
-        bakery: ModelBakery,
-        state: BlockState,
-        location: ResourceLocation,
-        sprites: MutableSet<ResourceLocation>,
-        replacements: MutableMap<ResourceLocation, ModelBakingKey>
-    ): Boolean {
-        val model = bakery.getUnbakedModel(location)
-        if (model is BlockModel && state.block in DIRT_BLOCKS) {
-            Client.blockTypes.dirt.add(state)
-            replacements[location] = StandardDirtKey
-//            RenderTypeLookup.setRenderLayer(state.block, RenderType.getCutout())
-            RenderTypeLookup.setRenderLayer(state.block, RenderType.getCutoutMipped())
-            return true
+
+    fun canRenderInLayer(layer: RenderType) = when {
+        !Config.enabled -> layer == RenderType.getSolid()
+        !Config.connectedGrass.enabled && !Config.algae.enabled && !Config.reed.enabled -> layer == RenderType.getSolid()
+        else -> layer == RenderType.getCutoutMipped()
+    }
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in DIRT_BLOCKS) {
+            Client.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardDirtKey)
+            RenderTypeLookup.setRenderLayer(ctx.blockState.block, ::canRenderInLayer)
        }
-        return super.processModel(bakery, state, location, sprites, replacements)
+        super.processModel(ctx)
    }
 }

 object StandardDirtKey : HalfBakedWrapperKey() {
-    override fun replace(wrapped: SpecialRenderModel) = StandardDirtModel(wrapped)
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardDirtModel(wrapped)
 }

 class StandardDirtModel(
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt
@@ -4,8 +4,6 @@ import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.Client
 import mods.betterfoliage.config.BlockConfig
 import mods.betterfoliage.config.Config
-import mods.betterfoliage.config.ConfigurableBlockMatcher
-import mods.betterfoliage.config.ModelTextureList
 import mods.betterfoliage.integration.ShadersModIntegration
 import mods.betterfoliage.model.Color
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
@@ -19,8 +17,11 @@ import mods.betterfoliage.model.tuftShapeSet
 import mods.betterfoliage.render.lighting.LightingPreferredFace
 import mods.betterfoliage.render.pipeline.RenderCtxBase
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ConfigurableBlockMatcher
 import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
-import mods.betterfoliage.resource.discovery.ModelBakingKey
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ModelTextureList
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.LazyMapInvalidatable
@@ -28,7 +29,6 @@ import mods.betterfoliage.util.averageColor
 import mods.betterfoliage.util.get
 import mods.betterfoliage.util.isSnow
 import mods.betterfoliage.util.randomI
-import net.minecraft.block.BlockState
 import net.minecraft.util.Direction.DOWN
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
@@ -37,17 +37,9 @@ object StandardGrassDiscovery : ConfigurableModelDiscovery() {
    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.grassBlocks
    override val modelTextures: List<ModelTextureList> get() = BlockConfig.grassModels.modelList

-    override fun processModel(
-        state: BlockState,
-        location: ResourceLocation,
-        textureMatch: List<ResourceLocation>,
-        sprites: MutableSet<ResourceLocation>,
-        replacements: MutableMap<ResourceLocation, ModelBakingKey>
-    ): Boolean {
-        replacements[location] = StandardGrassKey(textureMatch[0], null)
-        Client.blockTypes.grass.add(state)
-//        RenderTypeLookup.setRenderLayer(state.block, RenderType.getCutout())
-        return true
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
+        ctx.addReplacement(StandardGrassKey(textureMatch[0], null))
+        Client.blockTypes.grass.add(ctx.blockState)
    }
 }

@@ -57,7 +49,7 @@ data class StandardGrassKey(
 ) : HalfBakedWrapperKey() {
    val tintIndex: Int get() = if (overrideColor == null) 0 else -1

-    override fun replace(wrapped: SpecialRenderModel): SpecialRenderModel {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel): SpecialRenderModel {
        val grassSpriteColor = Atlas.BLOCKS[grassLocation].averageColor.let { hsb ->
            logColorOverride(BetterFoliageMod.detailLogger(this), Config.shortGrass.saturationThreshold, hsb)
            hsb.colorOverride(Config.shortGrass.saturationThreshold)
@@ -81,7 +73,7 @@ class StandardGrassModel(

        val stateBelow = ctx.state(DOWN)
        val stateAbove = ctx.state(UP)
-
+        val isAir = ctx.isAir(UP)
        val isSnowed = stateAbove.isSnow
        val connected = Config.connectedGrass.enabled &&
                (!isSnowed || Config.connectedGrass.snowEnabled) &&
@@ -93,7 +85,7 @@ class StandardGrassModel(
            super.render(ctx, noDecorations)
        }

-        if (Config.shortGrass.enabled(ctx.random) && !ctx.isNeighborSolid(UP)) {
+        if (Config.shortGrass.enabled(ctx.random) && (isAir || isSnowed)) {
            ctx.vertexLighter = tuftLighting
            ShadersModIntegration.grass(ctx, Config.shortGrass.shaderWind) {
                ctx.renderQuads(if (isSnowed) tuftSnowed[ctx.random] else tuftNormal[ctx.random])
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Leaf.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Leaf.kt
@@ -4,8 +4,6 @@ import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.Client
 import mods.betterfoliage.config.BlockConfig
 import mods.betterfoliage.config.Config
-import mods.betterfoliage.config.ConfigurableBlockMatcher
-import mods.betterfoliage.config.ModelTextureList
 import mods.betterfoliage.model.Color
 import mods.betterfoliage.model.HSB
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
@@ -14,21 +12,22 @@ import mods.betterfoliage.model.SpecialRenderModel
 import mods.betterfoliage.model.SpriteSetDelegate
 import mods.betterfoliage.model.crossModelsRaw
 import mods.betterfoliage.model.crossModelsTextured
-import mods.betterfoliage.render.lighting.RoundLeafLighting
+import mods.betterfoliage.render.lighting.RoundLeafLightingPreferUp
+import mods.betterfoliage.render.particle.LeafBlockModel
+import mods.betterfoliage.render.particle.LeafParticleKey
+import mods.betterfoliage.render.particle.LeafParticleRegistry
 import mods.betterfoliage.render.pipeline.RenderCtxBase
-import mods.betterfoliage.render.pipeline.RenderCtxVanilla
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ConfigurableBlockMatcher
 import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
-import mods.betterfoliage.resource.discovery.ModelBakingKey
+import mods.betterfoliage.resource.discovery.ModelBakingContext
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ModelTextureList
 import mods.betterfoliage.resource.generated.GeneratedLeaf
-import mods.betterfoliage.texture.LeafBlockModel
-import mods.betterfoliage.texture.LeafParticleKey
-import mods.betterfoliage.texture.LeafParticleRegistry
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyMapInvalidatable
 import mods.betterfoliage.util.averageColor
 import mods.betterfoliage.util.isSnow
-import net.minecraft.block.BlockState
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
 import org.apache.logging.log4j.Level.DEBUG
@@ -39,21 +38,15 @@ object StandardLeafDiscovery : ConfigurableModelDiscovery() {
    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.leafBlocks
    override val modelTextures: List<ModelTextureList> get() = BlockConfig.leafModels.modelList

-    override fun processModel(
-        state: BlockState,
-        location: ResourceLocation,
-        textureMatch: List<ResourceLocation>,
-        sprites: MutableSet<ResourceLocation>,
-        replacements: MutableMap<ResourceLocation, ModelBakingKey>
-    ): Boolean {
+
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
        val leafType = LeafParticleRegistry.typeMappings.getType(textureMatch[0]) ?: "default"
        val generated = GeneratedLeaf(textureMatch[0], leafType)
            .register(Client.generatedPack)
-            .apply { sprites.add(this) }
+            .apply { ctx.sprites.add(this) }

        detailLogger.log(INFO, "     particle $leafType")
-        replacements[location] = StandardLeafKey(generated, leafType, null)
-        return true
+        ctx.addReplacement(StandardLeafKey(generated, leafType, null))
    }
 }

@@ -76,7 +69,7 @@ data class StandardLeafKey(
 ) : HalfBakedWrapperKey(), LeafParticleKey {
    val tintIndex: Int get() = if (overrideColor == null) 0 else -1

-    override fun replace(wrapped: SpecialRenderModel): SpecialRenderModel {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel): SpecialRenderModel {
        val leafSpriteColor = Atlas.BLOCKS[roundLeafTexture].averageColor.let { hsb ->
            logColorOverride(BetterFoliageMod.detailLogger(this), Config.leaves.saturationThreshold, hsb)
            hsb.colorOverride(Config.leaves.saturationThreshold)
@@ -97,9 +90,10 @@ class StandardLeafModel(
        super.render(ctx, noDecorations)
        if (!Config.enabled || !Config.leaves.enabled || noDecorations) return

-        (ctx as? RenderCtxVanilla)?.let { it.vertexLighter = RoundLeafLighting }
-        ctx.renderQuads(leafNormal[ctx.random.nextInt(64)])
-        if (ctx.state(UP).isSnow) ctx.renderQuads(leafSnowed[ctx.random.nextInt(64)])
+        ctx.vertexLighter = RoundLeafLightingPreferUp
+        val leafIdx = ctx.random.nextInt(64)
+        ctx.renderQuads(leafNormal[leafIdx])
+        if (ctx.state(UP).isSnow) ctx.renderQuads(leafSnowed[leafIdx])
    }

    companion object {
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Lilypad.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Lilypad.kt
@@ -14,7 +14,9 @@ import mods.betterfoliage.model.tuftShapeSet
 import mods.betterfoliage.render.pipeline.RenderCtxBase
 import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
+import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelBakingKey
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.get
@@ -27,23 +29,17 @@ import net.minecraft.util.ResourceLocation

 object StandardLilypadDiscovery : AbstractModelDiscovery() {
    val LILYPAD_BLOCKS = listOf(Blocks.LILY_PAD)
-    override fun processModel(
-        bakery: ModelBakery,
-        state: BlockState,
-        location: ResourceLocation,
-        sprites: MutableSet<ResourceLocation>,
-        replacements: MutableMap<ResourceLocation, ModelBakingKey>
-    ): Boolean {
-        val model = bakery.getUnbakedModel(location)
-        if (model is BlockModel && state.block in LILYPAD_BLOCKS) {
-            replacements[location] = StandardLilypadKey
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in LILYPAD_BLOCKS) {
+            ctx.addReplacement(StandardLilypadKey)
        }
-        return super.processModel(bakery, state, location, sprites, replacements)
+        super.processModel(ctx)
    }
 }

 object StandardLilypadKey : HalfBakedWrapperKey() {
-    override fun replace(wrapped: SpecialRenderModel) = StandardLilypadModel(wrapped)
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardLilypadModel(wrapped)
 }

 class StandardLilypadModel(
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt
@@ -13,42 +13,33 @@ import mods.betterfoliage.render.lighting.LightingPreferredFace
 import mods.betterfoliage.render.pipeline.RenderCtxBase
 import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
-import mods.betterfoliage.resource.discovery.ModelBakingKey
+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
 import mods.betterfoliage.util.randomI
-import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.RenderTypeLookup
 import net.minecraft.client.renderer.model.BlockModel
-import net.minecraft.client.renderer.model.ModelBakery
 import net.minecraft.util.Direction
 import net.minecraft.util.ResourceLocation

 object StandardMyceliumDiscovery : AbstractModelDiscovery() {
    val MYCELIUM_BLOCKS = listOf(Blocks.MYCELIUM)

-    override fun processModel(
-        bakery: ModelBakery,
-        state: BlockState,
-        location: ResourceLocation,
-        sprites: MutableSet<ResourceLocation>,
-        replacements: MutableMap<ResourceLocation, ModelBakingKey>
-    ): Boolean {
-        val model = bakery.getUnbakedModel(location)
-        if (model is BlockModel && state.block in MYCELIUM_BLOCKS) {
-            replacements[location] = StandardMyceliumKey
-            RenderTypeLookup.setRenderLayer(state.block, RenderType.getCutout())
-            return true
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in MYCELIUM_BLOCKS) {
+            ctx.addReplacement(StandardMyceliumKey)
+            RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.getCutout())
        }
-        return super.processModel(bakery, state, location, sprites, replacements)
+        super.processModel(ctx)
    }
 }

 object StandardMyceliumKey : HalfBakedWrapperKey() {
-    override fun replace(wrapped: SpecialRenderModel) = StandardMyceliumModel(wrapped)
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardMyceliumModel(wrapped)
 }

 class StandardMyceliumModel(
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt
@@ -0,0 +1,82 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.Client
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.LightingPreferredFace
+import mods.betterfoliage.render.pipeline.RenderCtxBase
+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
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.randomI
+import net.minecraft.block.Blocks
+import net.minecraft.client.renderer.RenderType
+import net.minecraft.client.renderer.RenderTypeLookup
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.ResourceLocation
+
+object StandardNetherrackDiscovery : AbstractModelDiscovery() {
+    val NETHERRACK_BLOCKS = listOf(Blocks.NETHERRACK)
+
+    fun canRenderInLayer(layer: RenderType) = when {
+        !Config.enabled -> layer == RenderType.getSolid()
+        !Config.netherrack.enabled -> layer == RenderType.getSolid()
+        else -> layer == RenderType.getCutoutMipped()
+    }
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in NETHERRACK_BLOCKS) {
+            Client.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardNetherrackKey)
+            RenderTypeLookup.setRenderLayer(ctx.blockState.block, ::canRenderInLayer)
+        }
+        super.processModel(ctx)
+    }
+}
+
+object StandardNetherrackKey : HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardNetherrackModel(wrapped)
+}
+
+class StandardNetherrackModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+
+    val tuftLighting = LightingPreferredFace(DOWN)
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        super.render(ctx, noDecorations)
+        if (!Config.enabled || !Config.netherrack.enabled) return
+
+        if (ctx.isAir(DOWN)) {
+            ctx.vertexLighter = tuftLighting
+            ctx.renderQuads(netherrackTuftModels[ctx.random])
+        }
+    }
+
+    companion object {
+        val netherrackTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_netherrack_$idx")
+        }
+        val netherrackTuftModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.netherrack.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
+            tuftModelSet(shapes, -1) { netherrackTuftSprites[randomI()] }
+                .transform { rotate(Rotation.fromUp[DOWN.ordinal]).rotateUV(2) }
+                .buildTufts()
+        }
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt
@@ -1,13 +1,98 @@
 package mods.betterfoliage.render.block.vanilla

+import mods.betterfoliage.Client
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.resource.discovery.ModelTextureList
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.SpecialRenderModel
 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 net.minecraft.util.Direction
+import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyMapInvalidatable
+import mods.betterfoliage.util.tryDefault
+import net.minecraft.block.BlockState
+import net.minecraft.block.LogBlock
+import net.minecraft.util.Direction.Axis
 import net.minecraft.util.ResourceLocation
+import org.apache.logging.log4j.Level.INFO

-data class RoundLogKey(
-    override val axis: Direction.Axis?,
-    val barkSprite: ResourceLocation,
+interface RoundLogKey : ColumnBlockKey, ModelBakingKey {
+    val barkSprite: ResourceLocation
    val endSprite: ResourceLocation
-) : ColumnBlockKey, ModelBakingKey {
+}
+
+object RoundLogOverlayLayer : ColumnRenderLayer() {
+    override fun getColumnKey(state: BlockState) = Client.blockTypes.getTyped<ColumnBlockKey>(state)
+    override val connectSolids: Boolean get() = Config.roundLogs.connectSolids
+    override val lenientConnect: Boolean get() = Config.roundLogs.lenientConnect
+    override val defaultToY: Boolean get() = Config.roundLogs.defaultY
+}
+
+object StandardLogDiscovery : ConfigurableModelDiscovery() {
+    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.logBlocks
+    override val modelTextures: List<ModelTextureList> get() = BlockConfig.logModels.modelList
+
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
+        val axis = getAxis(ctx.blockState)
+        detailLogger.log(INFO, "       axis $axis")
+        StandardRoundLogKey(axis, textureMatch[0], textureMatch[1]).let { key ->
+            ctx.addReplacement(key)
+            Client.blockTypes.stateKeys[ctx.blockState] = key
+        }
+    }
+
+    fun getAxis(state: BlockState): Axis? {
+        val axis = tryDefault(null) { state.get(LogBlock.AXIS).toString() } ?:
+        state.values.entries.find { it.key.getName().toLowerCase() == "axis" }?.value?.toString()
+        return when (axis) {
+            "x" -> Axis.X
+            "y" -> Axis.Y
+            "z" -> Axis.Z
+            else -> null
+        }
+    }
+}
+
+data class StandardRoundLogKey(
+    override val axis: Axis?,
+    override val barkSprite: ResourceLocation,
+    override val endSprite: ResourceLocation
+) : RoundLogKey, HalfBakedWrapperKey() {
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardRoundLogModel(this, wrapped)
+}
+
+class StandardRoundLogModel(
+    val key: StandardRoundLogKey,
+    wrapped: SpecialRenderModel
+) : ColumnModelBase(wrapped) {
+    override val enabled: Boolean get() = Config.enabled && Config.roundLogs.enabled
+    override val overlayLayer: ColumnRenderLayer get() = RoundLogOverlayLayer
+    override val connectPerpendicular: Boolean get() = Config.roundLogs.connectPerpendicular
+
+    val modelSet by modelSets.delegate(key)
+    override fun getMeshSet(axis: Axis, quadrant: Int) = modelSet
+
+    companion object {
+        val modelSets = LazyMapInvalidatable(BakeWrapperManager) { key: StandardRoundLogKey ->
+            val barkSprite = Atlas.BLOCKS[key.barkSprite]
+            val endSprite = Atlas.BLOCKS[key.endSprite]
+            Config.roundLogs.let { config ->
+                ColumnMeshSet(
+                    config.radiusSmall, config.radiusLarge, config.zProtection,
+                    key.axis ?: Axis.Y,
+                    barkSprite, barkSprite,
+                    endSprite, endSprite
+                )
+            }
+        }
+    }
 }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt
@@ -18,7 +18,8 @@ import mods.betterfoliage.render.lighting.LightingPreferredFace
 import mods.betterfoliage.render.pipeline.RenderCtxBase
 import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
-import mods.betterfoliage.resource.discovery.ModelBakingKey
+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
@@ -28,39 +29,30 @@ import mods.betterfoliage.util.mapArray
 import mods.betterfoliage.util.randomB
 import mods.betterfoliage.util.randomD
 import mods.betterfoliage.util.randomI
-import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.RenderTypeLookup
 import net.minecraft.client.renderer.model.BlockModel
-import net.minecraft.client.renderer.model.ModelBakery
 import net.minecraft.util.Direction
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation

 object StandardSandDiscovery : AbstractModelDiscovery() {
    val SAND_BLOCKS = listOf(Blocks.SAND, Blocks.RED_SAND)
-    override fun processModel(
-        bakery: ModelBakery,
-        state: BlockState,
-        location: ResourceLocation,
-        sprites: MutableSet<ResourceLocation>,
-        replacements: MutableMap<ResourceLocation, ModelBakingKey>
-    ): Boolean {
-        val model = bakery.getUnbakedModel(location)
-        if (model is BlockModel && state.block in SAND_BLOCKS) {
-            Client.blockTypes.dirt.add(state)
-            replacements[location] = StandardSandKey
-            RenderTypeLookup.setRenderLayer(state.block, RenderType.getCutoutMipped())
-            return true
+
+    override fun processModel(ctx: ModelDiscoveryContext) {
+        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in SAND_BLOCKS) {
+            Client.blockTypes.dirt.add(ctx.blockState)
+            ctx.addReplacement(StandardSandKey)
+            RenderTypeLookup.setRenderLayer(ctx.blockState.block, RenderType.getCutoutMipped())
        }
-        return super.processModel(bakery, state, location, sprites, replacements)
+        super.processModel(ctx)
    }
 }

 object StandardSandKey : HalfBakedWrapperKey() {
-    override fun replace(wrapped: SpecialRenderModel) = StandardSandModel(wrapped)
+    override fun bake(ctx: ModelBakingContext, wrapped: SpecialRenderModel) = StandardSandModel(wrapped)
 }

 class StandardSandModel(