use new config parser

+BakeWrapperManager no longer singleton

src/main/java/mods/betterfoliage/mixin/MixinModelBakery.java

@@ -1,5 +1,6 @@
 package mods.betterfoliage.mixin;
 
+import mods.betterfoliage.BetterFoliage;
 import mods.betterfoliage.BetterFoliageMod;
 import mods.betterfoliage.resource.discovery.BakeWrapperManager;
 import mods.betterfoliage.resource.discovery.ModelDefinitionsLoadedEvent;
@@ -38,6 +39,6 @@ abstract public class MixinModelBakery {
             IModelTransform transform,
             ResourceLocation locationIn
     ) {
-        return BakeWrapperManager.INSTANCE.onBake(unbaked, bakery, spriteGetter, transform, locationIn);
+        return BetterFoliage.INSTANCE.getModelManager().onBake(unbaked, bakery, spriteGetter, transform, locationIn);
     }
 }

src/main/kotlin/mods/betterfoliage/BetterFoliage.kt

@@ -2,6 +2,7 @@ package mods.betterfoliage
 
 import mods.betterfoliage.chunk.ChunkOverlayManager
 import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.BlockConfigOld
 import mods.betterfoliage.integration.OptifineCustomColors
 import mods.betterfoliage.integration.ShadersModIntegration
 import mods.betterfoliage.render.block.vanilla.RoundLogOverlayLayer
@@ -27,15 +28,12 @@ import mods.betterfoliage.render.lighting.AoSideHelper
 import mods.betterfoliage.render.particle.LeafWindTracker
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
 import mods.betterfoliage.resource.discovery.BlockTypeCache
-import mods.betterfoliage.resource.discovery.ModelDefinitionsLoadedEvent
 import mods.betterfoliage.resource.generated.GeneratedTexturePack
 import mods.betterfoliage.render.particle.LeafParticleRegistry
 import mods.betterfoliage.render.particle.RisingSoulParticle
+import mods.betterfoliage.resource.discovery.RuleBasedDiscovery
 import mods.betterfoliage.util.resourceManager
 import net.minecraft.block.BlockState
-import net.minecraft.client.Minecraft
-import net.minecraft.resources.IReloadableResourceManager
-import net.minecraftforge.eventbus.api.SubscribeEvent
 
 /**
  * Object responsible for initializing (and holding a reference to) all the infrastructure of the mod
@@ -48,9 +46,26 @@ object BetterFoliage {
     /** List of recognized [BlockState]s */
     var blockTypes = BlockTypeCache()
 
+    val blockConfig = BlockConfig()
+
+    val standardModelSupport = RuleBasedDiscovery().apply {
+        discoverers["cactus"] = StandardCactusDiscovery
+        discoverers["dirt"] = StandardDirtDiscovery
+        discoverers["grass"] = StandardGrassDiscovery
+        discoverers["leaf"] = StandardLeafDiscovery
+        discoverers["lilypad"] = StandardLilypadDiscovery
+        discoverers["mycelium"] = StandardMyceliumDiscovery
+        discoverers["netherrack"] = StandardNetherrackDiscovery
+        discoverers["round-log"] = StandardRoundLogDiscovery
+        discoverers["sand"] = StandardSandDiscovery
+    }
+    val modelManager = BakeWrapperManager().apply {
+        discoverers.add(standardModelSupport)
+    }
+
     fun init() {
         // discoverers
-        BetterFoliageMod.bus.register(BakeWrapperManager)
+        BetterFoliageMod.bus.register(modelManager)
         BetterFoliageMod.bus.register(LeafParticleRegistry)
         resourceManager.registerReloadListener(LeafParticleRegistry)
 
@@ -58,22 +73,15 @@ object BetterFoliage {
 
         listOf(
             StandardLeafDiscovery,
-            StandardGrassDiscovery,
-            StandardDirtDiscovery,
-            StandardMyceliumDiscovery,
             StandardSandDiscovery,
-            StandardLilypadDiscovery,
+            StandardRoundLogDiscovery,
-            StandardCactusDiscovery,
-            StandardNetherrackDiscovery,
-            StandardRoundLogDiscovery
         ).forEach {
-            BakeWrapperManager.discoverers.add(it)
         }
 
         // init singletons
         val singletons = listOf(
             AoSideHelper,
-            BlockConfig,
+            BlockConfigOld,
             ChunkOverlayManager,
             LeafWindTracker
         )

src/main/kotlin/mods/betterfoliage/integration/ShadersModIntegration.kt

@@ -1,5 +1,6 @@
 package mods.betterfoliage.integration
 
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.render.pipeline.RenderCtxBase
 import mods.betterfoliage.render.pipeline.RenderCtxVanilla
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
@@ -50,8 +51,8 @@ object ShadersModIntegration : HasLogger() {
         logger.log(INFO, "ShadersMod diffuse shading integration is ${if (isDiffuseAvailable) "enabled" else "disabled" }")
         logger.log(INFO, "ShadersMod vertex shader integration is ${if (isEffectsAvailable) "enabled" else "disabled" }")
 
-        // Recalculate the diffsuse shading values used when resources are reloaded
+        // Recalculate the diffuse shading values used when resources are reloaded
-        if (isDiffuseAvailable) BakeWrapperManager.onInvalidate {
+        if (isDiffuseAvailable) BetterFoliage.modelManager.onInvalidate {
             if (Shaders.shaderPackLoaded.getStatic()) {
                 diffuseShades = Direction.values().mapArray { face ->
                     when(face) {

src/main/kotlin/mods/betterfoliage/model/TuftMeshes.kt

@@ -49,13 +49,13 @@ fun tuftQuadSingle(size: Double, height: Double, flipU: Boolean) =
     )
         .mirrorUV(flipU, false)
 
-fun tuftModelSet(shapes: Array<TuftShapeKey>, tintIndex: Int, spriteGetter: (Int) -> TextureAtlasSprite) =
+fun tuftModelSet(shapes: Array<TuftShapeKey>, overrideColor: Color?, spriteGetter: (Int) -> TextureAtlasSprite) =
     shapes.mapIndexed { idx, shape ->
         listOf(
             tuftQuadSingle(shape.size, shape.height, shape.flipU1),
             tuftQuadSingle(shape.size, shape.height, shape.flipU2).rotate(rot(UP))
         ).map { it.move(shape.offset) }
-            .map { it.colorIndex(tintIndex) }
+            .map { it.colorAndIndex(overrideColor) }
             .map { it.sprite(spriteGetter(idx)) }
     }
 

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

@@ -5,6 +5,7 @@ import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.chunk.BlockCtx
 import mods.betterfoliage.config.CACTUS_BLOCKS
 import mods.betterfoliage.config.Config
+import mods.betterfoliage.model.Color
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.SpecialRenderData
@@ -23,11 +24,13 @@ import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
 import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ParametrizedModelDiscovery
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.Rotation
 import mods.betterfoliage.util.horizontalDirections
 import mods.betterfoliage.util.idx
+import mods.betterfoliage.util.lazy
 import mods.betterfoliage.util.randomD
 import mods.betterfoliage.util.randomI
 import net.minecraft.client.renderer.RenderType
@@ -36,15 +39,10 @@ import net.minecraft.util.Direction.DOWN
 import net.minecraft.util.ResourceLocation
 import java.util.Random
 
-object StandardCactusDiscovery : AbstractModelDiscovery() {
+object StandardCactusDiscovery : ParametrizedModelDiscovery() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
-        val model = ctx.getUnbaked()
+        ctx.addReplacement(StandardCactusKey)
-        if (model is BlockModel && ctx.blockState.block in CACTUS_BLOCKS) {
+        ctx.sprites.add(StandardCactusModel.cactusCrossSprite)
-            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
-            ctx.addReplacement(StandardCactusKey)
-            ctx.sprites.add(StandardCactusModel.cactusCrossSprite)
-        }
-        super.processModel(ctx)
     }
 }
 
@@ -83,14 +81,14 @@ class StandardCactusModel(
         val cactusArmSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_cactus_arm_$idx")
         }
-        val cactusArmModels by LazyInvalidatable(BakeWrapperManager) {
+        val cactusArmModels by BetterFoliage.modelManager.lazy {
             val shapes = Config.cactus.let { tuftShapeSet(0.8, 0.8, 0.8, 0.2) }
-            val models = tuftModelSet(shapes, -1) { cactusArmSprites[randomI()] }
+            val models = tuftModelSet(shapes, Color.white) { cactusArmSprites[randomI()] }
             horizontalDirections.map { side ->
                 models.transform { move(0.0625 to DOWN).rotate(Rotation.fromUp[side.ordinal]) }.buildTufts()
             }.toTypedArray()
         }
-        val cactusCrossModels by LazyInvalidatable(BakeWrapperManager) {
+        val cactusCrossModels by BetterFoliage.modelManager.lazy {
             val models = Config.cactus.let { config ->
                 crossModelsRaw(64, config.size, 0.0, 0.0)
                     .transform { rotateZ(randomD(-config.sizeVariation, config.sizeVariation)) }

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

@@ -8,6 +8,7 @@ import mods.betterfoliage.config.DIRT_BLOCKS
 import mods.betterfoliage.config.SALTWATER_BIOMES
 import mods.betterfoliage.config.isSnow
 import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.model.Color
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.SpecialRenderData
@@ -24,6 +25,7 @@ import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
 import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ParametrizedModelDiscovery
 import mods.betterfoliage.resource.generated.CenteredSprite
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.Int3
@@ -31,6 +33,7 @@ import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.get
 import mods.betterfoliage.util.getBlockModel
 import mods.betterfoliage.util.idxOrNull
+import mods.betterfoliage.util.lazy
 import mods.betterfoliage.util.offset
 import mods.betterfoliage.util.randomI
 import net.minecraft.block.material.Material
@@ -42,14 +45,11 @@ import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
 import java.util.Random
 
-object StandardDirtDiscovery : AbstractModelDiscovery() {
+object StandardDirtDiscovery : ParametrizedModelDiscovery() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in DIRT_BLOCKS) {
+        BetterFoliage.blockTypes.dirt.add(ctx.blockState)
-            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+        ctx.addReplacement(StandardDirtKey)
-            ctx.addReplacement(StandardDirtKey)
+        ctx.blockState.block.extendLayers()
-            ctx.blockState.block.extendLayers()
-        }
-        super.processModel(ctx)
     }
 }
 
@@ -97,10 +97,8 @@ class StandardDirtModel(
     override fun renderLayer(ctx: RenderCtxBase, data: Any, layer: RenderType) {
         if (data is DirtRenderData) {
             if (data.connectedGrassModel != null) {
-                if (layer == Layers.connectedDirt) {
+                ctx.renderMasquerade(UP.offset) {
-                    ctx.renderMasquerade(UP.offset) {
+                    data.connectedGrassModel.renderLayer(ctx, ctx.state(UP), layer)
-                        data.connectedGrassModel.renderLayer(ctx, ctx.state(UP), layer)
-                    }
                 }
             } else {
                 // render non-connected grass
@@ -133,13 +131,13 @@ class StandardDirtModel(
             idFunc = { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_reed_$idx") },
             idRegister = { id -> CenteredSprite(id, aspectHeight = 2).register(BetterFoliage.generatedPack) }
         )
-        val algaeModels by LazyInvalidatable(BakeWrapperManager) {
+        val algaeModels by BetterFoliage.modelManager.lazy {
             val shapes = Config.algae.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
-            tuftModelSet(shapes, -1) { algaeSprites[randomI()] }.buildTufts()
+            tuftModelSet(shapes, Color.white) { algaeSprites[randomI()] }.buildTufts()
         }
-        val reedModels by LazyInvalidatable(BakeWrapperManager) {
+        val reedModels by BetterFoliage.modelManager.lazy {
             val shapes = Config.reed.let { tuftShapeSet(2.0, it.heightMin, it.heightMax, it.hOffset) }
-            tuftModelSet(shapes, -1) { reedSprites[randomI()] }.buildTufts()
+            tuftModelSet(shapes, Color.white) { reedSprites[randomI()] }.buildTufts()
         }
     }
 }

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

@@ -3,7 +3,7 @@ package mods.betterfoliage.render.block.vanilla
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.chunk.BlockCtx
-import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.BlockConfigOld
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.config.isSnow
 import mods.betterfoliage.integration.ShadersModIntegration
@@ -27,12 +27,15 @@ 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.discovery.ParametrizedModelDiscovery
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.LazyMapInvalidatable
 import mods.betterfoliage.util.averageColor
 import mods.betterfoliage.util.colorOverride
 import mods.betterfoliage.util.idxOrNull
+import mods.betterfoliage.util.lazy
+import mods.betterfoliage.util.lazyMap
 import mods.betterfoliage.util.logColorOverride
 import mods.betterfoliage.util.randomI
 import net.minecraft.client.renderer.RenderType
@@ -41,12 +44,10 @@ import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
 import java.util.Random
 
-object StandardGrassDiscovery : ConfigurableModelDiscovery() {
+object StandardGrassDiscovery : ParametrizedModelDiscovery() {
-    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.grassBlocks
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
-    override val modelTextures: List<ModelTextureList> get() = BlockConfig.grassModels.modelList
+        val textureGrass = params.texture("texture-grass") ?: return
-
+        ctx.addReplacement(StandardGrassKey(textureGrass, null))
-    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
-        ctx.addReplacement(StandardGrassKey(textureMatch[0], null))
         BetterFoliage.blockTypes.grass.add(ctx.blockState)
         ctx.blockState.block.extendLayers()
     }
@@ -132,19 +133,19 @@ class StandardGrassModel(
         val grassTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_grass_long_$idx")
         }
-        val grassTuftShapes by LazyInvalidatable(BakeWrapperManager) {
+        val grassTuftShapes by BetterFoliage.modelManager.lazy {
             Config.shortGrass.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
         }
-        val grassTuftMeshesNormal = LazyMapInvalidatable(BakeWrapperManager) { key: StandardGrassKey ->
+        val grassTuftMeshesNormal = BetterFoliage.modelManager.lazyMap { key: StandardGrassKey ->
-            tuftModelSet(grassTuftShapes, key.tintIndex) { idx -> grassTuftSprites[randomI()] }.buildTufts()
+            tuftModelSet(grassTuftShapes, key.overrideColor) { idx -> grassTuftSprites[randomI()] }.buildTufts()
         }
-        val grassTuftMeshesSnowed = LazyMapInvalidatable(BakeWrapperManager) { key: StandardGrassKey ->
+        val grassTuftMeshesSnowed = BetterFoliage.modelManager.lazyMap { key: StandardGrassKey ->
-            tuftModelSet(grassTuftShapes, -1) { idx -> grassTuftSprites[randomI()] }.buildTufts()
+            tuftModelSet(grassTuftShapes, null) { idx -> grassTuftSprites[randomI()] }.buildTufts()
         }
-        val grassFullBlockMeshes = LazyMapInvalidatable(BakeWrapperManager) { key: StandardGrassKey ->
+        val grassFullBlockMeshes = BetterFoliage.modelManager.lazyMap { key: StandardGrassKey ->
             Array(64) { fullCubeTextured(key.grassLocation, key.tintIndex) }
         }
-        val snowFullBlockMeshes by LazyInvalidatable(BakeWrapperManager) {
+        val snowFullBlockMeshes by BetterFoliage.modelManager.lazy {
             Array(64) { fullCubeTextured(ResourceLocation("block/snow"), -1) }
         }
     }

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

@@ -2,7 +2,7 @@ package mods.betterfoliage.render.block.vanilla
 
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.BlockConfigOld
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.config.isSnow
 import mods.betterfoliage.integration.ShadersModIntegration
@@ -18,30 +18,28 @@ import mods.betterfoliage.render.particle.LeafBlockModel
 import mods.betterfoliage.render.particle.LeafParticleKey
 import mods.betterfoliage.render.particle.LeafParticleRegistry
 import mods.betterfoliage.render.pipeline.RenderCtxBase
-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.discovery.ParametrizedModelDiscovery
 import mods.betterfoliage.resource.generated.GeneratedLeafSprite
 import mods.betterfoliage.util.Atlas
-import mods.betterfoliage.util.LazyMapInvalidatable
 import mods.betterfoliage.util.averageColor
 import mods.betterfoliage.util.colorOverride
+import mods.betterfoliage.util.lazyMap
 import mods.betterfoliage.util.logColorOverride
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
 import org.apache.logging.log4j.Level.INFO
 
-object StandardLeafDiscovery : ConfigurableModelDiscovery() {
+object StandardLeafDiscovery : ParametrizedModelDiscovery() {
-    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.leafBlocks
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
-    override val modelTextures: List<ModelTextureList> get() = BlockConfig.leafModels.modelList
+        val leafSprite = params.texture("texture-leaf") ?: return
-
+        val leafType = LeafParticleRegistry.typeMappings.getType(leafSprite) ?: "default"
-    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
+        val generated = GeneratedLeafSprite(leafSprite, leafType)
-        val leafType = LeafParticleRegistry.typeMappings.getType(textureMatch[0]) ?: "default"
-        val generated = GeneratedLeafSprite(textureMatch[0], leafType)
             .register(BetterFoliage.generatedPack)
             .apply { ctx.sprites.add(this) }
 
@@ -89,13 +87,13 @@ class StandardLeafModel(
         val leafSpritesSnowed by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_leaves_snowed_$idx")
         }
-        val leafModelsBase = LazyMapInvalidatable(BakeWrapperManager) { key: StandardLeafKey ->
+        val leafModelsBase = BetterFoliage.modelManager.lazyMap { key: StandardLeafKey ->
             Config.leaves.let { crossModelsRaw(64, it.size, it.hOffset, it.vOffset) }
         }
-        val leafModelsNormal = LazyMapInvalidatable(BakeWrapperManager) { key: StandardLeafKey ->
+        val leafModelsNormal = BetterFoliage.modelManager.lazyMap { key: StandardLeafKey ->
             crossModelsTextured(leafModelsBase[key], key.tintIndex, true) { key.roundLeafTexture }
         }
-        val leafModelsSnowed = LazyMapInvalidatable(BakeWrapperManager) { key: StandardLeafKey ->
+        val leafModelsSnowed = BetterFoliage.modelManager.lazyMap { key: StandardLeafKey ->
             crossModelsTextured(leafModelsBase[key], -1, false) { leafSpritesSnowed[it].name }
         }
     }

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

@@ -1,10 +1,12 @@
 package mods.betterfoliage.render.block.vanilla
 
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.chunk.BlockCtx
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.config.LILYPAD_BLOCKS
 import mods.betterfoliage.integration.ShadersModIntegration
+import mods.betterfoliage.model.Color
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.SpecialRenderModel
@@ -19,11 +21,13 @@ import mods.betterfoliage.resource.discovery.BakeWrapperManager
 import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelBakingKey
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ParametrizedModelDiscovery
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.get
 import mods.betterfoliage.util.idx
 import mods.betterfoliage.util.idxOrNull
+import mods.betterfoliage.util.lazy
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.client.renderer.RenderType
@@ -33,12 +37,9 @@ import net.minecraft.util.Direction.DOWN
 import net.minecraft.util.ResourceLocation
 import java.util.Random
 
-object StandardLilypadDiscovery : AbstractModelDiscovery() {
+object StandardLilypadDiscovery : ParametrizedModelDiscovery() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in LILYPAD_BLOCKS) {
+        ctx.addReplacement(StandardLilypadKey)
-            ctx.addReplacement(StandardLilypadKey)
-        }
-        super.processModel(ctx)
     }
 }
 
@@ -81,15 +82,15 @@ class StandardLilypadModel(
         val lilypadFlowerSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_lilypad_flower_$idx")
         }
-        val lilypadRootModels by LazyInvalidatable(BakeWrapperManager) {
+        val lilypadRootModels by BetterFoliage.modelManager.lazy {
             val shapes = tuftShapeSet(1.0, 1.0, 1.0, Config.lilypad.hOffset)
-            tuftModelSet(shapes, -1) { lilypadRootSprites[it] }
+            tuftModelSet(shapes, Color.white) { lilypadRootSprites[it] }
                 .transform { move(2.0 to DOWN) }
                 .buildTufts()
         }
-        val lilypadFlowerModels by LazyInvalidatable(BakeWrapperManager) {
+        val lilypadFlowerModels by BetterFoliage.modelManager.lazy {
             val shapes = tuftShapeSet(0.5, 0.5, 0.5, Config.lilypad.hOffset)
-            tuftModelSet(shapes, -1) { lilypadFlowerSprites[it] }
+            tuftModelSet(shapes, Color.white) { lilypadFlowerSprites[it] }
                 .transform { move(1.0 to DOWN) }
                 .buildTufts()
         }

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

@@ -1,9 +1,11 @@
 package mods.betterfoliage.render.block.vanilla
 
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.chunk.BlockCtx
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.config.MYCELIUM_BLOCKS
+import mods.betterfoliage.model.Color
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.SpecialRenderData
@@ -20,10 +22,12 @@ import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
 import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ParametrizedModelDiscovery
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.get
 import mods.betterfoliage.util.idxOrNull
+import mods.betterfoliage.util.lazy
 import mods.betterfoliage.util.randomI
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.RenderTypeLookup
@@ -32,13 +36,10 @@ import net.minecraft.util.Direction
 import net.minecraft.util.ResourceLocation
 import java.util.Random
 
-object StandardMyceliumDiscovery : AbstractModelDiscovery() {
+object StandardMyceliumDiscovery : ParametrizedModelDiscovery() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in MYCELIUM_BLOCKS) {
+        ctx.addReplacement(StandardMyceliumKey)
-            ctx.addReplacement(StandardMyceliumKey)
+        ctx.blockState.block.extendLayers()
-            ctx.blockState.block.extendLayers()
-        }
-        super.processModel(ctx)
     }
 }
 
@@ -81,9 +82,9 @@ class StandardMyceliumModel(
         val myceliumTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_mycel_$idx")
         }
-        val myceliumTuftModels by LazyInvalidatable(BakeWrapperManager) {
+        val myceliumTuftModels by BetterFoliage.modelManager.lazy {
             val shapes = Config.shortGrass.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
-            tuftModelSet(shapes, -1) { idx -> myceliumTuftSprites[randomI()] }.buildTufts()
+            tuftModelSet(shapes, Color.white) { idx -> myceliumTuftSprites[randomI()] }.buildTufts()
         }
     }
 }

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

@@ -5,6 +5,7 @@ import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.chunk.BlockCtx
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.config.NETHERRACK_BLOCKS
+import mods.betterfoliage.model.Color
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.SpecialRenderData
@@ -22,11 +23,13 @@ import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
 import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ParametrizedModelDiscovery
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.Rotation
 import mods.betterfoliage.util.get
 import mods.betterfoliage.util.idxOrNull
+import mods.betterfoliage.util.lazy
 import mods.betterfoliage.util.randomI
 import net.minecraft.block.Blocks
 import net.minecraft.client.renderer.RenderType
@@ -37,14 +40,10 @@ import net.minecraft.util.Direction.DOWN
 import net.minecraft.util.ResourceLocation
 import java.util.Random
 
-object StandardNetherrackDiscovery : AbstractModelDiscovery() {
+object StandardNetherrackDiscovery : ParametrizedModelDiscovery() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in NETHERRACK_BLOCKS) {
+        ctx.addReplacement(StandardNetherrackKey)
-            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+        ctx.blockState.block.extendLayers()
-            ctx.addReplacement(StandardNetherrackKey)
-            ctx.blockState.block.extendLayers()
-        }
-        super.processModel(ctx)
     }
 }
 
@@ -86,9 +85,9 @@ class StandardNetherrackModel(
         val netherrackTuftSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_netherrack_$idx")
         }
-        val netherrackTuftModels by LazyInvalidatable(BakeWrapperManager) {
+        val netherrackTuftModels by BetterFoliage.modelManager.lazy {
             val shapes = Config.netherrack.let { tuftShapeSet(it.size, it.heightMin, it.heightMax, it.hOffset) }
-            tuftModelSet(shapes, -1) { netherrackTuftSprites[randomI()] }
+            tuftModelSet(shapes, Color.white) { netherrackTuftSprites[randomI()] }
                 .transform { rotate(Rotation.fromUp[DOWN.ordinal]).rotateUV(2) }
                 .buildTufts()
         }

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

@@ -2,7 +2,7 @@ package mods.betterfoliage.render.block.vanilla
 
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.config.ACCEPTED_ROUND_LOG_MATERIALS
-import mods.betterfoliage.config.BlockConfig
+import mods.betterfoliage.config.BlockConfigOld
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.SpecialRenderModel
@@ -17,14 +17,17 @@ import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelBakingKey
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
 import mods.betterfoliage.resource.discovery.ModelTextureList
+import mods.betterfoliage.resource.discovery.ParametrizedModelDiscovery
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyMapInvalidatable
+import mods.betterfoliage.util.lazyMap
 import mods.betterfoliage.util.tryDefault
 import net.minecraft.block.BlockState
 import net.minecraft.block.RotatedPillarBlock
 import net.minecraft.util.Direction.Axis
 import net.minecraft.util.ResourceLocation
 import org.apache.logging.log4j.Level.INFO
+import org.apache.logging.log4j.Level.WARN
 
 interface RoundLogKey : ColumnBlockKey, ModelBakingKey {
     val barkSprite: ResourceLocation
@@ -38,16 +41,15 @@ object RoundLogOverlayLayer : ColumnRenderLayer() {
     override val defaultToY: Boolean get() = Config.roundLogs.defaultY
 }
 
-object StandardRoundLogDiscovery : ConfigurableModelDiscovery() {
+object StandardRoundLogDiscovery : ParametrizedModelDiscovery() {
-    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.logBlocks
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
-    override val modelTextures: List<ModelTextureList> get() = BlockConfig.logModels.modelList
+        val barkSprite = params.texture("texture-side") ?: return
-
+        val endSprite = params.texture("texture-end") ?: return
-    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
         val axis = getAxis(ctx.blockState)
 
         detailLogger.log(INFO, "       axis $axis, material ${ctx.blockState.material}")
         if (!Config.roundLogs.plantsOnly || ctx.blockState.material in ACCEPTED_ROUND_LOG_MATERIALS)
-            ctx.addReplacement(StandardRoundLogKey(axis, textureMatch[0], textureMatch[1]))
+            ctx.addReplacement(StandardRoundLogKey(axis, barkSprite, endSprite))
     }
 
     fun getAxis(state: BlockState): Axis? {
@@ -82,7 +84,7 @@ class StandardRoundLogModel(
     override fun getMeshSet(axis: Axis, quadrant: Int) = modelSet
 
     companion object {
-        val modelSets = LazyMapInvalidatable(BakeWrapperManager) { key: StandardRoundLogKey ->
+        val modelSets = BetterFoliage.modelManager.lazyMap { key: StandardRoundLogKey ->
             val barkSprite = Atlas.BLOCKS[key.barkSprite]
             val endSprite = Atlas.BLOCKS[key.endSprite]
             Config.roundLogs.let { config ->

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

@@ -6,6 +6,7 @@ import mods.betterfoliage.chunk.BlockCtx
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.config.SALTWATER_BIOMES
 import mods.betterfoliage.config.SAND_BLOCKS
+import mods.betterfoliage.model.Color
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.Quad
@@ -25,12 +26,15 @@ import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
 import mods.betterfoliage.resource.discovery.BakeWrapperManager
 import mods.betterfoliage.resource.discovery.ModelBakingContext
 import mods.betterfoliage.resource.discovery.ModelDiscoveryContext
+import mods.betterfoliage.resource.discovery.ParametrizedModelDiscovery
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyInvalidatable
 import mods.betterfoliage.util.Rotation
 import mods.betterfoliage.util.allDirections
 import mods.betterfoliage.util.get
 import mods.betterfoliage.util.idx
+import mods.betterfoliage.util.lazy
+import mods.betterfoliage.util.lazyMap
 import mods.betterfoliage.util.mapArray
 import mods.betterfoliage.util.randomB
 import mods.betterfoliage.util.randomD
@@ -44,14 +48,10 @@ import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
 import java.util.Random
 
-object StandardSandDiscovery : AbstractModelDiscovery() {
+object StandardSandDiscovery : ParametrizedModelDiscovery() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in SAND_BLOCKS) {
+        ctx.addReplacement(StandardSandKey)
-            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+        ctx.blockState.block.extendLayers()
-            ctx.addReplacement(StandardSandKey)
-            ctx.blockState.block.extendLayers()
-        }
-        super.processModel(ctx)
     }
 }
 
@@ -110,15 +110,15 @@ class StandardSandModel(
         val coralCrustSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_crust_$idx")
         }
-        val coralTuftModels by LazyInvalidatable(BakeWrapperManager) {
+        val coralTuftModels by BetterFoliage.modelManager.lazy {
             val shapes = Config.coral.let { tuftShapeSet(it.size, 1.0, 1.0, it.hOffset) }
             allDirections.mapArray { face ->
-                tuftModelSet(shapes, -1) { coralTuftSprites[randomI()] }
+                tuftModelSet(shapes, Color.white) { coralTuftSprites[randomI()] }
                     .transform { rotate(Rotation.fromUp[face]) }
                     .buildTufts()
             }
         }
-        val coralCrustModels by LazyInvalidatable(BakeWrapperManager) {
+        val coralCrustModels by BetterFoliage.modelManager.lazy {
             allDirections.map { face ->
                 Array(64) { idx ->
                     listOf(

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

@@ -1,9 +1,11 @@
 package mods.betterfoliage.resource.discovery
 
 import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.HasLogger
 import mods.betterfoliage.util.Invalidator
+import mods.betterfoliage.util.resourceManager
 import net.minecraft.block.BlockState
 import net.minecraft.client.renderer.model.IBakedModel
 import net.minecraft.client.renderer.model.IModelTransform
@@ -68,7 +70,7 @@ data class ModelBakingContext(
     fun getBaked() = bakery.getBakedModel(location, transform, spriteGetter)
 }
 
-object BakeWrapperManager : Invalidator, HasLogger() {
+class BakeWrapperManager : Invalidator, HasLogger() {
     val discoverers = mutableListOf<ModelDiscovery>()
     override val callbacks = mutableListOf<WeakReference<()->Unit>>()
 
@@ -79,6 +81,7 @@ object BakeWrapperManager : Invalidator, HasLogger() {
     fun handleModelLoad(event: ModelDefinitionsLoadedEvent) {
         val startTime = System.currentTimeMillis()
         invalidate()
+        BetterFoliage.blockConfig.readConfig(resourceManager)
         BetterFoliage.blockTypes = BlockTypeCache()
 
         StartupMessageManager.addModMessage("BetterFoliage: discovering models")

src/main/kotlin/mods/betterfoliage/util/Caching.kt

@@ -62,3 +62,6 @@ open class LazyMapInvalidatable<K, V>(val invalidator: Invalidator, val valueFac
         }
     }
 }
+
+fun <V> Invalidator.lazy(valueFactory: ()->V) = LazyInvalidatable(this, valueFactory)
+fun <K, V> Invalidator.lazyMap(valueFactory: (K)->V) = LazyMapInvalidatable(this, valueFactory)