[WIP] major rewrite, grass and leaves working already

src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxBase.kt

@@ -0,0 +1,43 @@
+package mods.betterfoliage.render.pipeline
+
+import com.mojang.blaze3d.matrix.MatrixStack
+import mods.betterfoliage.chunk.BasicBlockCtx
+import mods.betterfoliage.chunk.BlockCtx
+import mods.betterfoliage.render.old.HalfBakedQuad
+import mods.betterfoliage.util.Int3
+import net.minecraft.block.Block
+import net.minecraft.client.Minecraft
+import net.minecraft.client.renderer.model.IBakedModel
+import net.minecraft.util.Direction
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.ILightReader
+import net.minecraftforge.client.model.data.IModelData
+import java.util.Random
+
+abstract class RenderCtxBase(
+    world: ILightReader,
+    pos: BlockPos,
+    val matrixStack: MatrixStack,
+    val checkSides: Boolean,
+    val random: Random,
+    val modelData: IModelData
+) : BlockCtx by BasicBlockCtx(world, pos) {
+
+    var hasRendered = false
+    val blockModelShapes = Minecraft.getInstance().blockRendererDispatcher.blockModelShapes
+    inline fun Direction?.shouldRender() = this == null || !checkSides || Block.shouldSideBeRendered(state, world, pos, this)
+
+    protected abstract fun renderQuad(quad: HalfBakedQuad)
+    abstract fun renderFallback(model: IBakedModel)
+
+    fun render(quads: Iterable<HalfBakedQuad>) {
+        quads.forEach { quad ->
+            if (quad.raw.face.shouldRender()) {
+                renderQuad(quad)
+                hasRendered = true
+            }
+        }
+    }
+
+    abstract fun renderMasquerade(offset: Int3, func: ()->Unit)
+}

src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxForge.kt

@@ -0,0 +1,77 @@
+package mods.betterfoliage.render.pipeline
+
+import com.mojang.blaze3d.matrix.MatrixStack
+import mods.betterfoliage.render.ISpecialRenderModel
+import mods.betterfoliage.render.lighting.ForgeVertexLighter
+import mods.betterfoliage.render.lighting.ForgeVertexLighterAccess
+import mods.betterfoliage.render.old.HalfBakedQuad
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.directionsAndNull
+import mods.betterfoliage.util.get
+import mods.octarinecore.VertexLighterFlat_blockInfo
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.model.IBakedModel
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.ILightReader
+import net.minecraftforge.client.model.data.IModelData
+import net.minecraftforge.client.model.pipeline.VertexLighterFlat
+import java.util.Random
+
+class RenderCtxForge(
+    world: ILightReader,
+    pos: BlockPos,
+    val lighter: VertexLighterFlat,
+    matrixStack: MatrixStack,
+    checkSides: Boolean,
+    random: Random,
+    modelData: IModelData
+): RenderCtxBase(world, pos, matrixStack, checkSides, random, modelData), ForgeVertexLighterAccess {
+
+    val blockInfo = lighter[VertexLighterFlat_blockInfo]
+    override var vertexLighter: ForgeVertexLighter
+        get() = (lighter as ForgeVertexLighterAccess).vertexLighter
+        set(value) { (lighter as ForgeVertexLighterAccess).vertexLighter = value }
+
+    override fun renderQuad(quad: HalfBakedQuad) { quad.baked.pipe(lighter) }
+
+    override fun renderFallback(model: IBakedModel) {
+        directionsAndNull.forEach { face ->
+            model.getQuads(state, null, random, modelData).forEach { quad ->
+                if (quad.face.shouldRender()) {
+                    quad.pipe(lighter)
+                    hasRendered = true
+                }
+            }
+        }
+    }
+
+    override fun renderMasquerade(offset: Int3, func: () -> Unit) {
+        TODO("Not yet implemented")
+    }
+
+    companion object {
+        @JvmStatic
+        fun render(
+            lighter: VertexLighterFlat,
+            world: ILightReader,
+            model: ISpecialRenderModel,
+            state: BlockState,
+            pos: BlockPos,
+            matrixStack: MatrixStack,
+            checkSides: Boolean,
+            rand: Random, seed: Long,
+            modelData: IModelData
+        ): Boolean {
+            lighter.setWorld(world)
+            lighter.setState(state)
+            lighter.setBlockPos(pos)
+            rand.setSeed(seed)
+            lighter.updateBlockInfo()
+            return RenderCtxForge(world, pos, lighter, matrixStack, checkSides, rand, modelData).let {
+                model.render(it, false)
+                lighter.resetBlockInfo()
+                it.hasRendered
+            }
+        }
+    }
+}

src/main/kotlin/mods/betterfoliage/render/pipeline/RenderCtxVanilla.kt

@@ -0,0 +1,90 @@
+package mods.betterfoliage.render.pipeline
+
+import com.mojang.blaze3d.matrix.MatrixStack
+import com.mojang.blaze3d.vertex.IVertexBuilder
+import mods.betterfoliage.render.ISpecialRenderModel
+import mods.betterfoliage.render.lighting.VanillaFullBlockLighting
+import mods.betterfoliage.render.lighting.VanillaVertexLighter
+import mods.betterfoliage.render.lighting.VanillaQuadLighting
+import mods.betterfoliage.render.old.HalfBakedQuad
+import mods.betterfoliage.util.Int3
+import mods.betterfoliage.util.ThreadLocalDelegate
+import mods.betterfoliage.util.plus
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.BlockModelRenderer
+import net.minecraft.client.renderer.model.IBakedModel
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.ILightReader
+import net.minecraftforge.client.model.data.IModelData
+import java.util.Random
+
+class RenderCtxVanilla(
+    val renderer: BlockModelRenderer,
+    world: ILightReader,
+    pos: BlockPos,
+    val buffer: IVertexBuilder,
+    val combinedOverlay: Int,
+    matrixStack: MatrixStack,
+    checkSides: Boolean,
+    random: Random,
+    val seed: Long,
+    modelData: IModelData,
+    val useAO: Boolean
+): RenderCtxBase(world, pos, matrixStack, checkSides, random, modelData) {
+
+    private val blockColors = renderer.blockColors
+    var vertexLighter: VanillaVertexLighter = VanillaFullBlockLighting
+
+    override fun renderQuad(quad: HalfBakedQuad) {
+        lightingData.let { lighting ->
+            vertexLighter.updateLightmapAndColor(quad, lighting)
+            buffer.addQuad(
+                matrixStack.last, quad.baked,
+                lighting.colorMultiplier,
+                lighting.tint[0], lighting.tint[1], lighting.tint[2],
+                lighting.packedLight, combinedOverlay, true
+            )
+        }
+    }
+
+    override fun renderFallback(model: IBakedModel) {
+        if (useAO) renderer.renderModelSmooth(world, model, state, pos, matrixStack, buffer, checkSides, random, seed, combinedOverlay, modelData)
+        else renderer.renderModelFlat(world, model, state, pos, matrixStack, buffer, checkSides, random, seed, combinedOverlay, modelData)
+    }
+
+    override fun renderMasquerade(offset: Int3, func: () -> Unit) {
+        lightingData.calc.blockPos += offset
+        func()
+        lightingData.calc.blockPos = pos
+    }
+
+    companion object {
+        @JvmStatic
+        fun render(
+            renderer: BlockModelRenderer,
+            world: ILightReader,
+            model: ISpecialRenderModel,
+            state: BlockState,
+            pos: BlockPos,
+            matrixStack: MatrixStack,
+            buffer: IVertexBuilder,
+            checkSides: Boolean,
+            random: Random,
+            rand: Long,
+            combinedOverlay: Int,
+            modelData: IModelData,
+            smooth: Boolean
+        ): Boolean {
+            random.setSeed(rand)
+            val ctx = RenderCtxVanilla(renderer, world, pos, buffer, combinedOverlay, matrixStack, checkSides, random, rand, modelData, smooth)
+            lightingData.apply {
+                calc.reset(ctx)
+                blockColors = renderer.blockColors
+            }
+            model.render(ctx, false)
+            return ctx.hasRendered
+        }
+
+        val lightingData by ThreadLocalDelegate { VanillaQuadLighting() }
+    }
+}