adopt AO calculation tweak from Indigo

+minor cleanup

gradle.properties

@@ -4,7 +4,7 @@ org.gradle.daemon=false
 group = com.github.octarine-noise
 jarName = BetterFoliage-Forge
 
-version = 2.6.0
+version = 2.6.3
 
 mcVersion = 1.15.2
 forgeVersion = 31.2.44

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

@@ -77,6 +77,13 @@ object CustomColors : ClassRef<Any>("net.optifine.CustomColors") {
 }
 
 // Optifine shaders
+object Shaders : ClassRef<Any>("net.optifine.shaders.Shaders") {
+    val shaderPackLoaded = FieldRef(this, "shaderPackLoaded", boolean)
+    val blockLightLevel05 = FieldRef(this, "blockLightLevel05", float)
+    val blockLightLevel06 = FieldRef(this, "blockLightLevel06", float)
+    val blockLightLevel08 = FieldRef(this, "blockLightLevel08", float)
+}
+
 object SVertexBuilder : ClassRef<Any>("net.optifine.shaders.SVertexBuilder") {
     val pushState = MethodRef(this, "pushEntity", void, long)
     val popState = MethodRef(this, "popEntity", void)

src/main/kotlin/mods/betterfoliage/config/MiscDefaults.kt

@@ -0,0 +1,18 @@
+package mods.betterfoliage.config
+
+import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
+import net.minecraft.block.material.Material
+import net.minecraft.world.biome.Biome
+
+val CACTUS_BLOCKS = listOf(Blocks.CACTUS)
+val DIRT_BLOCKS = listOf(Blocks.DIRT, Blocks.COARSE_DIRT, Blocks.PODZOL)
+val SAND_BLOCKS = listOf(Blocks.SAND, Blocks.RED_SAND)
+val NETHERRACK_BLOCKS = listOf(Blocks.NETHERRACK)
+val LILYPAD_BLOCKS = listOf(Blocks.LILY_PAD)
+val MYCELIUM_BLOCKS = listOf(Blocks.MYCELIUM)
+
+val SALTWATER_BIOMES = listOf(Biome.Category.BEACH, Biome.Category.OCEAN)
+
+val SNOW_MATERIALS = listOf(Material.SNOW_BLOCK, Material.SNOW)
+val BlockState.isSnow: Boolean get() = material in SNOW_MATERIALS

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

@@ -1,30 +1,40 @@
 package mods.betterfoliage.integration
 
-import mods.betterfoliage.config.BlockConfig
 import mods.betterfoliage.render.pipeline.RenderCtxBase
-import mods.betterfoliage.render.pipeline.RenderCtxForge
 import mods.betterfoliage.render.pipeline.RenderCtxVanilla
+import mods.betterfoliage.resource.discovery.BakeWrapperManager
 import mods.betterfoliage.util.HasLogger
 import mods.betterfoliage.util.allAvailable
 import mods.betterfoliage.util.get
+import mods.betterfoliage.util.mapArray
 import mods.octarinecore.*
 import net.minecraft.block.BlockRenderType
 import net.minecraft.block.BlockRenderType.MODEL
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.client.renderer.BufferBuilder
+import net.minecraft.util.Direction
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.Direction.EAST
+import net.minecraft.util.Direction.NORTH
+import net.minecraft.util.Direction.SOUTH
+import net.minecraft.util.Direction.WEST
 import net.minecraft.util.math.BlockPos
 import net.minecraft.world.ILightReader
+import net.minecraftforge.client.model.pipeline.LightUtil
 import org.apache.logging.log4j.Level.INFO
 
 /**
  * Integration for ShadersMod.
  */
 object ShadersModIntegration : HasLogger() {
-    @JvmStatic val isAvailable = allAvailable(SVertexBuilder, SVertexBuilder.pushState, SVertexBuilder.popState, BlockAliases.getAliasBlockId)
+    @JvmStatic val isEffectsAvailable = allAvailable(SVertexBuilder.pushState, SVertexBuilder.popState, BlockAliases.getAliasBlockId)
+    @JvmStatic val isDiffuseAvailable = allAvailable(Shaders.shaderPackLoaded, Shaders.blockLightLevel05, Shaders.blockLightLevel06, Shaders.blockLightLevel08)
 
-    val defaultLeaves = Blocks.OAK_LEAVES.defaultState
+    @JvmStatic val defaultLeaves = Blocks.OAK_LEAVES.defaultState!!
-    val defaultGrass = Blocks.GRASS.defaultState
+    @JvmStatic val defaultGrass = Blocks.GRASS.defaultState!!
+
+    @JvmStatic var diffuseShades = Direction.values().mapArray { LightUtil.diffuseLight(it) }
 
     /**
      * Called from transformed ShadersMod code.
@@ -37,12 +47,29 @@ object ShadersModIntegration : HasLogger() {
     }
 
     init {
-        logger.log(INFO, "ShadersMod integration is ${if (isAvailable) "enabled" else "disabled" }")
+        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 {
+            if (Shaders.shaderPackLoaded.getStatic()) {
+                diffuseShades = Direction.values().mapArray { face ->
+                    when(face) {
+                        DOWN -> Shaders.blockLightLevel05.getStatic()
+                        WEST, EAST -> Shaders.blockLightLevel06.getStatic()
+                        NORTH, SOUTH -> Shaders.blockLightLevel08.getStatic()
+                        else -> LightUtil.diffuseLight(face)
+                    }
+                }
+            } else {
+                diffuseShades = Direction.values().mapArray { LightUtil.diffuseLight(it) }
+            }
+        }
     }
 
     /** Quads rendered inside this block will use the given block entity data in shader programs. */
     inline fun renderAs(buffer: BufferBuilder, state: BlockState, renderType: BlockRenderType, enabled: Boolean = true, func: ()->Unit) {
-        if (isAvailable && enabled) {
+        if (isEffectsAvailable && enabled) {
             val aliasBlockId = BlockAliases.getAliasBlockId.invokeStatic(state)
             val sVertexBuilder = buffer[BufferBuilder_sVertexBuilder]
             SVertexBuilder.pushState.invoke(sVertexBuilder, aliasBlockId)

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

@@ -96,9 +96,9 @@ fun Array<List<Quad>>.bake(applyDiffuseLighting: Boolean) = mapArray { it.bake(a
 fun BakedQuad.unbake(): HalfBakedQuad {
     val size = DefaultVertexFormats.BLOCK.integerSize
     val verts = Array(4) { vIdx ->
-        val x = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 0])
+        val x = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 0]) - 0.5f
-        val y = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 1])
+        val y = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 1]) - 0.5f
-        val z = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 2])
+        val z = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 2]) - 0.5f
         val color = vertexData[vIdx * size + 3]
         val u = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 4])
         val v = java.lang.Float.intBitsToFloat(vertexData[vIdx * size + 5])

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

@@ -2,6 +2,7 @@ package mods.betterfoliage.render.block.vanilla
 
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.config.CACTUS_BLOCKS
 import mods.betterfoliage.config.Config
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
@@ -33,8 +34,6 @@ import net.minecraft.util.Direction.DOWN
 import net.minecraft.util.ResourceLocation
 
 object StandardCactusDiscovery : AbstractModelDiscovery() {
-    val CACTUS_BLOCKS = listOf(Blocks.CACTUS)
-
     override fun processModel(ctx: ModelDiscoveryContext) {
         val model = ctx.getUnbaked()
         if (model is BlockModel && ctx.blockState.block in CACTUS_BLOCKS) {

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

@@ -3,6 +3,9 @@ package mods.betterfoliage.render.block.vanilla
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.DIRT_BLOCKS
+import mods.betterfoliage.config.SALTWATER_BIOMES
+import mods.betterfoliage.integration.ShadersModIntegration
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.SpecialRenderModel
@@ -34,8 +37,6 @@ import net.minecraft.util.ResourceLocation
 import net.minecraft.world.biome.Biome
 
 object StandardDirtDiscovery : AbstractModelDiscovery() {
-    val DIRT_BLOCKS = listOf(Blocks.DIRT, Blocks.COARSE_DIRT, Blocks.PODZOL)
-
     fun canRenderInLayer(layer: RenderType) = when {
         !Config.enabled -> layer == RenderType.getSolid()
         !Config.connectedGrass.enabled && !Config.algae.enabled && !Config.reed.enabled -> layer == RenderType.getSolid()
@@ -64,7 +65,8 @@ class StandardDirtModel(
     override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
         if (!Config.enabled || noDecorations) return super.render(ctx, noDecorations)
 
-        val stateUp = ctx.offset(UP).state
+        val stateUp = ctx.state(UP)
+        val state2Up = ctx.state(Int3(0, 2, 0))
         val isConnectedGrass = Config.connectedGrass.enabled && stateUp in BetterFoliage.blockTypes.grass
         if (isConnectedGrass) {
             (ctx.blockModelShapes.getModel(stateUp) as? SpecialRenderModel)?.let { grassModel ->
@@ -84,17 +86,19 @@ class StandardDirtModel(
         val isSaltWater = isWater && ctx.biome?.category in SALTWATER_BIOMES
 
         if (Config.algae.enabled(ctx.random) && isDeepWater) {
-            (ctx as? RenderCtxVanilla)?.vertexLighter = vanillaTuftLighting
+            ctx.vertexLighter = vanillaTuftLighting
-            ctx.renderQuads(algaeModels[ctx.random])
+            ShadersModIntegration.grass(ctx, Config.algae.shaderWind) {
+                ctx.renderQuads(algaeModels[ctx.random])
+            }
         } else if (Config.reed.enabled(ctx.random) && isShallowWater && !isSaltWater) {
-            (ctx as? RenderCtxVanilla)?.vertexLighter = vanillaTuftLighting
+            ctx.vertexLighter = vanillaTuftLighting
-            ctx.renderQuads(reedModels[ctx.random])
+            ShadersModIntegration.grass(ctx, Config.reed.shaderWind) {
+                ctx.renderQuads(reedModels[ctx.random])
+            }
         }
     }
 
     companion object {
-        val SALTWATER_BIOMES = listOf(Biome.Category.BEACH, Biome.Category.OCEAN)
-
         val algaeSprites by SpriteSetDelegate(Atlas.BLOCKS) { idx ->
             ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_algae_$idx")
         }

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

@@ -1,9 +1,10 @@
 package mods.betterfoliage.render.block.vanilla
 
-import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.config.BlockConfig
 import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.isSnow
 import mods.betterfoliage.integration.ShadersModIntegration
 import mods.betterfoliage.model.Color
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
@@ -28,7 +29,6 @@ import mods.betterfoliage.util.LazyMapInvalidatable
 import mods.betterfoliage.util.averageColor
 import mods.betterfoliage.util.colorOverride
 import mods.betterfoliage.util.get
-import mods.betterfoliage.util.isSnow
 import mods.betterfoliage.util.logColorOverride
 import mods.betterfoliage.util.randomI
 import net.minecraft.util.Direction.DOWN

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

@@ -1,9 +1,11 @@
 package mods.betterfoliage.render.block.vanilla
 
-import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.config.BlockConfig
 import mods.betterfoliage.config.Config
+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
@@ -27,7 +29,6 @@ import mods.betterfoliage.util.Atlas
 import mods.betterfoliage.util.LazyMapInvalidatable
 import mods.betterfoliage.util.averageColor
 import mods.betterfoliage.util.colorOverride
-import mods.betterfoliage.util.isSnow
 import mods.betterfoliage.util.logColorOverride
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
@@ -72,13 +73,15 @@ class StandardLeafModel(
     val leafSnowed by leafModelsSnowed.delegate(key)
 
     override fun render(ctx: RenderCtxBase, noDecorations: Boolean) {
-        super.render(ctx, noDecorations)
+        ShadersModIntegration.leaves(ctx, true) {
-        if (!Config.enabled || !Config.leaves.enabled || noDecorations) return
+            super.render(ctx, noDecorations)
+            if (!Config.enabled || !Config.leaves.enabled || noDecorations) return
 
-        ctx.vertexLighter = RoundLeafLightingPreferUp
+            ctx.vertexLighter = RoundLeafLightingPreferUp
-        val leafIdx = ctx.random.nextInt(64)
+            val leafIdx = ctx.random.nextInt(64)
-        ctx.renderQuads(leafNormal[leafIdx])
+            ctx.renderQuads(leafNormal[leafIdx])
-        if (ctx.state(UP).isSnow) ctx.renderQuads(leafSnowed[leafIdx])
+            if (ctx.state(UP).isSnow) ctx.renderQuads(leafSnowed[leafIdx])
+        }
     }
 
     companion object {

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

@@ -2,6 +2,7 @@ package mods.betterfoliage.render.block.vanilla
 
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.LILYPAD_BLOCKS
 import mods.betterfoliage.integration.ShadersModIntegration
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
@@ -28,8 +29,6 @@ import net.minecraft.util.Direction.DOWN
 import net.minecraft.util.ResourceLocation
 
 object StandardLilypadDiscovery : AbstractModelDiscovery() {
-    val LILYPAD_BLOCKS = listOf(Blocks.LILY_PAD)
-
     override fun processModel(ctx: ModelDiscoveryContext) {
         if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in LILYPAD_BLOCKS) {
             ctx.addReplacement(StandardLilypadKey)

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

@@ -2,6 +2,7 @@ package mods.betterfoliage.render.block.vanilla
 
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.MYCELIUM_BLOCKS
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.SpecialRenderModel
@@ -27,8 +28,6 @@ import net.minecraft.util.Direction
 import net.minecraft.util.ResourceLocation
 
 object StandardMyceliumDiscovery : AbstractModelDiscovery() {
-    val MYCELIUM_BLOCKS = listOf(Blocks.MYCELIUM)
-
     override fun processModel(ctx: ModelDiscoveryContext) {
         if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in MYCELIUM_BLOCKS) {
             ctx.addReplacement(StandardMyceliumKey)

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

@@ -3,6 +3,7 @@ package mods.betterfoliage.render.block.vanilla
 import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.NETHERRACK_BLOCKS
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.SpecialRenderModel
@@ -30,8 +31,6 @@ import net.minecraft.util.Direction.DOWN
 import net.minecraft.util.ResourceLocation
 
 object StandardNetherrackDiscovery : AbstractModelDiscovery() {
-    val NETHERRACK_BLOCKS = listOf(Blocks.NETHERRACK)
-
     fun canRenderInLayer(layer: RenderType) = when {
         !Config.enabled -> layer == RenderType.getSolid()
         !Config.netherrack.enabled -> layer == RenderType.getSolid()

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

@@ -1,8 +1,10 @@
 package mods.betterfoliage.render.block.vanilla
 
-import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.BetterFoliage
+import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.config.Config
+import mods.betterfoliage.config.SALTWATER_BIOMES
+import mods.betterfoliage.config.SAND_BLOCKS
 import mods.betterfoliage.model.HalfBakedSpecialWrapper
 import mods.betterfoliage.model.HalfBakedWrapperKey
 import mods.betterfoliage.model.Quad
@@ -13,7 +15,6 @@ import mods.betterfoliage.model.buildTufts
 import mods.betterfoliage.model.transform
 import mods.betterfoliage.model.tuftModelSet
 import mods.betterfoliage.model.tuftShapeSet
-import mods.betterfoliage.render.block.vanilla.StandardDirtModel.Companion.SALTWATER_BIOMES
 import mods.betterfoliage.render.lighting.LightingPreferredFace
 import mods.betterfoliage.render.pipeline.RenderCtxBase
 import mods.betterfoliage.resource.discovery.AbstractModelDiscovery
@@ -29,7 +30,6 @@ import mods.betterfoliage.util.mapArray
 import mods.betterfoliage.util.randomB
 import mods.betterfoliage.util.randomD
 import mods.betterfoliage.util.randomI
-import net.minecraft.block.Blocks
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.RenderTypeLookup
@@ -39,8 +39,6 @@ import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
 
 object StandardSandDiscovery : AbstractModelDiscovery() {
-    val SAND_BLOCKS = listOf(Blocks.SAND, Blocks.RED_SAND)
-
     override fun processModel(ctx: ModelDiscoveryContext) {
         if (ctx.getUnbaked() is BlockModel && ctx.blockState.block in SAND_BLOCKS) {
             BetterFoliage.blockTypes.dirt.add(ctx.blockState)

src/main/kotlin/mods/betterfoliage/render/lighting/VanillaAoCalculation.kt

@@ -23,6 +23,10 @@ data class LightingData(
     }
 }
 
+// Vanilla has a very suspicious-looking offset here, which Indigo gets rid of and calls it a fix
+// Naturally, we're going to believe Indigo, it's a hardcoded option for now
+const val OCCLUSION_OFFSET_FIX = true
+
 /**
  * Replacement for [BlockModelRenderer.AmbientOcclusionFace]
  * This gets called on a LOT, so object instantiation is avoided.
@@ -87,9 +91,9 @@ class VanillaAoCalculator {
         sideHelper.sides.forEachIndexed { sideIdx, sideDir ->
             // record light data in the block 1 step to the side
             probe.position { setPos(lightOrigin).move(sideDir) }.writeTo(sideAo[sideIdx])
-            // side is considered occluded if the block 1 step to that side and
+            // side is considered occluded if the block 1 step to that side is not fully transparent
-            // 1 step forward (in the lightface direction) is not fully transparent
+            if (!OCCLUSION_OFFSET_FIX) probe.position { move(lightFace) }
-            isOccluded[sideIdx] = probe.position { move(lightFace) }.isNonTransparent
+            isOccluded[sideIdx] = probe.isNonTransparent
         }
 
         // AO Calculation for the 4 corners

src/main/kotlin/mods/betterfoliage/render/lighting/VanillaVertexLighter.kt

@@ -1,15 +1,15 @@
 package mods.betterfoliage.render.lighting
 
+import mods.betterfoliage.integration.ShadersModIntegration
 import mods.betterfoliage.model.HalfBakedQuad
 import mods.betterfoliage.util.Double3
 import mods.betterfoliage.util.EPSILON_ONE
 import mods.betterfoliage.util.EPSILON_ZERO
+import mods.betterfoliage.util.get
 import mods.betterfoliage.util.minBy
 import net.minecraft.client.renderer.color.BlockColors
 import net.minecraft.util.Direction
 import net.minecraft.util.Direction.*
-import net.minecraft.util.Direction.Axis
-import net.minecraftforge.client.model.pipeline.LightUtil
 import kotlin.math.abs
 
 class VanillaQuadLighting {
@@ -34,7 +34,7 @@ class VanillaQuadLighting {
     }
 
     fun applyDiffuseLighting(face: Direction) {
-        val factor = LightUtil.diffuseLight(face)
+        val factor = ShadersModIntegration.diffuseShades[face]
         tint[0] *= factor; tint[1] *= factor; tint[2] *= factor
     }
 }

src/main/kotlin/mods/betterfoliage/render/old/AbstractEntityFX.kt

@@ -1,127 +0,0 @@
-package mods.betterfoliage.render.old
-
-import mods.betterfoliage.util.Double3
-import mods.betterfoliage.util.PI2
-import net.minecraft.client.Minecraft
-import net.minecraft.client.particle.IParticleRenderType
-import net.minecraft.client.particle.SpriteTexturedParticle
-import net.minecraft.client.renderer.BufferBuilder
-import net.minecraft.world.World
-import kotlin.math.cos
-import kotlin.math.sin
-
-abstract class AbstractEntityFX(world: World, x: Double, y: Double, z: Double) : SpriteTexturedParticle(world, x, y, z) {
-
-    companion object {
-        @JvmStatic val sin = Array(64) { idx -> sin(PI2 / 64.0 * idx) }
-        @JvmStatic val cos = Array(64) { idx -> cos(PI2 / 64.0 * idx) }
-    }
-
-    val billboardRot = Pair(Double3.zero, Double3.zero)
-    val currentPos = Double3.zero
-    val prevPos = Double3.zero
-    val velocity = Double3.zero
-
-    override fun tick() {
-        super.tick()
-        currentPos.setTo(posX, posY, posZ)
-        prevPos.setTo(prevPosX, prevPosY, prevPosZ)
-        velocity.setTo(motionX, motionY, motionZ)
-        update()
-        posX = currentPos.x; posY = currentPos.y; posZ = currentPos.z;
-        motionX = velocity.x; motionY = velocity.y; motionZ = velocity.z;
-    }
-
-    /** Render the particle. */
-    abstract fun render(worldRenderer: BufferBuilder, partialTickTime: Float)
-
-    /** Update particle on world tick. */
-    abstract fun update()
-
-    /** True if the particle is renderable. */
-    abstract val isValid: Boolean
-
-    /** Add the particle to the effect renderer if it is valid. */
-    fun addIfValid() { if (isValid) Minecraft.getInstance().particles.addEffect(this) }
-
-//    override fun renderParticle(buffer: BufferBuilder, entity: ActiveRenderInfo, partialTicks: Float, rotX: Float, rotZ: Float, rotYZ: Float, rotXY: Float, rotXZ: Float) {
-//        billboardRot.first.setTo(rotX + rotXY, rotZ, rotYZ + rotXZ)
-//        billboardRot.second.setTo(rotX - rotXY, -rotZ, rotYZ - rotXZ)
-//        render(buffer, partialTicks)
-//    }
-    /**
-     * Render a particle quad.
-     *
-     * @param[tessellator] the [Tessellator] instance to use
-     * @param[partialTickTime] partial tick time
-     * @param[currentPos] render position
-     * @param[prevPos] previous tick position for interpolation
-     * @param[size] particle size
-     * @param[rotation] viewpoint-dependent particle rotation (64 steps)
-     * @param[icon] particle texture
-     * @param[isMirrored] mirror particle texture along V-axis
-     * @param[alpha] aplha blending
-     */
-//    fun renderParticleQuad(worldRenderer: BufferBuilder,
-//                           partialTickTime: Float,
-//                           currentPos: Double3 = this.currentPos,
-//                           prevPos: Double3 = this.prevPos,
-//                           size: Double = particleScale.toDouble(),
-//                           rotation: Int = 0,
-//                           icon: TextureAtlasSprite = sprite,
-//                           isMirrored: Boolean = false,
-//                           alpha: Float = this.particleAlpha) {
-//
-//        val minU = (if (isMirrored) icon.minU else icon.maxU).toDouble()
-//        val maxU = (if (isMirrored) icon.maxU else icon.minU).toDouble()
-//        val minV = icon.minV.toDouble()
-//        val maxV = icon.maxV.toDouble()
-//
-//        val center = currentPos.copy().sub(prevPos).mul(partialTickTime.toDouble()).add(prevPos).sub(interpPosX, interpPosY, interpPosZ)
-//        val v1 = if (rotation == 0) billboardRot.first * size else
-//            Double3.weight(billboardRot.first, cos[rotation and 63] * size, billboardRot.second, sin[rotation and 63] * size)
-//        val v2 = if (rotation == 0) billboardRot.second * size else
-//            Double3.weight(billboardRot.first, -sin[rotation and 63] * size, billboardRot.second, cos[rotation and 63] * size)
-//
-//        val renderBrightness = this.getBrightnessForRender(partialTickTime)
-//        val brLow = renderBrightness shr 16 and 65535
-//        val brHigh = renderBrightness and 65535
-//
-//        worldRenderer
-//            .pos(center.x - v1.x, center.y - v1.y, center.z - v1.z)
-//            .tex(maxU, maxV)
-//            .color(particleRed, particleGreen, particleBlue, alpha)
-//            .lightmap(brLow, brHigh)
-//            .endVertex()
-//
-//        worldRenderer
-//            .pos(center.x - v2.x, center.y - v2.y, center.z - v2.z)
-//            .tex(maxU, minV)
-//            .color(particleRed, particleGreen, particleBlue, alpha)
-//            .lightmap(brLow, brHigh)
-//            .endVertex()
-//
-//        worldRenderer
-//            .pos(center.x + v1.x, center.y + v1.y, center.z + v1.z)
-//            .tex(minU, minV)
-//            .color(particleRed, particleGreen, particleBlue, alpha)
-//            .lightmap(brLow, brHigh)
-//            .endVertex()
-//
-//        worldRenderer
-//            .pos(center.x + v2.x, center.y + v2.y, center.z + v2.z)
-//            .tex(minU, maxV)
-//            .color(particleRed, particleGreen, particleBlue, alpha)
-//            .lightmap(brLow, brHigh)
-//            .endVertex()
-//    }
-
-    //    override fun getFXLayer() = 1
-    override fun getRenderType(): IParticleRenderType = IParticleRenderType.PARTICLE_SHEET_TRANSLUCENT
-
-    fun setColor(color: Int) {
-        particleBlue = (color and 255) / 256.0f
-        particleGreen = ((color shr 8) and 255) / 256.0f
-        particleRed = ((color shr 16) and 255) / 256.0f
-    }
-}

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

@@ -66,9 +66,11 @@ abstract class ConfigurableModelDiscovery : AbstractModelDiscovery() {
             detailLogger.log(Level.INFO, "      model ${ctx.modelLocation}")
             detailLogger.log(Level.INFO, "      class ${ctx.blockState.block.javaClass.name} matches ${matchClass.name}")
 
-            modelTextures
+            val ancestry = ctx.bakery.getAncestry(ctx.modelLocation)
-                .filter { matcher -> ctx.bakery.modelDerivesFrom(model, ctx.modelLocation, matcher.modelLocation) }
+            val matches = modelTextures.filter { matcher ->
-                .forEach { match ->
+                matcher.modelLocation in ancestry
+            }
+            matches.forEach { match ->
                     detailLogger.log(Level.INFO, "      model $model matches ${match.modelLocation}")
 
                     val materials = match.textureNames.map { it to model.resolveTextureName(it) }
@@ -91,3 +93,9 @@ fun ModelBakery.modelDerivesFrom(model: BlockModel, location: ResourceLocation,
         ?.let { getUnbakedModel(it) as? BlockModel }
         ?.let { parent -> modelDerivesFrom(parent, model.parentLocation!!, target) }
         ?: false
+
+fun ModelBakery.getAncestry(location: ResourceLocation): List<ResourceLocation> {
+    val model = getUnbakedModel(location) as? BlockModel ?: return listOf(location)
+    val parentAncestry = model.parentLocation?.let { getAncestry(it) } ?: emptyList()
+    return listOf(location) + parentAncestry
+}

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

@@ -4,6 +4,6 @@ import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.block.material.Material
 
-val BlockState.isSnow: Boolean get() = material.let { it == Material.SNOW }
+
 
 val DIRT_BLOCKS = listOf(Blocks.DIRT, Blocks.COARSE_DIRT)

src/main/resources/META-INF/accesstransformer.cfg

@@ -1,14 +1,5 @@
-#public net.minecraft.client.renderer.BlockModelRenderer$AmbientOcclusionFace
-#public net.minecraft.client.renderer.BlockModelRenderer$AmbientOcclusionFace <init>
-#public net.minecraft.client.renderer.BlockModelRenderer$AmbientOcclusionFace field_178206_b #vertexColorMultiplier
-#public net.minecraft.client.renderer.BlockModelRenderer$AmbientOcclusionFace field_178207_c #vertexBrightness
-
-#public net.minecraft.block.BlockState$Cache
-
 public net.minecraft.client.renderer.chunk.ChunkRenderCache field_212408_i #world
 
-#public net.minecraft.client.renderer.texture.AtlasTexture$SheetData field_217808_d # sprites
-
 public net.minecraft.client.renderer.BlockModelRenderer$Cache
 public net.minecraft.client.renderer.BlockModelRenderer field_210267_b
-public net.minecraft.client.renderer.BlockModelRenderer field_187499_a
+public net.minecraft.client.renderer.BlockModelRenderer field_187499_a