[WIP] major rewrite, grass and leaves working already

src/main/kotlin/mods/betterfoliage/resource/discovery/ModelReplacer.kt

@@ -0,0 +1,121 @@
+package mods.betterfoliage.resource.discovery
+
+import com.google.common.base.Joiner
+import mods.betterfoliage.config.IBlockMatcher
+import mods.betterfoliage.config.ModelTextureList
+import mods.betterfoliage.util.HasLogger
+import net.minecraft.block.BlockState
+import net.minecraft.client.renderer.BlockModelShapes
+import net.minecraft.client.renderer.model.BlockModel
+import net.minecraft.client.renderer.model.ModelBakery
+import net.minecraft.client.renderer.model.VariantList
+import net.minecraft.client.renderer.model.multipart.Multipart
+import net.minecraft.client.renderer.texture.MissingTextureSprite
+import net.minecraft.util.ResourceLocation
+import net.minecraftforge.registries.ForgeRegistries
+import org.apache.logging.log4j.Level
+
+abstract class ModelReplacer : HasLogger(), ModelDiscovery {
+    override fun onModelsLoaded(
+        bakery: ModelBakery,
+        sprites: MutableSet<ResourceLocation>,
+        replacements: MutableMap<ResourceLocation, ModelBakeKey>
+    ) {
+        ForgeRegistries.BLOCKS
+            .flatMap { block -> block.stateContainer.validStates }
+            .forEach { state ->
+                val location = BlockModelShapes.getModelLocation(state)
+                try {
+                    val hasReplaced = processModel(bakery, state, location, sprites, replacements)
+                } catch (e: Exception) {
+                    logger.log(Level.WARN, "Discovery error in $location", e)
+                }
+            }
+    }
+
+    open fun processModel(
+        bakery: ModelBakery,
+        state: BlockState,
+        location: ResourceLocation,
+        sprites: MutableSet<ResourceLocation>,
+        replacements: MutableMap<ResourceLocation, ModelBakeKey>
+    ): Boolean {
+        // built-in support for container models
+        return when (val model = bakery.getUnbakedModel(location)) {
+            is VariantList -> {
+                val hasReplaced = model.variantList.fold(false) { hasReplaced, variant ->
+                    processModel(bakery, state, variant.modelLocation, sprites, replacements) || hasReplaced
+                }
+                if (hasReplaced) replacements[location]
+                hasReplaced
+            }
+            is Multipart -> model.variants.fold(false) { hasReplaced, variantList ->
+                variantList.variantList.fold(false) { hasReplaced, variant ->
+                    processModel(bakery, state, variant.modelLocation, sprites, replacements) || hasReplaced
+                } || hasReplaced
+            }
+            else -> false
+        }
+    }
+}
+
+
+
+abstract class ConfigurableModelReplacer : ModelReplacer() {
+    abstract val matchClasses: IBlockMatcher
+    abstract val modelTextures: List<ModelTextureList>
+
+    abstract fun processModel(
+        state: BlockState,
+        location: ResourceLocation,
+        textureMatch: List<ResourceLocation>,
+        sprites: MutableSet<ResourceLocation>,
+        replacements: MutableMap<ResourceLocation, ModelBakeKey>
+    ): Boolean
+
+    override fun processModel(
+        bakery: ModelBakery,
+        state: BlockState,
+        location: ResourceLocation,
+        sprites: MutableSet<ResourceLocation>,
+        replacements: MutableMap<ResourceLocation, ModelBakeKey>
+    ): Boolean {
+        val model = bakery.getUnbakedModel(location)
+        if (model is BlockModel) {
+            val matchClass = matchClasses.matchingClass(state.block) ?: return false
+
+            detailLogger.log(Level.INFO, "block state $state")
+            detailLogger.log(Level.INFO, "      model $location")
+            replacements[location]?.let { existing ->
+                detailLogger.log(Level.INFO, "      already processed as $existing")
+                return true
+            }
+
+            detailLogger.log(Level.INFO, "      class ${state.block.javaClass.name} matches ${matchClass.name}")
+
+            modelTextures
+                .filter { matcher -> bakery.modelDerivesFrom(model, location, matcher.modelLocation) }
+                .forEach { match ->
+                    detailLogger.log(Level.INFO, "      model ${model} matches ${match.modelLocation}")
+
+                    val materials = match.textureNames.map { it to model.resolveTextureName(it) }
+                    val texMapString = Joiner.on(", ").join(materials.map { "${it.first}=${it.second.textureLocation}" })
+                    detailLogger.log(Level.INFO, "    sprites [$texMapString]")
+
+                    if (materials.all { it.second.textureLocation != MissingTextureSprite.getLocation() }) {
+                        // found a valid model (all required textures exist)
+                        if (processModel(state, location, materials.map { it.second.textureLocation }, sprites, replacements))
+                            return true
+                    }
+                }
+        }
+        return super.processModel(bakery, state, location, sprites, replacements)
+    }
+}
+
+fun ModelBakery.modelDerivesFrom(model: BlockModel, location: ResourceLocation, target: ResourceLocation): Boolean =
+    if (location == target) true
+    else model.parentLocation
+        ?.let { getUnbakedModel(it) as? BlockModel }
+        ?.let { parent -> modelDerivesFrom(parent, model.parentLocation!!, target) }
+        ?: false