use new config parser

+BakeWrapperManager no longer singleton
2021-07-12 20:21:26 +02:00
parent c8e79c22ff
commit 257593d231
15 changed files with 137 additions and 123 deletions
--- a/src/main/java/mods/betterfoliage/mixin/MixinModelBakery.java
+++ b/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);
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/BetterFoliage.kt
+++ b/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,
-            StandardCactusDiscovery,
-            StandardNetherrackDiscovery,
-            StandardRoundLogDiscovery
+            StandardRoundLogDiscovery,
        ).forEach {
-            BakeWrapperManager.discoverers.add(it)
        }

        // init singletons
        val singletons = listOf(
            AoSideHelper,
-            BlockConfig,
+            BlockConfigOld,
            ChunkOverlayManager,
            LeafWindTracker
        )
--- a/src/main/kotlin/mods/betterfoliage/integration/ShadersModIntegration.kt
+++ b/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
-        if (isDiffuseAvailable) BakeWrapperManager.onInvalidate {
+        // Recalculate the diffuse shading values used when resources are reloaded
+        if (isDiffuseAvailable) BetterFoliage.modelManager.onInvalidate {
            if (Shaders.shaderPackLoaded.getStatic()) {
                diffuseShades = Direction.values().mapArray { face ->
                    when(face) {
--- a/src/main/kotlin/mods/betterfoliage/model/TuftMeshes.kt
+++ b/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)) }
    }

--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Cactus.kt
+++ b/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() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
-        val model = ctx.getUnbaked()
-        if (model is BlockModel && ctx.blockState.block in CACTUS_BLOCKS) {
-            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
-            ctx.addReplacement(StandardCactusKey)
-            ctx.sprites.add(StandardCactusModel.cactusCrossSprite)
-        }
-        super.processModel(ctx)
+object StandardCactusDiscovery : ParametrizedModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
+        ctx.addReplacement(StandardCactusKey)
+        ctx.sprites.add(StandardCactusModel.cactusCrossSprite)
    }
 }

@@ -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)) }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Dirt.kt
+++ b/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() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in DIRT_BLOCKS) {
-            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
-            ctx.addReplacement(StandardDirtKey)
-            ctx.blockState.block.extendLayers()
-        }
-        super.processModel(ctx)
+object StandardDirtDiscovery : ParametrizedModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
+        BetterFoliage.blockTypes.dirt.add(ctx.blockState)
+        ctx.addReplacement(StandardDirtKey)
+        ctx.blockState.block.extendLayers()
    }
 }

@@ -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) {
-                        data.connectedGrassModel.renderLayer(ctx, ctx.state(UP), layer)
-                    }
+                ctx.renderMasquerade(UP.offset) {
+                    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()
        }
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Grass.kt
+++ b/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() {
-    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.grassBlocks
-    override val modelTextures: List<ModelTextureList> get() = BlockConfig.grassModels.modelList
-
-    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
-        ctx.addReplacement(StandardGrassKey(textureMatch[0], null))
+object StandardGrassDiscovery : ParametrizedModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
+        val textureGrass = params.texture("texture-grass") ?: return
+        ctx.addReplacement(StandardGrassKey(textureGrass, 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 ->
-            tuftModelSet(grassTuftShapes, key.tintIndex) { idx -> grassTuftSprites[randomI()] }.buildTufts()
+        val grassTuftMeshesNormal = BetterFoliage.modelManager.lazyMap { key: StandardGrassKey ->
+            tuftModelSet(grassTuftShapes, key.overrideColor) { idx -> grassTuftSprites[randomI()] }.buildTufts()
        }
-        val grassTuftMeshesSnowed = LazyMapInvalidatable(BakeWrapperManager) { key: StandardGrassKey ->
-            tuftModelSet(grassTuftShapes, -1) { idx -> grassTuftSprites[randomI()] }.buildTufts()
+        val grassTuftMeshesSnowed = BetterFoliage.modelManager.lazyMap { key: StandardGrassKey ->
+            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) }
        }
    }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Leaf.kt
+++ b/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() {
-    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.leafBlocks
-    override val modelTextures: List<ModelTextureList> get() = BlockConfig.leafModels.modelList
-
-    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
-        val leafType = LeafParticleRegistry.typeMappings.getType(textureMatch[0]) ?: "default"
-        val generated = GeneratedLeafSprite(textureMatch[0], leafType)
+object StandardLeafDiscovery : ParametrizedModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
+        val leafSprite = params.texture("texture-leaf") ?: return
+        val leafType = LeafParticleRegistry.typeMappings.getType(leafSprite) ?: "default"
+        val generated = GeneratedLeafSprite(leafSprite, 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 }
        }
    }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Lilypad.kt
+++ b/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() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in LILYPAD_BLOCKS) {
-            ctx.addReplacement(StandardLilypadKey)
-        }
-        super.processModel(ctx)
+object StandardLilypadDiscovery : ParametrizedModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
+        ctx.addReplacement(StandardLilypadKey)
    }
 }

@@ -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()
        }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Mycelium.kt
+++ b/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() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in MYCELIUM_BLOCKS) {
-            ctx.addReplacement(StandardMyceliumKey)
-            ctx.blockState.block.extendLayers()
-        }
-        super.processModel(ctx)
+object StandardMyceliumDiscovery : ParametrizedModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
+        ctx.addReplacement(StandardMyceliumKey)
+        ctx.blockState.block.extendLayers()
    }
 }

@@ -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()
        }
    }
 }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Netherrack.kt
+++ b/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() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in NETHERRACK_BLOCKS) {
-            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
-            ctx.addReplacement(StandardNetherrackKey)
-            ctx.blockState.block.extendLayers()
-        }
-        super.processModel(ctx)
+object StandardNetherrackDiscovery : ParametrizedModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
+        ctx.addReplacement(StandardNetherrackKey)
+        ctx.blockState.block.extendLayers()
    }
 }

@@ -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()
        }
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/RoundLog.kt
+++ b/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() {
-    override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.logBlocks
-    override val modelTextures: List<ModelTextureList> get() = BlockConfig.logModels.modelList
-
-    override fun processModel(ctx: ModelDiscoveryContext, textureMatch: List<ResourceLocation>) {
+object StandardRoundLogDiscovery : ParametrizedModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
+        val barkSprite = params.texture("texture-side") ?: return
+        val endSprite = params.texture("texture-end") ?: return
        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 ->
--- a/src/main/kotlin/mods/betterfoliage/render/block/vanilla/Sand.kt
+++ b/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() {
-    override fun processModel(ctx: ModelDiscoveryContext) {
-        if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in SAND_BLOCKS) {
-            BetterFoliage.blockTypes.dirt.add(ctx.blockState)
-            ctx.addReplacement(StandardSandKey)
-            ctx.blockState.block.extendLayers()
-        }
-        super.processModel(ctx)
+object StandardSandDiscovery : ParametrizedModelDiscovery() {
+    override fun processModel(ctx: ModelDiscoveryContext, params: Map<String, String>) {
+        ctx.addReplacement(StandardSandKey)
+        ctx.blockState.block.extendLayers()
    }
 }

@@ -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(
--- a/src/main/kotlin/mods/betterfoliage/resource/discovery/BakingLifecycle.kt
+++ b/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")
--- a/src/main/kotlin/mods/betterfoliage/util/Caching.kt
+++ b/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)