[WIP] adopt model replacement from Forge vesion

+ bunch of renames to bring the 2 version closer
+ at-least-not-crashing levels of Optifine support

src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt

@@ -2,7 +2,8 @@ package mods.betterfoliage.render.block.vanilla
 
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.chunk.BasicBlockCtx
-import mods.betterfoliage.render.SNOW_MATERIALS
+import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.SNOW_MATERIALS
 import mods.betterfoliage.render.ShadersModIntegration
 import mods.betterfoliage.render.lighting.grassTuftLighting
 import mods.betterfoliage.render.lighting.withLighting
@@ -14,6 +15,7 @@ import net.fabricmc.fabric.api.renderer.v1.model.FabricBakedModel
 import net.fabricmc.fabric.api.renderer.v1.render.RenderContext
 import net.minecraft.block.BlockState
 import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.render.model.BasicBakedModel
 import net.minecraft.util.Identifier
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction.*
@@ -22,32 +24,32 @@ import java.util.*
 import java.util.function.Consumer
 import java.util.function.Supplier
 
-interface GrassKey : BlockRenderKey {
-    val grassTopTexture: Identifier
-
-    /**
-     * Color to use for Short Grass rendering instead of the biome color.
-     *
-     * Value is null if the texture is mostly grey (the saturation of its average color is under a configurable limit),
-     * the average color of the texture otherwise.
-     */
-    val overrideColor: Int?
-}
-
 object StandardGrassDiscovery : ConfigurableModelDiscovery() {
-    override val logger = BetterFoliage.logDetail
     override val matchClasses: ConfigurableBlockMatcher get() = BetterFoliage.blockConfig.grassBlocks
     override val modelTextures: List<ModelTextureList> get() = BetterFoliage.blockConfig.grassModels.modelList
 
-    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: Consumer<Identifier>): BlockRenderKey? {
-        val grassId = textures[0]
-        log(" block state $state")
-        log("       texture $grassId")
-        return GrassBlockModel.Key(grassId, getAndLogColorOverride(grassId, Atlas.BLOCKS, BetterFoliage.config.shortGrass.saturationThreshold))
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<Identifier>) {
+        ctx.addReplacement(StandardGrassKey(textureMatch[0], null))
+        BetterFoliage.blockTypes.grass.add(ctx.blockState)
     }
 }
 
-class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wrapped), FabricBakedModel {
+data class StandardGrassKey(
+    val grassLocation: Identifier,
+    val overrideColor: Color?
+) : ModelWrapKey() {
+    val tintIndex: Int get() = if (overrideColor == null) 0 else -1
+
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel): BakedModel {
+        val grassSpriteColor = Atlas.BLOCKS[grassLocation].averageColor.let { hsb ->
+            logColorOverride(detailLogger, BetterFoliage.config.shortGrass.saturationThreshold, hsb)
+            hsb.colorOverride(BetterFoliage.config.shortGrass.saturationThreshold)
+        }
+        return StandardGrassModel(meshifyCutoutMipped(wrapped), this.copy(overrideColor = grassSpriteColor))
+    }
+}
+
+class StandardGrassModel(wrapped: BakedModel, val key: StandardGrassKey) : WrappedBakedModel(wrapped) {
 
     val tuftNormal by grassTuftMeshesNormal.delegate(key)
     val tuftSnowed by grassTuftMeshesSnowed.delegate(key)
@@ -64,9 +66,8 @@ class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wra
 
         val isSnowed = stateAbove.material in SNOW_MATERIALS
         val connected = BetterFoliage.config.connectedGrass.enabled &&
-            (!isSnowed || BetterFoliage.config.connectedGrass.snowEnabled) && (
-                BetterFoliage.modelReplacer[stateBelow].let { it is DirtKey || it is GrassKey }
-            )
+            (!isSnowed || BetterFoliage.config.connectedGrass.snowEnabled) &&
+            (stateBelow in BetterFoliage.blockTypes.dirt || stateBelow in BetterFoliage.blockTypes.grass)
 
         val random = randomSupplier.get()
         if (connected) {
@@ -84,13 +85,6 @@ class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wra
         }
     }
 
-    data class Key(
-        override val grassTopTexture: Identifier,
-        override val overrideColor: Int?
-    ) : GrassKey {
-        override fun replace(model: BakedModel, state: BlockState) = GrassBlockModel(this, meshifyStandard(model, state))
-    }
-
     companion object {
         val grassTuftSpritesNormal by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             Identifier(BetterFoliage.MOD_ID, "blocks/better_grass_long_$idx")
@@ -98,23 +92,23 @@ class GrassBlockModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wra
         val grassTuftSpritesSnowed by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             Identifier(BetterFoliage.MOD_ID, "blocks/better_grass_long_$idx")
         }
-        val grassTuftShapes = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
+        val grassTuftShapes = LazyMap(BakeWrapperManager) { key: StandardGrassKey ->
             BetterFoliage.config.shortGrass.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
         }
-        val grassTuftMeshesNormal = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
-            tuftModelSet(grassTuftShapes[key], key.overrideColor) { idx -> grassTuftSpritesNormal[randomI()] }
+        val grassTuftMeshesNormal = LazyMap(BakeWrapperManager) { key: StandardGrassKey ->
+            tuftModelSet(grassTuftShapes[key], key.tintIndex) { idx -> grassTuftSpritesNormal[randomI()] }
                 .withOpposites()
                 .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)
         }
-        val grassTuftMeshesSnowed = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
+        val grassTuftMeshesSnowed = LazyMap(BakeWrapperManager) { key: StandardGrassKey ->
             tuftModelSet(grassTuftShapes[key], Color.white.asInt) { idx -> grassTuftSpritesSnowed[randomI()] }
                 .withOpposites()
                 .build(BlendMode.CUTOUT_MIPPED, flatLighting = false)
         }
-        val grassFullBlockMeshes = LazyMap(BetterFoliage.modelReplacer) { key: GrassKey ->
-            Array(64) { fullCubeTextured(key.grassTopTexture, key.overrideColor) }
+        val grassFullBlockMeshes = LazyMap(BakeWrapperManager) { key: StandardGrassKey ->
+            Array(64) { fullCubeTextured(key.grassLocation, key.tintIndex) }
         }
-        val snowFullBlockMeshes by LazyInvalidatable(BetterFoliage.modelReplacer) {
+        val snowFullBlockMeshes by LazyInvalidatable(BakeWrapperManager) {
             Array(64) { fullCubeTextured(Identifier("block/snow"), Color.white.asInt) }
         }
     }