[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/Leaf.kt

@@ -2,76 +2,87 @@ 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.SNOW_MATERIALS
+import mods.betterfoliage.model.Color
+import mods.betterfoliage.model.ModelWrapKey
+import mods.betterfoliage.model.SpriteSetDelegate
+import mods.betterfoliage.model.WrappedBakedModel
+import mods.betterfoliage.model.crossModelsRaw
+import mods.betterfoliage.model.crossModelsTextured
+import mods.betterfoliage.model.meshifyCutoutMipped
 import mods.betterfoliage.render.ShadersModIntegration
-import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.lighting.roundLeafLighting
+import mods.betterfoliage.render.lighting.withLighting
 import mods.betterfoliage.render.particle.LeafParticleRegistry
-import mods.betterfoliage.util.Atlas
-import mods.betterfoliage.resource.discovery.*
+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.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ModelTextureList
 import mods.betterfoliage.resource.generated.GeneratedLeafSprite
-import mods.betterfoliage.model.*
-import mods.betterfoliage.util.*
-import net.fabricmc.fabric.api.renderer.v1.material.BlendMode
-import net.fabricmc.fabric.api.renderer.v1.model.FabricBakedModel
+import mods.betterfoliage.util.Atlas
+import mods.betterfoliage.util.LazyMap
+import mods.betterfoliage.util.averageColor
+import mods.betterfoliage.util.colorOverride
+import mods.betterfoliage.util.get
+import mods.betterfoliage.util.logColorOverride
 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.*
+import net.minecraft.util.math.Direction.UP
 import net.minecraft.world.BlockRenderView
-import java.util.*
-import java.util.function.Consumer
+import org.apache.logging.log4j.Level
+import java.util.Random
 import java.util.function.Supplier
 
-interface LeafKey : BlockRenderKey {
-    val roundLeafTexture: Identifier
+interface LeafBlockModel {
+    val key: LeafParticleKey
+}
 
-    /** Type of the leaf block (configurable by user). */
+interface LeafParticleKey {
     val leafType: String
-
-    /** Average color of the round leaf texture. */
-    val overrideColor: Int?
+    val overrideColor: Color?
 }
 
 object StandardLeafDiscovery : ConfigurableModelDiscovery() {
-    override val logger = BetterFoliage.logDetail
     override val matchClasses: ConfigurableBlockMatcher get() = BetterFoliage.blockConfig.leafBlocks
     override val modelTextures: List<ModelTextureList> get() = BetterFoliage.blockConfig.leafModels.modelList
 
-    override fun processModel(state: BlockState, textures: List<Identifier>, atlas: Consumer<Identifier>) =
-        defaultRegisterLeaf(textures[0], atlas)
+    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<Identifier>) {
+        val leafType = LeafParticleRegistry.typeMappings.getType(textureMatch[0]) ?: "default"
+        val generated = GeneratedLeafSprite(textureMatch[0], leafType)
+            .register(BetterFoliage.generatedPack)
+            .apply { ctx.sprites.add(this) }
 
-}
-
-fun HasLogger.defaultRegisterLeaf(sprite: Identifier, atlas: Consumer<Identifier>): BlockRenderKey? {
-    val leafType = LeafParticleRegistry.typeMappings.getType(sprite) ?: "default"
-    val leafId = GeneratedLeafSprite(sprite, leafType).register(BetterFoliage.generatedPack)
-    atlas.accept(leafId)
-
-    log(" leaf texture $sprite")
-    log("     particle $leafType")
-
-    return NormalLeavesModel.Key(
-        leafId, leafType,
-        getAndLogColorOverride(leafId, Atlas.BLOCKS, BetterFoliage.config.shortGrass.saturationThreshold)
-    )
-}
-
-fun HasLogger.getAndLogColorOverride(sprite: Identifier, atlas: Atlas, threshold: Double): Int? {
-    val hsb = resourceManager.averageImageColorHSB(sprite, atlas)
-    return if (hsb.saturation >= threshold) {
-        log("         brightness ${hsb.brightness}")
-        log("         saturation ${hsb.saturation} >= ${threshold}, using texture color")
-        hsb.copy(brightness = 0.9f.coerceAtMost(hsb.brightness * 2.0f)).asColor
-    } else {
-        log("         saturation ${hsb.saturation} < ${threshold}, using block color")
-        null
+        detailLogger.log(Level.INFO, "     particle $leafType")
+        ctx.addReplacement(StandardLeafKey(generated, leafType, null))
     }
 }
 
-class NormalLeavesModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(wrapped), FabricBakedModel {
+data class StandardLeafKey(
+    val roundLeafTexture: Identifier,
+    override val leafType: String,
+    override val overrideColor: Color?
+) : ModelWrapKey(), LeafParticleKey {
+    val tintIndex: Int get() = if (overrideColor == null) 0 else -1
+
+    override fun bake(ctx: ModelBakingContext, wrapped: BasicBakedModel): BakedModel {
+        val leafSpriteColor = Atlas.BLOCKS[roundLeafTexture].averageColor.let { hsb ->
+            logColorOverride(detailLogger, BetterFoliage.config.leaves.saturationThreshold, hsb)
+            hsb.colorOverride(BetterFoliage.config.leaves.saturationThreshold)
+        }
+        return StandardLeafModel(meshifyCutoutMipped(wrapped), this.copy(overrideColor = leafSpriteColor))
+    }
+}
+
+class StandardLeafModel(
+    wrapped: BakedModel,
+    override val key: StandardLeafKey
+) : WrappedBakedModel(wrapped), LeafBlockModel {
 
     val leafNormal by leafModelsNormal.delegate(key)
     val leafSnowed by leafModelsSnowed.delegate(key)
@@ -94,26 +105,18 @@ class NormalLeavesModel(val key: Key, wrapped: BakedModel) : WrappedBakedModel(w
         }
     }
 
-    data class Key(
-        override val roundLeafTexture: Identifier,
-        override val leafType: String,
-        override val overrideColor: Int?
-    ) : LeafKey {
-        override fun replace(model: BakedModel, state: BlockState) = NormalLeavesModel(this, meshifyStandard(model, state, blendModeOverride = BlendMode.CUTOUT_MIPPED))
-    }
-
     companion object {
         val leafSpritesSnowed by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             Identifier(BetterFoliage.MOD_ID, "blocks/better_leaves_snowed_$idx")
         }
-        val leafModelsBase = LazyMap(BetterFoliage.modelReplacer) { key: LeafKey ->
+        val leafModelsBase = LazyMap(BakeWrapperManager) { key: StandardLeafKey ->
             BetterFoliage.config.leaves.let { crossModelsRaw(64, it.size, it.hOffset, it.vOffset) }
         }
-        val leafModelsNormal = LazyMap(BetterFoliage.modelReplacer) { key: LeafKey ->
-            crossModelsTextured(leafModelsBase[key], key.overrideColor, true) { Atlas.BLOCKS.atlas[key.roundLeafTexture]!! }
+        val leafModelsNormal = LazyMap(BakeWrapperManager) { key: StandardLeafKey ->
+            crossModelsTextured(leafModelsBase[key], key.tintIndex, true) { key.roundLeafTexture }
         }
-        val leafModelsSnowed = LazyMap(BetterFoliage.modelReplacer) { key: LeafKey ->
-            crossModelsTextured(leafModelsBase[key], Color.white.asInt, false) { leafSpritesSnowed[it] }
+        val leafModelsSnowed = LazyMap(BakeWrapperManager) { key: StandardLeafKey ->
+            crossModelsTextured(leafModelsBase[key], Color.white.asInt, false) { leafSpritesSnowed[it].id }
         }
     }
 }