[WIP] algae, reeds, mycelium, coral working

+ lots of cleanup, reorganizing
2021-05-07 19:08:00 +02:00
parent f44d2a7a50
commit 7168caded1
29 changed files with 501 additions and 332 deletions
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt
@@ -1,57 +1,77 @@
 package mods.betterfoliage.render.block.vanilla

+import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.Client
 import mods.betterfoliage.config.Config
-import mods.betterfoliage.render.ISpecialRenderModel
-import mods.betterfoliage.render.old.HalfBakedSpecialWrapper
-import mods.betterfoliage.render.old.HalfBakedWrapKey
+import mods.betterfoliage.model.Color
+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.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.lighting.LightingPreferredFace
 import mods.betterfoliage.render.pipeline.RenderCtxBase
-import mods.betterfoliage.resource.discovery.ModelBakeKey
-import mods.betterfoliage.resource.discovery.ModelReplacer
+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.generated.CenteredSprite
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.Int3
+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 : ModelReplacer() {
-    val dirtBlocks = listOf(Blocks.DIRT, Blocks.COARSE_DIRT, Blocks.PODZOL)
+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, ModelBakeKey>
+        replacements: MutableMap<ResourceLocation, ModelBakingKey>
    ): Boolean {
        val model = bakery.getUnbakedModel(location)
-        if (model is BlockModel && state.block in dirtBlocks) {
+        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.getCutout())
+            RenderTypeLookup.setRenderLayer(state.block, RenderType.getCutoutMipped())
            return true
        }
        return super.processModel(bakery, state, location, sprites, replacements)
    }
 }

-object StandardDirtKey : HalfBakedWrapKey() {
-    override fun replace(wrapped: ISpecialRenderModel) = StandardDirtModel(wrapped)
+object StandardDirtKey : HalfBakedWrapperKey() {
+    override fun replace(wrapped: SpecialRenderModel) = StandardDirtModel(wrapped)
 }

 class StandardDirtModel(
-    wrapped: ISpecialRenderModel
+    wrapped: SpecialRenderModel
 ) : HalfBakedSpecialWrapper(wrapped) {
+    val vanillaTuftLighting = LightingPreferredFace(UP)
+
    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
-        if (!Config.enabled || noDecorations) return super.render(ctx, false)
+        if (!Config.enabled || noDecorations) return super.render(ctx, noDecorations)

        val stateUp = ctx.offset(UP).state
        val isConnectedGrass = Config.connectedGrass.enabled && stateUp in Client.blockTypes.grass
        if (isConnectedGrass) {
-            (ctx.blockModelShapes.getModel(stateUp) as? ISpecialRenderModel)?.let { grassModel ->
+            (ctx.blockModelShapes.getModel(stateUp) as? SpecialRenderModel)?.let { grassModel ->
                ctx.renderMasquerade(UP.offset) {
                    grassModel.render(ctx, true)
                }
@@ -61,5 +81,39 @@ class StandardDirtModel(
        }

        super.render(ctx, false)
+
+        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 (Config.algae.enabled(ctx.random) && isDeepWater) {
+            (ctx as? RenderCtxVanilla)?.vertexLighter = vanillaTuftLighting
+            ctx.render(algaeModels[ctx.random])
+        } else if (Config.reed.enabled(ctx.random) && isShallowWater && !isSaltWater) {
+            (ctx as? RenderCtxVanilla)?.vertexLighter = vanillaTuftLighting
+            ctx.render(reedModels[ctx.random])
+        }
+    }
+
+    companion object {
+        val SALTWATER_BIOMES = listOf(Biome.Category.BEACH, Biome.Category.OCEAN)
+
+        val algaeSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_algae_$idx")
+        }
+        val reedSprites by SpriteSetDelegate(
+            Atlas.BLOCKS,
+            idFunc = { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_reed_$idx") },
+            idRegister = { id -> CenteredSprite(id, aspectHeight = 2).register(Client.generatedPack) }
+        )
+        val algaeModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.algae.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
+            tuftModelSet(shapes, Color.white) { algaeSprites[randomI()] }.buildTufts()
+        }
+        val reedModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.reed.let { tuftShapeSet(2.0, it.heightMin, it.heightMax, it.hOffset) }
+            tuftModelSet(shapes, Color.white) { reedSprites[randomI()] }.buildTufts()
+        }
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt
@@ -6,22 +6,22 @@ import mods.betterfoliage.config.BlockConfig
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.config.ConfigurableBlockMatcher
 import mods.betterfoliage.config.ModelTextureList
-import mods.betterfoliage.render.ISpecialRenderModel
+import mods.betterfoliage.model.SpecialRenderModel
 import mods.betterfoliage.render.lighting.LightingPreferredFace
-import mods.betterfoliage.render.old.Color
-import mods.betterfoliage.render.old.HalfBakedSpecialWrapper
-import mods.betterfoliage.render.old.HalfBakedWrapKey
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.render.pipeline.RenderCtxBase
 import mods.betterfoliage.render.pipeline.RenderCtxVanilla
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
-import mods.betterfoliage.resource.discovery.ConfigurableModelReplacer
-import mods.betterfoliage.resource.discovery.ModelBakeKey
-import mods.betterfoliage.resource.model.SpriteSetDelegate
-import mods.betterfoliage.resource.model.buildTufts
-import mods.betterfoliage.resource.model.fullCubeTextured
-import mods.betterfoliage.resource.model.fullCubeTinted
-import mods.betterfoliage.resource.model.tuftModelSet
-import mods.betterfoliage.resource.model.tuftShapeSet
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelBakingKey
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.fullCubeTextured
+import mods.betterfoliage.model.fullCubeTinted
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.LazyMapInvalidatable
@@ -29,14 +29,11 @@ import mods.betterfoliage.util.get
 import mods.betterfoliage.util.isSnow
 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.util.Direction.DOWN
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation

-object StandardGrassDiscovery : ConfigurableModelReplacer() {
+object StandardGrassDiscovery : ConfigurableModelDiscovery() {
    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.grassBlocks
    override val modelTextures: List<ModelTextureList> get() = BlockConfig.grassModels.modelList

@@ -45,36 +42,33 @@ object StandardGrassDiscovery : ConfigurableModelReplacer() {
        location: ResourceLocation,
        textureMatch: List<ResourceLocation>,
        sprites: MutableSet<ResourceLocation>,
-        replacements: MutableMap<ResourceLocation, ModelBakeKey>
+        replacements: MutableMap<ResourceLocation, ModelBakingKey>
    ): Boolean {
        replacements[location] = StandardGrassKey(textureMatch[0])
        Client.blockTypes.grass.add(state)
-        RenderTypeLookup.setRenderLayer(state.block, RenderType.getCutout())
+//        RenderTypeLookup.setRenderLayer(state.block, RenderType.getCutout())
        return true
    }
 }

 data class StandardGrassKey(
    val grassLocation: ResourceLocation
-) : HalfBakedWrapKey() {
-    override fun replace(wrapped: ISpecialRenderModel): ISpecialRenderModel {
+) : HalfBakedWrapperKey() {
+    override fun replace(wrapped: SpecialRenderModel): SpecialRenderModel {
        Atlas.BLOCKS[grassLocation].logColorOverride(detailLogger, Config.shortGrass.saturationThreshold)
        return StandardGrassModel(wrapped, this)
    }
 }

 class StandardGrassModel(
-    wrapped: ISpecialRenderModel,
+    wrapped: SpecialRenderModel,
    key: StandardGrassKey
 ) : HalfBakedSpecialWrapper(wrapped) {

    val tuftNormal by grassTuftMeshesNormal.delegate(key)
    val tuftSnowed by grassTuftMeshesSnowed.delegate(key)
    val fullBlock by grassFullBlockMeshes.delegate(key)
-
-    val upNormal = arrayOf(0.0f, 1.0f, 0.0f, 0.0f).toFloatArray()
-
-    val vanillaTuftLighting = LightingPreferredFace(UP)
+    val tuftLighting = LightingPreferredFace(UP)

    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
        if (!Config.enabled || noDecorations) return super.render(ctx, noDecorations)
@@ -94,7 +88,7 @@ class StandardGrassModel(
        }

        if (Config.shortGrass.enabled(ctx.random) && !ctx.isNeighborSolid(UP)) {
-            (ctx as? RenderCtxVanilla)?.let { it.vertexLighter = vanillaTuftLighting }
+            (ctx as? RenderCtxVanilla)?.let { it.vertexLighter = tuftLighting }
            ctx.render(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
@@ -6,21 +6,21 @@ import mods.betterfoliage.config.BlockConfig
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.config.ConfigurableBlockMatcher
 import mods.betterfoliage.config.ModelTextureList
-import mods.betterfoliage.render.ISpecialRenderModel
+import mods.betterfoliage.model.SpecialRenderModel
 import mods.betterfoliage.render.lighting.RoundLeafLighting
-import mods.betterfoliage.render.old.Color
-import mods.betterfoliage.render.old.HalfBakedSpecialWrapper
-import mods.betterfoliage.render.old.HalfBakedWrapKey
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.render.pipeline.RenderCtxBase
 import mods.betterfoliage.render.pipeline.RenderCtxVanilla
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
-import mods.betterfoliage.resource.discovery.ConfigurableModelReplacer
-import mods.betterfoliage.resource.discovery.ModelBakeKey
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelBakingKey
 import mods.betterfoliage.resource.generated.GeneratedLeaf
-import mods.betterfoliage.resource.model.SpriteSetDelegate
-import mods.betterfoliage.resource.model.crossModelsRaw
-import mods.betterfoliage.resource.model.crossModelsTextured
-import mods.betterfoliage.resource.model.crossModelsTinted
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.crossModelsRaw
+import mods.betterfoliage.model.crossModelsTextured
+import mods.betterfoliage.model.crossModelsTinted
 import mods.betterfoliage.texture.LeafParticleRegistry
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyMapInvalidatable
@@ -33,7 +33,7 @@ import net.minecraft.util.ResourceLocation
 import org.apache.logging.log4j.Level.INFO
 import org.apache.logging.log4j.Logger

-object StandardLeafDiscovery : ConfigurableModelReplacer() {
+object StandardLeafDiscovery : ConfigurableModelDiscovery() {
    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.leafBlocks
    override val modelTextures: List<ModelTextureList> get() = BlockConfig.leafModels.modelList

@@ -42,11 +42,11 @@ object StandardLeafDiscovery : ConfigurableModelReplacer() {
        location: ResourceLocation,
        textureMatch: List<ResourceLocation>,
        sprites: MutableSet<ResourceLocation>,
-        replacements: MutableMap<ResourceLocation, ModelBakeKey>
+        replacements: MutableMap<ResourceLocation, ModelBakingKey>
    ): Boolean {
        val leafType = LeafParticleRegistry.typeMappings.getType(textureMatch[0]) ?: "default"
        val generated = GeneratedLeaf(textureMatch[0], leafType)
-            .register(Client.asyncPack)
+            .register(Client.generatedPack)
            .apply { sprites.add(this) }

        detailLogger.log(INFO, "     particle $leafType")
@@ -72,15 +72,15 @@ fun TextureAtlasSprite.getColorOverride(threshold: Double) = averageColor.let {
 data class StandardLeafKey(
    val roundLeafTexture: ResourceLocation,
    val leafType: String
-) : HalfBakedWrapKey() {
-    override fun replace(wrapped: ISpecialRenderModel): ISpecialRenderModel {
+) : HalfBakedWrapperKey() {
+    override fun replace(wrapped: SpecialRenderModel): SpecialRenderModel {
        Atlas.BLOCKS[roundLeafTexture].logColorOverride(BetterFoliageMod.detailLogger(this), 0.1)
        return StandardLeafModel(wrapped, this)
    }
 }

 class StandardLeafModel(
-    model: ISpecialRenderModel,
+    model: SpecialRenderModel,
    key: StandardLeafKey
 ) : HalfBakedSpecialWrapper(model) {
    val leafNormal by leafModelsNormal.delegate(key)
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt
@@ -0,0 +1,83 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.Color
+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.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.ModelBakingKey
+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
+        }
+        return super.processModel(bakery, state, location, sprites, replacements)
+    }
+}
+
+object StandardMyceliumKey : HalfBakedWrapperKey() {
+    override fun replace(wrapped: SpecialRenderModel) = StandardMyceliumModel(wrapped)
+}
+
+class StandardMyceliumModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+
+    val tuftLighting = LightingPreferredFace(Direction.UP)
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        super.render(ctx, noDecorations)
+
+        if (Config.shortGrass.enabled &&
+            Config.shortGrass.myceliumEnabled &&
+            Config.shortGrass.enabled(ctx.random) &&
+            ctx.state(Direction.UP).isAir(ctx.world, ctx.pos)
+        ) {
+            ctx.vertexLighter = tuftLighting
+            ctx.render(myceliumTuftModels[ctx.random])
+        }
+    }
+
+    companion object {
+        val myceliumTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_mycel_$idx")
+        }
+        val myceliumTuftModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.shortGrass.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
+            tuftModelSet(shapes, Color.white) { idx -> myceliumTuftSprites[randomI()] }.buildTufts()
+        }
+    }
+}
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt
@@ -1,7 +1,7 @@
 package mods.betterfoliage.render.block.vanilla

 import mods.betterfoliage.render.column.ColumnBlockKey
-import mods.betterfoliage.resource.discovery.ModelBakeKey
+import mods.betterfoliage.resource.discovery.ModelBakingKey
 import net.minecraft.util.Direction
 import net.minecraft.util.ResourceLocation

@@ -9,5 +9,5 @@ data class RoundLogKey(
    override val axis: Direction.Axis?,
    val barkSprite: ResourceLocation,
    val endSprite: ResourceLocation
-) : ColumnBlockKey, ModelBakeKey {
+) : ColumnBlockKey, ModelBakingKey {
 }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt
+++ b/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt
@@ -0,0 +1,118 @@
+package mods.betterfoliage.render.block.vanilla
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.Client
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.HalfBakedSpecialWrapper
+import mods.betterfoliage.model.HalfBakedWrapperKey
+import mods.betterfoliage.model.Quad
+import mods.betterfoliage.model.SpecialRenderModel
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.bake
+import mods.betterfoliage.model.buildTufts
+import mods.betterfoliage.model.transform
+import mods.betterfoliage.model.tuftModelSet
+import mods.betterfoliage.model.tuftShapeSet
+import mods.betterfoliage.render.block.vanilla.StandardDirtModel.Companion.SALTWATER_BIOMES
+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.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.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
+        }
+        return super.processModel(bakery, state, location, sprites, replacements)
+    }
+}
+
+object StandardSandKey : HalfBakedWrapperKey() {
+    override fun replace(wrapped: SpecialRenderModel) = StandardSandModel(wrapped)
+}
+
+class StandardSandModel(
+    wrapped: SpecialRenderModel
+) : HalfBakedSpecialWrapper(wrapped) {
+    val coralLighting = Direction.values().mapArray { LightingPreferredFace(it) }
+
+    override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
+        super.render(ctx, noDecorations)
+        if (noDecorations || !Config.enabled || !Config.coral.enabled(ctx.random)) return
+        if (ctx.biome?.category !in SALTWATER_BIOMES) return
+
+        allDirections.filter { ctx.random.nextInt(64) < Config.coral.chance }.forEach { face ->
+            val isWater = ctx.state(face).material == Material.WATER
+            val isDeepWater = isWater && ctx.offset(face).state(UP).material == Material.WATER
+            if (isDeepWater) {
+                ctx.vertexLighter = coralLighting[face]
+                ctx.render(coralCrustModels[face][ctx.random])
+                ctx.render(coralTuftModels[face][ctx.random])
+            }
+        }
+    }
+
+    companion object {
+        val coralTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_coral_$idx")
+        }
+        val coralCrustSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
+            ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_crust_$idx")
+        }
+        val coralTuftModels by LazyInvalidatable(BakeWrapperManager) {
+            val shapes = Config.coral.let { tuftShapeSet(it.size, 1.0, 1.0, it.hOffset) }
+            allDirections.mapArray { face ->
+                tuftModelSet(shapes, Color.white) { coralTuftSprites[randomI()] }
+                    .transform { rotate(Rotation.fromUp[face]) }
+                    .buildTufts()
+            }
+        }
+        val coralCrustModels by LazyInvalidatable(BakeWrapperManager) {
+            allDirections.map { face ->
+                Array(64) { idx ->
+                    listOf(
+                        Quad.horizontalRectangle(x1 = -0.5, x2 = 0.5, z1 = -0.5, z2 = 0.5, y = 0.0)
+                            .scale(Config.coral.crustSize)
+                            .move(0.5 + randomD(0.01, Config.coral.vOffset) to UP)
+                            .rotate(Rotation.fromUp[face])
+                            .mirrorUV(randomB(), randomB()).rotateUV(randomI(max = 4))
+                            .sprite(coralCrustSprites[idx]).colorAndIndex(null)
+                    ).bake(applyDiffuseLighting = false)
+                }
+            }.toTypedArray()
+        }
+    }
+}