[WIP] start 1.15 port

reorganize packages to match Fabric version use util classes from Fabric version
2021-05-01 13:52:21 +02:00
parent 9566ae8341
commit 09ccb83e8b
81 changed files with 1220 additions and 1011 deletions
@@ -0,0 +1,42 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.render.DIRT_BLOCKS
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.up1
+import mods.betterfoliage.render.up2
+import mods.betterfoliage.render.old.RenderDecorator
+import net.minecraft.block.material.Material
+import net.minecraft.util.ResourceLocation
+import net.minecraft.world.biome.Biome
+
+class RenderAlgae : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    val noise = simplexNoise()
+
+    val algaeIcons = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_algae_$idx") }
+    val algaeModels = modelSet(64) { idx -> RenderGrass.grassTopQuads(Config.algae.heightMin, Config.algae.heightMax)(idx) }
+
+    override fun isEligible(ctx: CombinedContext) =
+        Config.enabled && Config.algae.enabled &&
+        ctx.state(up2).material == Material.WATER &&
+        ctx.state(up1).material == Material.WATER &&
+        DIRT_BLOCKS.contains(ctx.state.block) &&
+        ctx.biome?.category
+            .let { it == Biome.Category.OCEAN || it == Biome.Category.BEACH || it == Biome.Category.RIVER } &&
+            noise[ctx.pos] < Config.algae.population
+
+    override fun render(ctx: CombinedContext) {
+        ctx.render()
+        if (!ctx.isCutout) return
+        val rand = ctx.semiRandomArray(3)
+        ShadersModIntegration.grass(ctx, Config.algae.shaderWind) {
+            ctx.render(
+                algaeModels[rand[2]],
+                icon = { _, qi, _ -> algaeIcons[rand[qi and 1]] }
+            )
+        }
+    }
+}
@@ -0,0 +1,111 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.column.ColumnTextureInfo
+import mods.betterfoliage.render.column.SimpleColumnInfo
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerAoMaxGreen
+import mods.betterfoliage.render.lighting.edgeOrientedAuto
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.octarinecore.client.resource.*
+import mods.betterfoliage.util.Rotation
+import mods.betterfoliage.config.ModelTextureList
+import mods.betterfoliage.config.SimpleBlockMatcher
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.old.Vertex
+import net.minecraft.block.BlockState
+import net.minecraft.block.CactusBlock
+import net.minecraft.util.Direction.*
+import java.util.concurrent.CompletableFuture
+
+object AsyncCactusDiscovery : ConfigurableModelDiscovery<ColumnTextureInfo>() {
+    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: AtlasFuture): CompletableFuture<ColumnTextureInfo>? {
+        val sprites = textures.map { atlas.sprite(it) }
+        return atlas.mapAfter {
+            SimpleColumnInfo(
+                Axis.Y,
+                sprites[0].get(),
+                sprites[1].get(),
+                sprites.drop(2).map { it.get() }
+            )
+        }
+    }
+
+    fun init() {
+        BetterFoliage.blockSprites.providers.add(this)
+    }
+}
+
+class RenderCactus : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    val cactusStemRadius = 0.4375
+    val cactusArmRotation = listOf(NORTH, SOUTH, EAST, WEST).map { Rotation.rot90[it.ordinal] }
+
+    val iconCross by sprite(Identifier(BetterFoliageMod.MOD_ID, "blocks/better_cactus"))
+    val iconArm = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_cactus_arm_$idx") }
+
+    val modelStem = model {
+        horizontalRectangle(x1 = -cactusStemRadius, x2 = cactusStemRadius, z1 = -cactusStemRadius, z2 = cactusStemRadius, y = 0.5)
+        .scaleUV(cactusStemRadius * 2.0)
+        .let { listOf(it.flipped.move(1.0 to DOWN), it) }
+        .forEach { it.setAoShader(faceOrientedAuto(corner = cornerAo(Axis.Y), edge = null)).add() }
+
+        verticalRectangle(x1 = -0.5, z1 = cactusStemRadius, x2 = 0.5, z2 = cactusStemRadius, yBottom = -0.5, yTop = 0.5)
+        .setAoShader(faceOrientedAuto(corner = cornerAo(Axis.Y), edge = null))
+        .toCross(UP).addAll()
+    }
+    val modelCross = modelSet(64) { modelIdx ->
+        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -0.5 * 1.41, yTop = 0.5 * 1.41)
+        .setAoShader(edgeOrientedAuto(corner = cornerAoMaxGreen))
+        .scale(1.4)
+        .transformV { v ->
+            val perturb = xzDisk(modelIdx) * Config.cactus.sizeVariation
+            Vertex(v.xyz + (if (v.uv.u < 0.0) perturb else -perturb), v.uv, v.aoShader)
+        }
+        .toCross(UP).addAll()
+    }
+    val modelArm = modelSet(64) { modelIdx ->
+        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.0, yTop = 1.0)
+        .scale(Config.cactus.size).move(0.5 to UP)
+
+        .setAoShader(faceOrientedAuto(overrideFace = UP, corner = cornerAo(Axis.Y), edge = null))
+        .toCross(UP) { it.move(xzDisk(modelIdx) * Config.cactus.hOffset) }.addAll()
+    }
+
+    override fun isEligible(ctx: CombinedContext): Boolean =
+        Config.enabled && Config.cactus.enabled &&
+        AsyncCactusDiscovery[ctx] != null
+
+    override val onlyOnCutout get() = true
+
+    override fun render(ctx: CombinedContext) {
+        val icons = AsyncCactusDiscovery[ctx]!!
+
+        ctx.render(
+            modelStem.model,
+            icon = { ctx, qi, q -> when(qi) {
+                0 -> icons.bottom(ctx, qi, q); 1 -> icons.top(ctx, qi, q); else -> icons.side(ctx, qi, q)
+            } }
+        )
+        ctx.render(
+            modelCross[ctx.semiRandom(0)],
+            icon = { _, _, _ -> iconCross }
+        )
+
+        ctx.render(
+            modelArm[ctx.semiRandom(1)],
+            cactusArmRotation[ctx.semiRandom(2) % 4],
+            icon = { _, _, _ -> iconArm[ctx.semiRandom(3)] }
+        )
+    }
+}
@@ -0,0 +1,48 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.DIRT_BLOCKS
+import mods.betterfoliage.render.isSnow
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.up1
+import mods.betterfoliage.render.up2
+import mods.betterfoliage.texture.GrassRegistry
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.horizontalDirections
+import mods.betterfoliage.util.offset
+
+class RenderConnectedGrass : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+    override fun isEligible(ctx: CombinedContext) =
+        Config.enabled && Config.connectedGrass.enabled &&
+        DIRT_BLOCKS.contains(ctx.state.block) &&
+        GrassRegistry[ctx, up1] != null &&
+        (Config.connectedGrass.snowEnabled || !ctx.state(up2).isSnow)
+
+    override fun render(ctx: CombinedContext) {
+        // if the block sides are not visible anyway, render normally
+        if (horizontalDirections.none { ctx.shouldSideBeRendered(it) }) {
+            ctx.render()
+        } else {
+            ctx.exchange(Int3.zero, up1).exchange(up1, up2).render()
+        }
+    }
+}
+
+class RenderConnectedGrassLog : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    override fun isEligible(ctx: CombinedContext) =
+        Config.enabled && Config.roundLogs.enabled && Config.roundLogs.connectGrass &&
+                DIRT_BLOCKS.contains(ctx.state.block) &&
+        LogRegistry[ctx, up1] != null
+
+    override fun render(ctx: CombinedContext) {
+        val grassDir = horizontalDirections.find { GrassRegistry[ctx, it.offset] != null }
+        if (grassDir == null) {
+            ctx.render()
+        } else {
+            ctx.exchange(Int3.zero, grassDir.offset).render()
+        }
+    }
+}
@@ -0,0 +1,69 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerFlat
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.rotationFromUp
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.up1
+import mods.betterfoliage.render.up2
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.randomD
+import net.minecraft.block.material.Material
+import net.minecraft.tags.BlockTags
+import net.minecraft.util.Direction.Axis
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
+import net.minecraft.world.biome.Biome
+
+class RenderCoral : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    val noise = simplexNoise()
+
+    val coralIcons = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_coral_$idx") }
+    val crustIcons = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_crust_$idx") }
+    val coralModels = modelSet(64) { modelIdx ->
+        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.0, yTop = 1.0)
+        .scale(Config.coral.size).move(0.5 to UP)
+        .toCross(UP) { it.move(xzDisk(modelIdx) * Config.coral.hOffset) }.addAll()
+
+        val separation = randomD(0.01, Config.coral.vOffset)
+        horizontalRectangle(x1 = -0.5, x2 = 0.5, z1 = -0.5, z2 = 0.5, y = 0.0)
+        .scale(Config.coral.crustSize).move(0.5 + separation to UP).add()
+
+        transformQ {
+            it.setAoShader(faceOrientedAuto(overrideFace = UP, corner = cornerAo(Axis.Y)))
+            .setFlatShader(faceOrientedAuto(overrideFace = UP, corner = cornerFlat))
+        }
+    }
+
+    override fun isEligible(ctx: CombinedContext) =
+        Config.enabled && Config.coral.enabled &&
+        (ctx.state(up2).material == Material.WATER || Config.coral.shallowWater) &&
+        ctx.state(up1).material == Material.WATER &&
+        BlockTags.SAND.contains(ctx.state.block) &&
+        ctx.biome?.category
+            .let { it == Biome.Category.OCEAN || it == Biome.Category.BEACH } &&
+            noise[ctx.pos] < Config.coral.population
+
+    override fun render(ctx: CombinedContext) {
+        val baseRender = ctx.render()
+        if (!ctx.isCutout) return
+
+        allDirections.forEachIndexed { idx, face ->
+            if (ctx.state(face).material == Material.WATER && ctx.semiRandom(idx) < Config.coral.chance) {
+                var variation = ctx.semiRandom(6)
+                ctx.render(
+                    coralModels[variation++],
+                    rotationFromUp[idx],
+                    icon = { _, qi, _ -> if (qi == 4) crustIcons[variation] else coralIcons[variation + (qi and 1)] }
+                )
+            }
+        }
+    }
+}
@@ -0,0 +1,105 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.OptifineCustomColors
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.render.DIRT_BLOCKS
+import mods.betterfoliage.render.down1
+import mods.betterfoliage.render.isSnow
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.generated.GeneratedGrass
+import mods.betterfoliage.texture.GrassRegistry
+import mods.betterfoliage.render.old.Model
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.old.fullCube
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerFlat
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.snowOffset
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.randomD
+import net.minecraft.util.Direction.*
+
+class RenderGrass : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    companion object {
+        @JvmStatic fun grassTopQuads(heightMin: Double, heightMax: Double): Model.(Int)->Unit = { modelIdx ->
+            verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.5,
+                    yTop = 0.5 + randomD(heightMin, heightMax)
+            )
+            .setAoShader(faceOrientedAuto(overrideFace = UP, corner = cornerAo(Axis.Y)))
+            .setFlatShader(faceOrientedAuto(overrideFace = UP, corner = cornerFlat))
+            .toCross(UP) { it.move(xzDisk(modelIdx) * Config.shortGrass.hOffset) }.addAll()
+        }
+    }
+
+    val noise = simplexNoise()
+
+    val normalIcons = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_grass_long_$idx") }
+    val snowedIcons = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_grass_snowed_$idx") }
+    val normalGenIcon by sprite { GeneratedGrass(sprite = "minecraft:blocks/tall_grass_top", isSnowed = false).register(BetterFoliage.asyncPack) }
+    val snowedGenIcon by sprite { GeneratedGrass(sprite = "minecraft:blocks/tall_grass_top", isSnowed = true).register(BetterFoliage.asyncPack) }
+
+    val grassModels = modelSet(64) { idx -> grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax)(idx) }
+
+    override fun isEligible(ctx: CombinedContext) =
+        Config.enabled &&
+        (Config.shortGrass.grassEnabled || Config.connectedGrass.enabled) &&
+        GrassRegistry[ctx] != null
+
+    override val onlyOnCutout get() = true
+
+    override fun render(ctx: CombinedContext) {
+        val isConnected = DIRT_BLOCKS.contains(ctx.state(DOWN).block) || GrassRegistry[ctx, down1] != null
+        val isSnowed = ctx.state(UP).isSnow
+        val connectedGrass = isConnected && Config.connectedGrass.enabled && (!isSnowed || Config.connectedGrass.snowEnabled)
+
+        val grass = GrassRegistry[ctx]!!
+        val blockColor = OptifineCustomColors.getBlockColor(ctx)
+
+        if (connectedGrass) {
+            // check occlusion
+            val isVisible = allDirections.map { ctx.shouldSideBeRendered(it) }
+
+            // render full grass block
+            ctx.render(
+                fullCube,
+                quadFilter = { qi, _ -> isVisible[qi] },
+                icon = { _, _, _ -> grass.grassTopTexture },
+                postProcess = { ctx, _, _, _, _ ->
+                    rotateUV(2)
+                    if (isSnowed) {
+                        if (!ctx.aoEnabled) setGrey(1.4f)
+                    } else if (ctx.aoEnabled && grass.overrideColor == null) multiplyColor(blockColor)
+                }
+            )
+        } else {
+            ctx.render()
+        }
+
+        if (!Config.shortGrass.grassEnabled) return
+        if (isSnowed && !Config.shortGrass.snowEnabled) return
+        if (ctx.offset(UP).isNormalCube) return
+        if (Config.shortGrass.population < 64 && noise[ctx.pos] >= Config.shortGrass.population) return
+
+        // render grass quads
+        val iconset = if (isSnowed) snowedIcons else normalIcons
+        val iconGen = if (isSnowed) snowedGenIcon else normalGenIcon
+        val rand = ctx.semiRandomArray(2)
+
+        ShadersModIntegration.grass(ctx, Config.shortGrass.shaderWind) {
+            ctx.render(
+                grassModels[rand[0]],
+                translation = ctx.blockCenter + (if (isSnowed) snowOffset else Double3.zero),
+                icon = { _, qi, _ -> if (Config.shortGrass.useGenerated) iconGen else iconset[rand[qi and 1]] },
+                postProcess = { _, _, _, _, _ -> if (isSnowed) setGrey(1.0f) else multiplyColor(grass.overrideColor ?: blockColor) }
+            )
+        }
+    }
+}
@@ -0,0 +1,83 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.OptifineCustomColors
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.render.denseLeavesRot
+import mods.betterfoliage.render.isSnow
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.texture.LeafRegistry
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.lighting.FlatOffset
+import mods.betterfoliage.render.lighting.cornerAoMaxGreen
+import mods.betterfoliage.render.lighting.edgeOrientedAuto
+import mods.betterfoliage.render.normalLeavesRot
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.whitewash
+import mods.betterfoliage.util.Double3
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.PI2
+import mods.betterfoliage.util.allDirections
+import mods.betterfoliage.util.randomD
+import mods.betterfoliage.util.vec
+import net.minecraft.util.Direction.UP
+import java.lang.Math.cos
+import java.lang.Math.sin
+
+class RenderLeaves : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    val leavesModel = model {
+        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -0.5 * 1.41, yTop = 0.5 * 1.41)
+        .setAoShader(edgeOrientedAuto(corner = cornerAoMaxGreen))
+        .setFlatShader(FlatOffset(Int3.zero))
+        .scale(Config.leaves.size)
+        .toCross(UP).addAll()
+    }
+    val snowedIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_leaves_snowed_$idx") }
+
+    val perturbs = vectorSet(64) { idx ->
+        val angle = PI2 * idx / 64.0
+        Double3(cos(angle), 0.0, sin(angle)) * Config.leaves.hOffset +
+            UP.vec * randomD(-1.0, 1.0) * Config.leaves.vOffset
+    }
+
+    override fun isEligible(ctx: CombinedContext) =
+        Config.enabled &&
+        Config.leaves.enabled &&
+        LeafRegistry[ctx] != null &&
+        !(Config.leaves.hideInternal && allDirections.all { ctx.offset(it).isNormalCube } )
+
+    override val onlyOnCutout get() = true
+
+    override fun render(ctx: CombinedContext) {
+        val isSnowed = ctx.state(UP).isSnow
+        val leafInfo = LeafRegistry[ctx]!!
+        val blockColor = OptifineCustomColors.getBlockColor(ctx)
+
+        ctx.render(force = true)
+
+        ShadersModIntegration.leaves(ctx) {
+            val rand = ctx.semiRandomArray(2)
+            (if (Config.leaves.dense) denseLeavesRot else normalLeavesRot).forEach { rotation ->
+                ctx.render(
+                    leavesModel.model,
+                    rotation,
+                    translation = ctx.blockCenter + perturbs[rand[0]],
+                    icon = { _, _, _ -> leafInfo.roundLeafTexture },
+                    postProcess = { _, _, _, _, _ ->
+                        rotateUV(rand[1])
+                        multiplyColor(blockColor)
+                    }
+                )
+            }
+            if (isSnowed && Config.leaves.snowEnabled) ctx.render(
+                leavesModel.model,
+                translation = ctx.blockCenter + perturbs[rand[0]],
+                icon = { _, _, _ -> snowedIcon[rand[1]] },
+                postProcess = whitewash
+            )
+        }
+    }
+}
@@ -0,0 +1,58 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.lighting.FlatOffsetNoColor
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.util.Int3
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.Direction.UP
+
+class RenderLilypad : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    val rootModel = model {
+        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = -1.5, yTop = -0.5)
+        .setFlatShader(FlatOffsetNoColor(Int3.zero))
+        .toCross(UP).addAll()
+    }
+    val flowerModel = model {
+        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.0, yTop = 1.0)
+        .scale(0.5).move(0.5 to DOWN)
+        .setFlatShader(FlatOffsetNoColor(Int3.zero))
+        .toCross(UP).addAll()
+    }
+    val rootIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_lilypad_roots_$idx") }
+    val flowerIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_lilypad_flower_$idx") }
+    val perturbs = vectorSet(64) { modelIdx -> xzDisk(modelIdx) * Config.lilypad.hOffset }
+
+    override fun isEligible(ctx: CombinedContext): Boolean =
+        Config.enabled && Config.lilypad.enabled &&
+        BlockConfig.lilypad.matchesClass(ctx.state.block)
+
+    override fun render(ctx: CombinedContext) {
+        ctx.render()
+
+        val rand = ctx.semiRandomArray(5)
+        ShadersModIntegration.grass(ctx) {
+            ctx.render(
+                rootModel.model,
+                translation = ctx.blockCenter.add(perturbs[rand[2]]),
+                forceFlat = true,
+                icon = { ctx, qi, q -> rootIcon[rand[qi and 1]] }
+            )
+        }
+
+        if (rand[3] < Config.lilypad.flowerChance) ctx.render(
+            flowerModel.model,
+            translation = ctx.blockCenter.add(perturbs[rand[4]]),
+            forceFlat = true,
+            icon = { _, _, _ -> flowerIcon[rand[0]] }
+        )
+    }
+}
@@ -0,0 +1,89 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.chunk.ChunkOverlayManager
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.column.AbstractRenderColumn
+import mods.betterfoliage.render.column.ColumnRenderLayer
+import mods.betterfoliage.render.column.ColumnTextureInfo
+import mods.betterfoliage.render.column.SimpleColumnInfo
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.resource.discovery.ConfigurableModelDiscovery
+import mods.betterfoliage.resource.discovery.ModelRenderRegistry
+import mods.betterfoliage.resource.discovery.ModelRenderRegistryRoot
+import mods.octarinecore.client.resource.*
+import mods.betterfoliage.config.ConfigurableBlockMatcher
+import mods.betterfoliage.config.ModelTextureList
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.util.tryDefault
+import net.minecraft.block.BlockState
+import net.minecraft.block.LogBlock
+import net.minecraft.util.Direction.Axis
+import org.apache.logging.log4j.Level
+import java.util.concurrent.CompletableFuture
+
+class RenderLog : AbstractRenderColumn(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    override val renderOnCutout: Boolean get() = false
+
+    override fun isEligible(ctx: CombinedContext) =
+        Config.enabled && Config.roundLogs.enabled &&
+        LogRegistry[ctx] != null
+
+    override val overlayLayer = RoundLogOverlayLayer()
+    override val connectPerpendicular: Boolean get() = Config.roundLogs.connectPerpendicular
+    override val radiusSmall: Double get() = Config.roundLogs.radiusSmall
+    override val radiusLarge: Double get() = Config.roundLogs.radiusLarge
+    init {
+        ChunkOverlayManager.layers.add(overlayLayer)
+    }
+}
+
+class RoundLogOverlayLayer : ColumnRenderLayer() {
+    override val registry: ModelRenderRegistry<ColumnTextureInfo> get() = LogRegistry
+    override val blockPredicate = { state: BlockState -> BlockConfig.logBlocks.matchesClass(state.block) }
+
+    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 LogRegistry : ModelRenderRegistryRoot<ColumnTextureInfo>()
+
+object AsyncLogDiscovery : ConfigurableModelDiscovery<ColumnTextureInfo>() {
+    override val logger = BetterFoliage.logDetail
+    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.logBlocks
+    override val modelTextures: List<ModelTextureList> get() = BlockConfig.logModels.modelList
+
+    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: AtlasFuture): CompletableFuture<ColumnTextureInfo> {
+        val axis = getAxis(state)
+        logger.log(Level.DEBUG, "$logName:       axis $axis")
+        val spriteList = textures.map { atlas.sprite(it) }
+        return atlas.mapAfter {
+            SimpleColumnInfo(
+                axis,
+                spriteList[0].get(),
+                spriteList[1].get(),
+                spriteList.drop(2).map { it.get() }
+            )
+        }
+    }
+
+    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
+        }
+    }
+
+    fun init() {
+        LogRegistry.registries.add(this)
+        BetterFoliage.blockSprites.providers.add(this)
+    }
+}
@@ -0,0 +1,45 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.isSnow
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.old.noPost
+import mods.betterfoliage.render.snowOffset
+import mods.betterfoliage.render.whitewash
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.util.Double3
+import net.minecraft.util.Direction.UP
+
+class RenderMycelium : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    val myceliumIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_mycel_$idx") }
+    val myceliumModel = modelSet(64) { idx -> RenderGrass.grassTopQuads(
+        Config.shortGrass.heightMin,
+        Config.shortGrass.heightMax
+    )(idx) }
+
+    override fun isEligible(ctx: CombinedContext): Boolean {
+        if (!Config.enabled || !Config.shortGrass.myceliumEnabled) return false
+        return BlockConfig.mycelium.matchesClass(ctx.state.block)
+    }
+
+    override fun render(ctx: CombinedContext) {
+        ctx.render()
+        if (!ctx.isCutout) return
+
+        val isSnowed = ctx.state(UP).isSnow
+        if (isSnowed && !Config.shortGrass.snowEnabled) return
+        if (ctx.offset(UP).isNormalCube) return
+        val rand = ctx.semiRandomArray(2)
+
+        ctx.render(
+            myceliumModel[rand[0]],
+            translation = ctx.blockCenter + (if (isSnowed) snowOffset else Double3.zero),
+            icon = { _, qi, _ -> myceliumIcon[rand[qi and 1]] },
+            postProcess = if (isSnowed) whitewash else noPost
+        )
+    }
+}
@@ -0,0 +1,44 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.render.lighting.cornerAo
+import mods.betterfoliage.render.lighting.cornerFlat
+import mods.betterfoliage.render.lighting.faceOrientedAuto
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.util.randomD
+import net.minecraft.block.Blocks
+import net.minecraft.util.Direction.Axis
+import net.minecraft.util.Direction.*
+
+class RenderNetherrack : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    val netherrackIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_netherrack_$idx") }
+    val netherrackModel = modelSet(64) { modelIdx ->
+        verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yTop = -0.5,
+        yBottom = -0.5 - randomD(Config.netherrack.heightMin, Config.netherrack.heightMax))
+        .setAoShader(faceOrientedAuto(overrideFace = DOWN, corner = cornerAo(Axis.Y)))
+        .setFlatShader(faceOrientedAuto(overrideFace = DOWN, corner = cornerFlat))
+        .toCross(UP) { it.move(xzDisk(modelIdx) * Config.shortGrass.hOffset) }.addAll()
+
+    }
+
+    override fun isEligible(ctx: CombinedContext) =
+        Config.enabled && Config.netherrack.enabled && ctx.state.block == Blocks.NETHERRACK
+
+    override fun render(ctx: CombinedContext) {
+        ctx.render()
+        if (!ctx.isCutout) return
+        if (ctx.offset(DOWN).isNormalCube) return
+
+        val rand = ctx.semiRandomArray(2)
+        ctx.render(
+            netherrackModel[rand[0]],
+            icon = { _, qi, _ -> netherrackIcon[rand[qi and 1]] }
+        )
+    }
+}
@@ -0,0 +1,70 @@
+package mods.betterfoliage.render.block.vanillaold
+
+import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
+import mods.betterfoliage.config.Config
+import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.render.DIRT_BLOCKS
+import mods.betterfoliage.resource.Identifier
+import mods.betterfoliage.render.old.RenderDecorator
+import mods.betterfoliage.render.lighting.FlatOffsetNoColor
+import mods.betterfoliage.render.old.CombinedContext
+import mods.betterfoliage.render.toCross
+import mods.betterfoliage.render.up1
+import mods.betterfoliage.render.up2
+import mods.betterfoliage.render.xzDisk
+import mods.betterfoliage.resource.generated.CenteredSprite
+import mods.betterfoliage.util.randomD
+import net.minecraft.block.material.Material
+import net.minecraft.util.Direction.UP
+
+class RenderReeds : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
+
+    val noise = simplexNoise()
+    val reedIcons = spriteSetTransformed(
+        check = { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_reed_$idx")},
+        register = { CenteredSprite(it).register(BetterFoliage.asyncPack) }
+    )
+    val reedModels = modelSet(64) { modelIdx ->
+        val height = randomD(Config.reed.heightMin, Config.reed.heightMax)
+        val waterline = 0.875f
+        val vCutLine = 0.5 - waterline / height
+        listOf(
+            // below waterline
+            verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.5, yTop = 0.5 + waterline)
+            .setFlatShader(FlatOffsetNoColor(up1)).clampUV(minV = vCutLine),
+
+            // above waterline
+            verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yBottom = 0.5 + waterline, yTop = 0.5 + height)
+            .setFlatShader(FlatOffsetNoColor(up2)).clampUV(maxV = vCutLine)
+        ).forEach {
+            it.clampUV(minU = -0.25, maxU = 0.25)
+            .toCross(UP) { it.move(xzDisk(modelIdx) * Config.reed.hOffset) }.addAll()
+        }
+    }
+
+    override fun isEligible(ctx: CombinedContext) =
+        Config.enabled && Config.reed.enabled &&
+        ctx.state(up2).material == Material.AIR &&
+        ctx.state(UP).material == Material.WATER &&
+        DIRT_BLOCKS.contains(ctx.state.block) &&
+        ctx.biome
+            ?.let { it.downfall > Config.reed.minBiomeRainfall && it.defaultTemperature >= Config.reed.minBiomeTemp } ?: false &&
+            noise[ctx.pos] < Config.reed.population
+
+    override val onlyOnCutout get() = false
+
+    override fun render(ctx: CombinedContext) {
+        ctx.render()
+        if (!ctx.isCutout) return
+
+        val iconVar = ctx.semiRandom(1)
+        ShadersModIntegration.grass(ctx, Config.reed.shaderWind) {
+            ctx.render(
+                reedModels[ctx.semiRandom(0)],
+                forceFlat = true,
+                icon = { _, _, _ -> reedIcons[iconVar] }
+            )
+        }
+    }
+}