remove some Fabric aliases

use the low-level call on SVertexBuilder to set apparent block ID for the current draw

build.gradle.kts

@@ -15,20 +15,13 @@ dependencies {
     "minecraft"("net.minecraftforge:forge:${properties["mcVersion"]}-${properties["forgeVersion"]}")
 
     "implementation"("kottle:Kottle:${properties["kottleVersion"]}")
-
     "implementation"("org.spongepowered:mixin:0.8-SNAPSHOT")
-    annotationProcessor("org.spongepowered:mixin:0.8-SNAPSHOT")
 }
 
+configurations["annotationProcessor"].extendsFrom(configurations["implementation"])
 sourceSets {
     get("main").ext["refMap"] = "betterfoliage.refmap.json"
-    get("main").resources.srcDir("src/forge/resources")
-    get("main").java.srcDir("src/forge/java")
 }
-kotlin.sourceSets {
-    get("main").kotlin.srcDir("src/forge/kotlin")
-}
-
 
 minecraft {
     mappings(properties["mappingsChannel"] as String, properties["mappingsVersion"] as String)
@@ -62,4 +55,6 @@ tasks.getByName<Jar>("jar") {
         attributes["Implementation-Version"] = project.version
     }
     exclude("net")
+    filesMatching("META-INF/mods.toml") { expand(project.properties) }
+    filesMatching("mcmod.info") { expand(project.properties) }
 }

gradle.properties

@@ -4,10 +4,10 @@ org.gradle.daemon=false
 group = com.github.octarine-noise
 jarName = BetterFoliage-Forge
 
-version = 2.3.1
+version = 2.5.1
 
 mcVersion = 1.14.4
-forgeVersion = 28.1.109
+forgeVersion = 28.2.0
 mappingsChannel = snapshot
 mappingsVersion = 20190719-1.14.3
 

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

@@ -1,7 +1,6 @@
 package mods.betterfoliage.mixin;
 
 import mods.betterfoliage.BetterFoliage;
-import mods.octarinecore.client.resource.AsnycSpriteProviderManager;
 import net.minecraft.client.renderer.model.ModelBakery;
 import net.minecraft.client.renderer.texture.AtlasTexture;
 import net.minecraft.profiler.IProfiler;
@@ -19,9 +18,12 @@ abstract public class MixinModelBakery {
 
     @Redirect(method = processLoading, at = @At(value = "INVOKE", target = stitch))
     AtlasTexture.SheetData onStitchModelTextures(AtlasTexture atlas, IResourceManager manager, Iterable<ResourceLocation> idList, IProfiler profiler) {
-        AsnycSpriteProviderManager.StitchWrapper wrapper = BetterFoliage.INSTANCE.getBlockSprites().prepare(this, atlas, manager, idList, profiler);
+        return BetterFoliage.INSTANCE.getBlockSprites().finish(
-        AtlasTexture.SheetData sheet = atlas.stitch(manager, wrapper.getIdList(), profiler);
+            atlas.stitch(
-        wrapper.complete(sheet);
+                manager,
-        return sheet;
+                BetterFoliage.INSTANCE.getBlockSprites().prepare(this, manager, idList, profiler),
+                profiler
+            ), profiler
+        );
     }
 }

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

@@ -21,9 +21,13 @@ public class MixinParticleManager {
     @SuppressWarnings("UnresolvedMixinReference")
     @Redirect(method = "*", at = @At(value = "INVOKE", target = stitch))
     AtlasTexture.SheetData onStitchModelTextures(AtlasTexture atlas, IResourceManager manager, Iterable<ResourceLocation> idList, IProfiler profiler) {
-        AsnycSpriteProviderManager.StitchWrapper wrapper = BetterFoliage.INSTANCE.getParticleSprites().prepare(this, atlas, manager, idList, profiler);
+        return BetterFoliage.INSTANCE.getParticleSprites().finish(
-        AtlasTexture.SheetData sheet = atlas.stitch(manager, wrapper.getIdList(), profiler);
+            atlas.stitch(
-        wrapper.complete(sheet);
+                manager,
-        return sheet;
+                BetterFoliage.INSTANCE.getParticleSprites().prepare(this, manager, idList, profiler),
+                profiler
+            ), profiler
+        );
     }
+
 }

src/main/kotlin/mods/betterfoliage/client/Client.kt

@@ -57,10 +57,10 @@ object Client {
         // init mod integrations
         val integrations = listOf(
             ShadersModIntegration,
-            OptifineCustomColors,
+            OptifineCustomColors
-            ForestryIntegration,
+//            ForestryIntegration,
-            IC2RubberIntegration,
+//            IC2RubberIntegration,
-            TechRebornRubberIntegration
+//            TechRebornRubberIntegration
         )
 
         LeafParticleRegistry.init()

src/main/kotlin/mods/betterfoliage/client/Hooks.kt

@@ -77,7 +77,7 @@ fun renderWorldBlock(dispatcher: BlockRendererDispatcher,
 ): Boolean {
     // build context
     val blockCtx = CachedBlockCtx(reader, pos)
-    val renderCtx = RenderCtx(dispatcher, buffer, layer, random)
+    val renderCtx = RenderCtx(dispatcher, buffer, layer, random, modelData)
     lightingCtx.reset(blockCtx)
     val combinedCtx = CombinedContext(blockCtx, renderCtx, lightingCtx)
 

src/main/kotlin/mods/betterfoliage/client/config/Config.kt

@@ -120,7 +120,7 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.MOD_I
         val windStrength by double(min=0.1, max=2.0, default=0.5)
         val stormStrength by double(min=0.1, max=2.0, default=0.8)
         val size by double(min=0.25, max=1.5, default=0.75).lang("size")
-        val chance by double(min=0.001, max=1.0, default=0.05)
+        val chance by double(min=0.001, max=1.0, default=0.02)
         val perturb by double(min=0.01, max=1.0, default=0.25)
         val lifetime by double(min=1.0, max=15.0, default=5.0)
         val opacityHack by boolean(true)
@@ -153,10 +153,7 @@ object BlockConfig {
     val crops = blocks("crop_default.cfg")
     val logBlocks = blocks("log_blocks_default.cfg")
     val logModels = models("log_models_default.cfg")
-    val sand = blocks("sand_default.cfg")
     val lilypad = blocks("lilypad_default.cfg")
-    val cactus = blocks("cactus_default.cfg")
-    val netherrack = blocks("netherrack_blocks_default.cfg")
 
     init { BetterFoliageMod.bus.register(this) }
     private fun blocks(cfgName: String) = ConfigurableBlockMatcher(BetterFoliage.logDetail, ResourceLocation(BetterFoliageMod.MOD_ID, cfgName)).apply { list.add(this) }

src/main/kotlin/mods/betterfoliage/client/integration/ForestryIntegration.kt

@@ -5,7 +5,6 @@ import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.render.AsyncLogDiscovery
 import mods.betterfoliage.client.render.column.ColumnTextureInfo
 import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.betterfoliage.client.resource.Identifier
 import mods.betterfoliage.client.texture.LeafInfo
 import mods.betterfoliage.client.texture.defaultRegisterLeaf
 import mods.octarinecore.HasLogger
@@ -19,6 +18,7 @@ import net.minecraft.block.BlockState
 import net.minecraft.client.Minecraft
 import net.minecraft.client.renderer.model.ModelBakery
 import net.minecraft.resources.IResourceManager
+import net.minecraft.util.ResourceLocation
 import net.minecraft.util.math.BlockPos
 import net.minecraft.world.IBlockReader
 import net.minecraftforge.fml.ModList
@@ -54,13 +54,14 @@ val ILeafSpriteProvider_getSprite = MethodRef(ILeafSpriteProvider, "getSprite",
 object ForestryIntegration {
     init {
         if (ModList.get().isLoaded("forestry") && allAvailable(TileLeaves_getLeaveSprite, IAlleleTreeSpecies_getLeafSpriteProvider, ILeafSpriteProvider_getSprite)) {
+            // Just keep it inactive for now until Forestry updates
         }
     }
 }
 
 object ForestryLeafDiscovery : HasLogger, AsyncSpriteProvider<ModelBakery>, ModelRenderRegistry<LeafInfo> {
     override val logger = BetterFoliage.logDetail
-    var idToValue = emptyMap<Identifier, LeafInfo>()
+    var idToValue = emptyMap<ResourceLocation, LeafInfo>()
 
     override fun get(state: BlockState, world: IBlockReader, pos: BlockPos): LeafInfo? {
         // check variant property (used in decorative leaves)
@@ -81,7 +82,7 @@ object ForestryLeafDiscovery : HasLogger, AsyncSpriteProvider<ModelBakery>, Mode
     }
 
     override fun setup(manager: IResourceManager, bakeryF: CompletableFuture<ModelBakery>, atlasFuture: AtlasFuture): StitchPhases {
-        val futures = mutableMapOf<Identifier, CompletableFuture<LeafInfo>>()
+        val futures = mutableMapOf<ResourceLocation, CompletableFuture<LeafInfo>>()
 
         return StitchPhases(
             discovery = bakeryF.thenRunAsync {

src/main/kotlin/mods/betterfoliage/client/integration/RubberIntegration.kt

@@ -1,9 +1,9 @@
 package mods.betterfoliage.client.integration
 
 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.client.render.LogRegistry
 import mods.betterfoliage.client.render.column.ColumnTextureInfo
 import mods.betterfoliage.client.render.column.SimpleColumnInfo
+import mods.octarinecore.Sprite
 import mods.octarinecore.client.render.CombinedContext
 import mods.octarinecore.client.render.Quad
 import mods.octarinecore.client.render.lighting.QuadIconResolver
@@ -12,27 +12,29 @@ import mods.octarinecore.common.rotate
 import mods.octarinecore.metaprog.ClassRef
 import mods.octarinecore.metaprog.allAvailable
 import net.minecraft.client.renderer.model.BlockModel
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
 import net.minecraft.util.Direction
 import net.minecraft.util.Direction.*
 import net.minecraft.util.ResourceLocation
 import net.minecraftforge.fml.ModList
-import org.apache.logging.log4j.Level
 import java.util.concurrent.CompletableFuture
 
+
 object IC2RubberIntegration {
 
     val BlockRubWood = ClassRef<Any>("ic2.core.block.BlockRubWood")
 
     init {
         if (ModList.get().isLoaded("ic2") && allAvailable(BlockRubWood)) {
-            BetterFoliage.log(Level.INFO, "IC2 rubber support initialized")
+            // keep it inactive for now until IC2 updates
-            LogRegistry.registries.add(IC2LogDiscovery)
+//            BetterFoliage.log(Level.INFO, "IC2 rubber support initialized")
-            BetterFoliage.blockSprites.providers.add(IC2LogDiscovery)
+//            LogRegistry.registries.add(IC2LogDiscovery)
+//            BetterFoliage.blockSprites.providers.add(IC2LogDiscovery)
         }
     }
 }
 
+// Probably unneeded, as TechReborn went Fabric-only
+/*
 object TechRebornRubberIntegration {
 
     val BlockRubberLog = ClassRef<Any>("techreborn.blocks.BlockRubberLog")
@@ -45,14 +47,15 @@ object TechRebornRubberIntegration {
         }
     }
 }
+ */
 
 class RubberLogInfo(
     axis: Axis?,
     val spotDir: Direction,
-    topTexture: TextureAtlasSprite,
+    topTexture: Sprite,
-    bottomTexture: TextureAtlasSprite,
+    bottomTexture: Sprite,
-    val spotTexture: TextureAtlasSprite,
+    val spotTexture: Sprite,
-    sideTextures: List<TextureAtlasSprite>
+    sideTextures: List<Sprite>
 ) : SimpleColumnInfo(axis, topTexture, bottomTexture, sideTextures) {
 
     override val side: QuadIconResolver = { ctx: CombinedContext, idx: Int, quad: Quad ->
@@ -116,6 +119,7 @@ object IC2LogDiscovery : ModelDiscovery<ColumnTextureInfo>() {
     }
 }
 
+/*
 object TechRebornLogDiscovery : ModelDiscovery<ColumnTextureInfo>() {
     override val logger = BetterFoliage.logDetail
 
@@ -152,4 +156,5 @@ object TechRebornLogDiscovery : ModelDiscovery<ColumnTextureInfo>() {
         }
         return null
     }
-}
+}
+ */

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

@@ -2,8 +2,6 @@ package mods.betterfoliage.client.integration
 
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.texture.GrassRegistry
 import mods.betterfoliage.client.texture.LeafRegistry
 import mods.octarinecore.*
 import mods.octarinecore.client.render.CombinedContext
@@ -13,7 +11,6 @@ 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.math.BlockPos
 import net.minecraft.world.IEnviromentBlockReader
 import org.apache.logging.log4j.Level.INFO
@@ -23,10 +20,10 @@ import org.apache.logging.log4j.Level.INFO
  */
 object ShadersModIntegration {
 
-    @JvmStatic val isAvailable = allAvailable(SVertexBuilder, SVertexBuilder.pushState, SVertexBuilder.pushNum, SVertexBuilder.pop)
+    @JvmStatic val isAvailable = allAvailable(SVertexBuilder, SVertexBuilder.pushState, SVertexBuilder.popState, BlockAliases.getAliasBlockId)
 
     val defaultLeaves = Blocks.OAK_LEAVES.defaultState
-    val defaultGrass = Blocks.TALL_GRASS.defaultState
+    val defaultGrass = Blocks.GRASS.defaultState
 
     /**
      * Called from transformed ShadersMod code.
@@ -49,10 +46,11 @@ object ShadersModIntegration {
     inline fun renderAs(ctx: CombinedContext, state: BlockState, renderType: BlockRenderType, enabled: Boolean = true, func: ()->Unit) {
         if (isAvailable && enabled) {
             val buffer = ctx.renderCtx.renderBuffer
+            val aliasBlockId = BlockAliases.getAliasBlockId.invokeStatic(state)
             val sVertexBuilder = buffer[BufferBuilder_sVertexBuilder]
-            SVertexBuilder.pushState.invoke(sVertexBuilder, ctx.state, ctx.pos, ctx.world, buffer)
+            SVertexBuilder.pushState.invoke(sVertexBuilder, aliasBlockId)
             func()
-            SVertexBuilder.pop.invoke(sVertexBuilder)
+            SVertexBuilder.popState.invoke(sVertexBuilder)
         } else {
             func()
         }

src/main/kotlin/mods/betterfoliage/client/render/EntityRisingSoulFX.kt

@@ -1,10 +1,7 @@
 package mods.betterfoliage.client.render
 
-import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.client.render.AbstractEntityFX
 import mods.octarinecore.client.resource.Atlas
 import mods.octarinecore.client.resource.ResourceHandler
@@ -15,7 +12,6 @@ import net.minecraft.util.ResourceLocation
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.MathHelper
 import net.minecraft.world.World
-import org.apache.logging.log4j.Level.DEBUG
 import java.util.*
 
 class EntityRisingSoulFX(world: World, pos: BlockPos) :
@@ -69,5 +65,5 @@ AbstractEntityFX(world, pos.x.toDouble() + 0.5, pos.y.toDouble() + 1.0, pos.z.to
 
 object RisingSoulTextures : ResourceHandler(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus, targetAtlas = Atlas.PARTICLES) {
     val headIcons = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "rising_soul_$idx") }
-    val trackIcon by sprite(Identifier(BetterFoliageMod.MOD_ID, "soul_track"))
+    val trackIcon by sprite(ResourceLocation(BetterFoliageMod.MOD_ID, "soul_track"))
 }

src/main/kotlin/mods/betterfoliage/client/render/RenderCactus.kt

@@ -5,7 +5,6 @@ import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.client.config.Config
 import mods.betterfoliage.client.render.column.ColumnTextureInfo
 import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.client.render.*
 import mods.octarinecore.client.render.lighting.*
 import mods.octarinecore.client.resource.*
@@ -15,7 +14,7 @@ import mods.octarinecore.common.config.SimpleBlockMatcher
 import net.minecraft.block.BlockState
 import net.minecraft.block.CactusBlock
 import net.minecraft.util.Direction.*
-import org.apache.logging.log4j.Level.DEBUG
+import net.minecraft.util.ResourceLocation
 import java.util.concurrent.CompletableFuture
 
 object AsyncCactusDiscovery : ConfigurableModelDiscovery<ColumnTextureInfo>() {
@@ -23,7 +22,7 @@ object AsyncCactusDiscovery : ConfigurableModelDiscovery<ColumnTextureInfo>() {
     override val matchClasses = SimpleBlockMatcher(CactusBlock::class.java)
     override val modelTextures = listOf(ModelTextureList("block/cactus", "top", "bottom", "side"))
     override fun processModel(state: BlockState, textures: List<String>, atlas: AtlasFuture): CompletableFuture<ColumnTextureInfo>? {
-        val sprites = textures.map { atlas.sprite(Identifier(it)) }
+        val sprites = textures.map { atlas.sprite(ResourceLocation(it)) }
         return atlas.mapAfter {
             SimpleColumnInfo(
                 Axis.Y,
@@ -44,8 +43,8 @@ class RenderCactus : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.b
     val cactusStemRadius = 0.4375
     val cactusArmRotation = listOf(NORTH, SOUTH, EAST, WEST).map { Rotation.rot90[it.ordinal] }
 
-    val iconCross by sprite(Identifier(BetterFoliageMod.MOD_ID, "blocks/better_cactus"))
+    val iconCross by sprite(ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_cactus"))
-    val iconArm = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_cactus_arm_$idx") }
+    val iconArm = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_cactus_arm_$idx") }
 
     val modelStem = model {
         horizontalRectangle(x1 = -cactusStemRadius, x2 = cactusStemRadius, z1 = -cactusStemRadius, z2 = cactusStemRadius, y = 0.5)

src/main/kotlin/mods/betterfoliage/client/render/RenderCoral.kt

@@ -10,6 +10,7 @@ import mods.octarinecore.client.render.lighting.*
 import mods.octarinecore.common.allDirections
 import mods.octarinecore.random
 import net.minecraft.block.material.Material
+import net.minecraft.tags.BlockTags
 import net.minecraft.util.Direction.Axis
 import net.minecraft.util.Direction.UP
 import net.minecraft.util.ResourceLocation
@@ -41,7 +42,7 @@ class RenderCoral : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bu
         Config.enabled && Config.coral.enabled &&
         (ctx.state(up2).material == Material.WATER || Config.coral.shallowWater) &&
         ctx.state(up1).material == Material.WATER &&
-        BlockConfig.sand.matchesClass(ctx.state.block) &&
+        BlockTags.SAND.contains(ctx.state.block) &&
         ctx.biome.category.let { it == Biome.Category.OCEAN || it == Biome.Category.BEACH } &&
         noise[ctx.pos] < Config.coral.population
 

src/main/kotlin/mods/betterfoliage/client/render/RenderGrass.kt

@@ -2,11 +2,9 @@ package mods.betterfoliage.client.render
 
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.config.Config
 import mods.betterfoliage.client.integration.OptifineCustomColors
 import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.betterfoliage.client.resource.Identifier
 import mods.betterfoliage.client.texture.GeneratedGrass
 import mods.betterfoliage.client.texture.GrassRegistry
 import mods.octarinecore.client.render.CombinedContext
@@ -20,8 +18,10 @@ import mods.octarinecore.common.Double3
 import mods.octarinecore.common.allDirections
 import mods.octarinecore.random
 import net.minecraft.tags.BlockTags
-import net.minecraft.util.Direction.*
+import net.minecraft.util.Direction.Axis
-import org.apache.logging.log4j.Level.DEBUG
+import net.minecraft.util.Direction.DOWN
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
 
 class RenderGrass : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
 
@@ -38,10 +38,10 @@ class RenderGrass : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bu
 
     val noise = simplexNoise()
 
-    val normalIcons = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_grass_long_$idx") }
+    val normalIcons = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_grass_long_$idx") }
-    val snowedIcons = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_grass_snowed_$idx") }
+    val snowedIcons = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_grass_snowed_$idx") }
-    val normalGenIcon by sprite { GeneratedGrass(sprite = "minecraft:blocks/tallgrass", isSnowed = false).register(BetterFoliage.asyncPack) }
+    val normalGenIcon by sprite { GeneratedGrass(sprite = "minecraft:blocks/tall_grass_top", isSnowed = false).register(BetterFoliage.asyncPack) }
-    val snowedGenIcon by sprite { GeneratedGrass(sprite = "minecraft:blocks/tallgrass", isSnowed = true).register(BetterFoliage.asyncPack) }
+    val snowedGenIcon by sprite { GeneratedGrass(sprite = "minecraft:blocks/tall_grass_top", isSnowed = true).register(BetterFoliage.asyncPack) }
 
     val grassModels = modelSet(64) { idx -> grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax)(idx) }
 

src/main/kotlin/mods/betterfoliage/client/render/RenderLeaves.kt

@@ -4,7 +4,6 @@ import mods.betterfoliage.BetterFoliageMod
 import mods.betterfoliage.client.config.Config
 import mods.betterfoliage.client.integration.OptifineCustomColors
 import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.betterfoliage.client.resource.Identifier
 import mods.betterfoliage.client.texture.LeafRegistry
 import mods.octarinecore.PI2
 import mods.octarinecore.client.render.CombinedContext
@@ -18,6 +17,7 @@ import mods.octarinecore.common.allDirections
 import mods.octarinecore.common.vec
 import mods.octarinecore.random
 import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
 import java.lang.Math.cos
 import java.lang.Math.sin
 
@@ -30,7 +30,7 @@ class RenderLeaves : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.b
         .scale(Config.leaves.size)
         .toCross(UP).addAll()
     }
-    val snowedIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_leaves_snowed_$idx") }
+    val snowedIcon = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_leaves_snowed_$idx") }
 
     val perturbs = vectorSet(64) { idx ->
         val angle = PI2 * idx / 64.0

src/main/kotlin/mods/betterfoliage/client/render/RenderLilypad.kt

@@ -1,19 +1,16 @@
 package mods.betterfoliage.client.render
 
-import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.config.Config
 import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.client.render.CombinedContext
 import mods.octarinecore.client.render.RenderDecorator
 import mods.octarinecore.client.render.lighting.FlatOffsetNoColor
 import mods.octarinecore.common.Int3
 import net.minecraft.util.Direction.DOWN
 import net.minecraft.util.Direction.UP
-import org.apache.logging.log4j.Level.DEBUG
+import net.minecraft.util.ResourceLocation
 
 class RenderLilypad : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
 
@@ -28,8 +25,8 @@ class RenderLilypad : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.
         .setFlatShader(FlatOffsetNoColor(Int3.zero))
         .toCross(UP).addAll()
     }
-    val rootIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_lilypad_roots_$idx") }
+    val rootIcon = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_lilypad_roots_$idx") }
-    val flowerIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_lilypad_flower_$idx") }
+    val flowerIcon = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_lilypad_flower_$idx") }
     val perturbs = vectorSet(64) { modelIdx -> xzDisk(modelIdx) * Config.lilypad.hOffset }
 
     override fun isEligible(ctx: CombinedContext): Boolean =

src/main/kotlin/mods/betterfoliage/client/render/RenderLog.kt

@@ -9,7 +9,6 @@ import mods.betterfoliage.client.render.column.AbstractRenderColumn
 import mods.betterfoliage.client.render.column.ColumnRenderLayer
 import mods.betterfoliage.client.render.column.ColumnTextureInfo
 import mods.betterfoliage.client.render.column.SimpleColumnInfo
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.client.render.CombinedContext
 import mods.octarinecore.client.resource.*
 import mods.octarinecore.common.config.ConfigurableBlockMatcher
@@ -18,6 +17,7 @@ import mods.octarinecore.tryDefault
 import net.minecraft.block.BlockState
 import net.minecraft.block.LogBlock
 import net.minecraft.util.Direction.Axis
+import net.minecraft.util.ResourceLocation
 import org.apache.logging.log4j.Level
 import java.util.concurrent.CompletableFuture
 
@@ -57,7 +57,7 @@ object AsyncLogDiscovery : ConfigurableModelDiscovery<ColumnTextureInfo>() {
     override fun processModel(state: BlockState, textures: List<String>, atlas: AtlasFuture): CompletableFuture<ColumnTextureInfo> {
         val axis = getAxis(state)
         logger.log(Level.DEBUG, "$logName:       axis $axis")
-        val spriteList = textures.map { atlas.sprite(Identifier(it)) }
+        val spriteList = textures.map { atlas.sprite(ResourceLocation(it)) }
         return atlas.mapAfter {
             SimpleColumnInfo(
                 axis,

src/main/kotlin/mods/betterfoliage/client/render/RenderMycelium.kt

@@ -1,21 +1,18 @@
 package mods.betterfoliage.client.render
 
-import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.client.render.CombinedContext
 import mods.octarinecore.client.render.RenderDecorator
 import mods.octarinecore.client.render.noPost
 import mods.octarinecore.common.Double3
 import net.minecraft.util.Direction.UP
-import org.apache.logging.log4j.Level.DEBUG
+import net.minecraft.util.ResourceLocation
 
 class RenderMycelium : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
 
-    val myceliumIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_mycel_$idx") }
+    val myceliumIcon = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_mycel_$idx") }
     val myceliumModel = modelSet(64) { idx -> RenderGrass.grassTopQuads(Config.shortGrass.heightMin, Config.shortGrass.heightMax)(idx) }
 
     override fun isEligible(ctx: CombinedContext): Boolean {

src/main/kotlin/mods/betterfoliage/client/render/RenderNetherrack.kt

@@ -1,21 +1,22 @@
 package mods.betterfoliage.client.render
 
-import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
-import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.resource.Identifier
+import mods.octarinecore.client.render.CombinedContext
-import mods.octarinecore.client.render.*
+import mods.octarinecore.client.render.RenderDecorator
-import mods.octarinecore.client.render.lighting.*
+import mods.octarinecore.client.render.lighting.cornerAo
+import mods.octarinecore.client.render.lighting.cornerFlat
+import mods.octarinecore.client.render.lighting.faceOrientedAuto
 import mods.octarinecore.random
+import net.minecraft.block.Blocks
 import net.minecraft.util.Direction.Axis
-import net.minecraft.util.Direction.*
+import net.minecraft.util.Direction.DOWN
-import org.apache.logging.log4j.Level.DEBUG
+import net.minecraft.util.Direction.UP
+import net.minecraft.util.ResourceLocation
 
 class RenderNetherrack : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
 
-    val netherrackIcon = spriteSet { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_netherrack_$idx") }
+    val netherrackIcon = spriteSet { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_netherrack_$idx") }
     val netherrackModel = modelSet(64) { modelIdx ->
         verticalRectangle(x1 = -0.5, z1 = 0.5, x2 = 0.5, z2 = -0.5, yTop = -0.5,
         yBottom = -0.5 - random(Config.netherrack.heightMin, Config.netherrack.heightMax))
@@ -25,10 +26,8 @@ class RenderNetherrack : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageM
 
     }
 
-    override fun isEligible(ctx: CombinedContext): Boolean {
+    override fun isEligible(ctx: CombinedContext) =
-        if (!Config.enabled || !Config.netherrack.enabled) return false
+        Config.enabled && Config.netherrack.enabled && ctx.state.block == Blocks.NETHERRACK
-        return BlockConfig.netherrack.matchesClass(ctx.state.block)
-    }
 
     override fun render(ctx: CombinedContext) {
         ctx.render()

src/main/kotlin/mods/betterfoliage/client/render/RenderReeds.kt

@@ -2,10 +2,8 @@ package mods.betterfoliage.client.render
 
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.Client
 import mods.betterfoliage.client.config.Config
 import mods.betterfoliage.client.integration.ShadersModIntegration
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.client.render.CombinedContext
 import mods.octarinecore.client.render.RenderDecorator
 import mods.octarinecore.client.render.lighting.FlatOffsetNoColor
@@ -14,13 +12,13 @@ import mods.octarinecore.random
 import net.minecraft.block.material.Material
 import net.minecraft.tags.BlockTags
 import net.minecraft.util.Direction.UP
-import org.apache.logging.log4j.Level.DEBUG
+import net.minecraft.util.ResourceLocation
 
 class RenderReeds : RenderDecorator(BetterFoliageMod.MOD_ID, BetterFoliageMod.bus) {
 
     val noise = simplexNoise()
     val reedIcons = spriteSetTransformed(
-        check = { idx -> Identifier(BetterFoliageMod.MOD_ID, "blocks/better_reed_$idx")},
+        check = { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "blocks/better_reed_$idx") },
         register = { CenteredSprite(it).register(BetterFoliage.asyncPack) }
     )
     val reedModels = modelSet(64) { modelIdx ->

src/main/kotlin/mods/betterfoliage/client/render/column/OverlayLayer.kt

@@ -1,5 +1,6 @@
 package mods.betterfoliage.client.render.column
 
+import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.chunk.ChunkOverlayLayer
 import mods.betterfoliage.client.chunk.ChunkOverlayManager
 import mods.betterfoliage.client.chunk.dimType
@@ -72,7 +73,7 @@ abstract class ColumnRenderLayer : ChunkOverlayLayer<ColumnLayerData> {
     }
 
     override fun calculate(ctx: BlockCtx): ColumnLayerData {
-        if (allDirections.all { ctx.offset(it).isNormalCube }) return ColumnLayerData.SkipRender
+        if (allDirections.all { dir -> ctx.offset(dir).let { it.isNormalCube && registry[ctx] == null }}) return ColumnLayerData.SkipRender
         val columnTextures = registry[ctx] ?: return ColumnLayerData.ResolveError
 
         // if log axis is not defined and "Default to vertical" config option is not set, render normally

src/main/kotlin/mods/betterfoliage/client/resource/Aliases.kt

@@ -1,10 +0,0 @@
-package mods.betterfoliage.client.resource
-
-import net.minecraft.client.renderer.model.ModelResourceLocation
-import net.minecraft.client.renderer.texture.TextureAtlasSprite
-import net.minecraft.util.ResourceLocation
-
-typealias Identifier = ResourceLocation
-typealias ModelIdentifier = ModelResourceLocation
-
-typealias Sprite = TextureAtlasSprite

src/main/kotlin/mods/betterfoliage/client/texture/GeneratedGrass.kt

@@ -1,8 +1,8 @@
 package mods.betterfoliage.client.texture
 
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.client.resource.*
 import net.minecraft.resources.IResourceManager
+import net.minecraft.util.ResourceLocation
 import java.awt.image.BufferedImage
 
 /**
@@ -11,8 +11,8 @@ import java.awt.image.BufferedImage
  *
  * @param[domain] Resource domain of generator
  */
-data class GeneratedGrass(val sprite: Identifier, val isSnowed: Boolean, val atlas: Atlas = Atlas.BLOCKS) {
+data class GeneratedGrass(val sprite: ResourceLocation, val isSnowed: Boolean, val atlas: Atlas = Atlas.BLOCKS) {
-    constructor(sprite: String, isSnowed: Boolean) : this(Identifier(sprite), isSnowed)
+    constructor(sprite: String, isSnowed: Boolean) : this(ResourceLocation(sprite), isSnowed)
 
     fun register(pack: GeneratedBlockTexturePack) = pack.register(this, this::draw)
 

src/main/kotlin/mods/betterfoliage/client/texture/GrassRegistry.kt

@@ -3,13 +3,16 @@ package mods.betterfoliage.client.texture
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.config.BlockConfig
 import mods.betterfoliage.client.config.Config
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.client.render.lighting.HSB
-import mods.octarinecore.client.resource.*
+import mods.octarinecore.client.resource.AtlasFuture
+import mods.octarinecore.client.resource.ConfigurableModelDiscovery
+import mods.octarinecore.client.resource.ModelRenderRegistryRoot
+import mods.octarinecore.client.resource.averageColor
 import mods.octarinecore.common.config.ConfigurableBlockMatcher
 import mods.octarinecore.common.config.ModelTextureList
 import net.minecraft.block.BlockState
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.ResourceLocation
 import org.apache.logging.log4j.Level
 import java.lang.Math.min
 import java.util.concurrent.CompletableFuture
@@ -39,7 +42,7 @@ object AsyncGrassDiscovery : ConfigurableModelDiscovery<GrassInfo>() {
 
     override fun processModel(state: BlockState, textures: List<String>, atlas: AtlasFuture): CompletableFuture<GrassInfo> {
         val textureName = textures[0]
-        val spriteF = atlas.sprite(Identifier(textureName))
+        val spriteF = atlas.sprite(ResourceLocation(textureName))
         logger.log(Level.DEBUG, "$logName:       texture $textureName")
         return atlas.mapAfter {
             val sprite = spriteF.get()

src/main/kotlin/mods/betterfoliage/client/texture/LeafParticleRegistry.kt

@@ -2,12 +2,10 @@ package mods.betterfoliage.client.texture
 
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.BetterFoliageMod
-import mods.betterfoliage.client.resource.Identifier
+import mods.octarinecore.Sprite
-import mods.betterfoliage.client.resource.Sprite
 import mods.octarinecore.client.resource.*
-import mods.octarinecore.stripStart
-import mods.octarinecore.client.resource.Atlas
 import mods.octarinecore.common.sinkAsync
+import mods.octarinecore.stripStart
 import net.minecraft.client.particle.ParticleManager
 import net.minecraft.resources.IResourceManager
 import net.minecraft.util.ResourceLocation
@@ -31,11 +29,11 @@ object LeafParticleRegistry : AsyncSpriteProvider<ParticleManager> {
 
         return StitchPhases(
             discovery = particleF.sinkAsync {
-                typeMappings.loadMappings(Identifier(BetterFoliageMod.MOD_ID, "leaf_texture_mappings.cfg"))
+                typeMappings.loadMappings(ResourceLocation(BetterFoliageMod.MOD_ID, "leaf_texture_mappings.cfg"))
                 (typeMappings.mappings.map { it.type } + "default").distinct().forEach { leafType ->
-                    val ids = (0 until 16).map { idx -> Identifier(BetterFoliageMod.MOD_ID, "falling_leaf_${leafType}_$idx") }
+                    val ids = (0 until 16).map { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "falling_leaf_${leafType}_$idx") }
                     val wids = ids.map { Atlas.PARTICLES.wrap(it) }
-                    futures[leafType] = (0 until 16).map { idx -> Identifier(BetterFoliageMod.MOD_ID, "falling_leaf_${leafType}_$idx") }
+                    futures[leafType] = (0 until 16).map { idx -> ResourceLocation(BetterFoliageMod.MOD_ID, "falling_leaf_${leafType}_$idx") }
                         .filter { manager.hasResource(Atlas.PARTICLES.wrap(it)) }
                         .map { atlasFuture.sprite(it) }
                 }

src/main/kotlin/mods/betterfoliage/client/texture/LeafRegistry.kt

@@ -2,13 +2,13 @@ package mods.betterfoliage.client.texture
 
 import mods.betterfoliage.BetterFoliage
 import mods.betterfoliage.client.config.BlockConfig
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.HasLogger
 import mods.octarinecore.client.resource.*
 import mods.octarinecore.common.config.ConfigurableBlockMatcher
 import mods.octarinecore.common.config.ModelTextureList
 import net.minecraft.block.BlockState
 import net.minecraft.client.renderer.texture.TextureAtlasSprite
+import net.minecraft.util.ResourceLocation
 import java.util.concurrent.CompletableFuture
 
 const val defaultLeafColor = 0
@@ -35,7 +35,8 @@ object AsyncLeafDiscovery : ConfigurableModelDiscovery<LeafInfo>() {
     override val matchClasses: ConfigurableBlockMatcher get() = BlockConfig.leafBlocks
     override val modelTextures: List<ModelTextureList> get() = BlockConfig.leafModels.modelList
 
-    override fun processModel(state: BlockState, textures: List<String>, atlas: AtlasFuture) = defaultRegisterLeaf(Identifier(textures[0]), atlas)
+    override fun processModel(state: BlockState, textures: List<String>, atlas: AtlasFuture) =
+        defaultRegisterLeaf(ResourceLocation(textures[0]), atlas)
 
     fun init() {
         LeafRegistry.registries.add(this)
@@ -43,7 +44,7 @@ object AsyncLeafDiscovery : ConfigurableModelDiscovery<LeafInfo>() {
     }
 }
 
-fun HasLogger.defaultRegisterLeaf(sprite: Identifier, atlas: AtlasFuture): CompletableFuture<LeafInfo> {
+fun HasLogger.defaultRegisterLeaf(sprite: ResourceLocation, atlas: AtlasFuture): CompletableFuture<LeafInfo> {
     val leafType = LeafParticleRegistry.typeMappings.getType(sprite) ?: "default"
     val generated = GeneratedLeaf(sprite, leafType).register(BetterFoliage.asyncPack)
     val roundLeaf = atlas.sprite(generated)

src/main/kotlin/mods/betterfoliage/client/texture/Utils.kt

@@ -1,11 +1,10 @@
 @file:JvmName("Utils")
 package mods.betterfoliage.client.texture
 
-import mods.betterfoliage.client.resource.Identifier
-import mods.octarinecore.client.resource.Atlas
 import mods.octarinecore.client.resource.get
 import mods.octarinecore.client.resource.loadImage
 import net.minecraft.resources.IResourceManager
+import net.minecraft.util.ResourceLocation
 import java.io.IOException
 
 fun blendRGB(rgb1: Int, rgb2: Int, weight1: Int, weight2: Int): Int {
@@ -17,4 +16,4 @@ fun blendRGB(rgb1: Int, rgb2: Int, weight1: Int, weight2: Int): Int {
     return result
 }
 
-fun IResourceManager.loadSprite(id: Identifier) = this.get(id)?.loadImage() ?: throw IOException("Cannot load resource $id")
+fun IResourceManager.loadSprite(id: ResourceLocation) = this.get(id)?.loadImage() ?: throw IOException("Cannot load resource $id")

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

@@ -18,6 +18,8 @@ import net.minecraft.world.IBlockReader
 import net.minecraft.world.IEnviromentBlockReader
 import java.util.*
 
+typealias Sprite = TextureAtlasSprite
+
 // Java
 val String = ClassRef<String>("java.lang.String")
 val Map = ClassRef<Map<*, *>>("java.util.Map")
@@ -60,9 +62,12 @@ object CustomColors : ClassRef<Any>("net.optifine.CustomColors") {
 
 // Optifine shaders
 object SVertexBuilder : ClassRef<Any>("net.optifine.shaders.SVertexBuilder") {
-    val pushState = MethodRef(this, "pushEntity", void, BlockState, BlockPos, IEnvironmentBlockReader, BufferBuilder)
+    val pushState = MethodRef(this, "pushEntity", void, long)
-    val pushNum = MethodRef(this, "pushEntity", void, long)
+    val popState = MethodRef(this, "popEntity", void)
-    val pop = MethodRef(this, "popEntity", void)
+}
+
+object BlockAliases : ClassRef<Any>("net.optifine.shaders.BlockAliases") {
+    val getAliasBlockId = MethodRef(this, "getAliasBlockId", int, BlockState)
 }
 
 

src/main/kotlin/mods/octarinecore/client/render/BlockContext.kt

@@ -13,6 +13,7 @@ import net.minecraft.world.IBlockReader
 import net.minecraft.world.IEnviromentBlockReader
 import net.minecraft.world.World
 import net.minecraft.world.biome.Biome
+import net.minecraftforge.client.model.data.IModelData
 import java.util.*
 
 /**
@@ -64,8 +65,9 @@ data class RenderCtx(
     val dispatcher: BlockRendererDispatcher,
     val renderBuffer: BufferBuilder,
     val layer: BlockRenderLayer,
-    val random: Random
+    val random: Random,
+    val modelData: IModelData
 ) {
-    fun render(worldBlock: BlockCtx) = dispatcher.renderBlock(worldBlock.state, worldBlock.pos, worldBlock.world, renderBuffer, random, null)
+    fun render(worldBlock: BlockCtx) = dispatcher.renderBlock(worldBlock.state, worldBlock.pos, worldBlock.world, renderBuffer, random, modelData)
 }
 

src/main/kotlin/mods/octarinecore/client/resource/AsyncSpriteProviderManager.kt

@@ -1,13 +1,13 @@
 package mods.octarinecore.client.resource
 
-import mods.betterfoliage.client.resource.Identifier
+import mods.octarinecore.Sprite
-import mods.betterfoliage.client.resource.Sprite
 import mods.octarinecore.common.map
 import net.minecraft.client.renderer.texture.AtlasTexture
 import net.minecraft.client.renderer.texture.MissingTextureSprite
 import net.minecraft.profiler.IProfiler
 import net.minecraft.resources.IResourceManager
-import java.util.*
+import net.minecraft.util.ResourceLocation
+import java.util.Collections
 import java.util.concurrent.CompletableFuture
 
 /**
@@ -30,26 +30,34 @@ class AsnycSpriteProviderManager<SOURCE: Any>(val profilerSection: String) {
      * Needed in order to keep the actual [AtlasTexture.stitch] call in the original method, in case
      * other modders want to modify it too.
      */
-    class StitchWrapper(val idList: Iterable<Identifier>, val onComplete: (AtlasTexture.SheetData)->Unit) {
+    class StitchWrapper(val idList: Iterable<ResourceLocation>, val onComplete: (AtlasTexture.SheetData)->Unit) {
         fun complete(sheet: AtlasTexture.SheetData) = onComplete(sheet)
     }
 
+    var currentAtlas: AtlasFuture? = null
+    var currentPhases: List<StitchPhases> = emptyList()
+
     @Suppress("UNCHECKED_CAST")
-    fun prepare(sourceObj: Any, atlas: AtlasTexture, manager: IResourceManager, idList: Iterable<Identifier>, profiler: IProfiler): StitchWrapper {
+    fun prepare(sourceObj: Any, manager: IResourceManager, idList: Iterable<ResourceLocation>, profiler: IProfiler): Set<ResourceLocation> {
         profiler.startSection(profilerSection)
 
         val source = CompletableFuture<SOURCE>()
-        val atlasFuture = AtlasFuture(idList)
+        currentAtlas = AtlasFuture(idList)
 
-        val phases = providers.map { it.setup(manager, source, atlasFuture) }
+        currentPhases = providers.map { it.setup(manager, source, currentAtlas!!) }
         source.complete(sourceObj as SOURCE)
-        phases.forEach { it.discovery.get() }
+        currentPhases.forEach { it.discovery.get() }
 
-        return StitchWrapper(atlasFuture.idSet) { sheet ->
+        return currentAtlas!!.idSet
-            atlasFuture.complete(sheet)
+    }
-            phases.forEach { it.cleanup.get() }
+
-            profiler.endSection()
+    fun finish(sheetData: AtlasTexture.SheetData, profiler: IProfiler): AtlasTexture.SheetData {
-        }
+        currentAtlas!!.complete(sheetData)
+        currentPhases.forEach { it.cleanup.get() }
+        currentAtlas = null
+        currentPhases = emptyList()
+        profiler.endSection()
+        return sheetData
     }
 }
 
@@ -57,8 +65,8 @@ class AsnycSpriteProviderManager<SOURCE: Any>(val profilerSection: String) {
  * Provides a way for [AsyncSpriteProvider]s to register sprites to receive [CompletableFuture]s.
  * Tracks sprite ids that need to be stitched.
  */
-class AtlasFuture(initial: Iterable<Identifier>) {
+class AtlasFuture(initial: Iterable<ResourceLocation>) {
-    val idSet = Collections.synchronizedSet(mutableSetOf<Identifier>().apply { addAll(initial) })
+    val idSet = Collections.synchronizedSet(mutableSetOf<ResourceLocation>().apply { addAll(initial) })
     protected val sheet = CompletableFuture<AtlasTexture.SheetData>()
     protected val finished = CompletableFuture<Void>()
 
@@ -67,8 +75,8 @@ class AtlasFuture(initial: Iterable<Identifier>) {
         finished.complete(null)
     }
 
-    fun sprite(id: String) = sprite(Identifier(id))
+    fun sprite(id: String) = sprite(ResourceLocation(id))
-    fun sprite(id: Identifier): CompletableFuture<Sprite> {
+    fun sprite(id: ResourceLocation): CompletableFuture<Sprite> {
         idSet.add(id)
         return sheet.map { sheetData -> sheetData.sprites.find { it.name == id } ?: throw IllegalStateException("Atlas does not contain $id") }
     }

src/main/kotlin/mods/octarinecore/client/resource/CenteringTextureGenerator.kt

@@ -1,12 +1,12 @@
 package mods.octarinecore.client.resource
 
-import mods.betterfoliage.client.resource.Identifier
 import mods.betterfoliage.client.texture.loadSprite
 import net.minecraft.resources.IResourceManager
+import net.minecraft.util.ResourceLocation
 import java.awt.image.BufferedImage
 import java.lang.Math.max
 
-data class CenteredSprite(val sprite: Identifier, val atlas: Atlas = Atlas.BLOCKS, val aspectHeight: Int = 1, val aspectWidth: Int = 1) {
+data class CenteredSprite(val sprite: ResourceLocation, val atlas: Atlas = Atlas.BLOCKS, val aspectHeight: Int = 1, val aspectWidth: Int = 1) {
 
     fun register(pack: GeneratedBlockTexturePack) = pack.register(this, this::draw)
 

src/main/kotlin/mods/octarinecore/client/resource/ModelDiscovery.kt

@@ -1,20 +1,20 @@
 package mods.octarinecore.client.resource
 
 import com.google.common.base.Joiner
-import mods.betterfoliage.client.resource.ModelIdentifier
 import mods.octarinecore.HasLogger
 import mods.octarinecore.client.render.BlockCtx
 import mods.octarinecore.common.Int3
 import mods.octarinecore.common.config.IBlockMatcher
 import mods.octarinecore.common.config.ModelTextureList
 import mods.octarinecore.common.plus
-import mods.octarinecore.findFirst
 import mods.octarinecore.common.sinkAsync
+import mods.octarinecore.findFirst
 import net.minecraft.block.BlockState
 import net.minecraft.client.renderer.BlockModelShapes
 import net.minecraft.client.renderer.model.BlockModel
 import net.minecraft.client.renderer.model.IUnbakedModel
 import net.minecraft.client.renderer.model.ModelBakery
+import net.minecraft.client.renderer.model.ModelResourceLocation
 import net.minecraft.client.renderer.model.VariantList
 import net.minecraft.resources.IResourceManager
 import net.minecraft.util.ResourceLocation
@@ -40,7 +40,7 @@ abstract class ModelRenderRegistryRoot<T> : ModelRenderRegistry<T> {
 class ModelDiscoveryContext(
     bakery: ModelBakery,
     val state: BlockState,
-    val modelId: ModelIdentifier
+    val modelId: ModelResourceLocation
 ) {
     val models = bakery.unwrapVariants(bakery.getUnbakedModel(modelId) to modelId)
         .filter { it.second != bakery.getUnbakedModel(ModelBakery.MODEL_MISSING) }

src/main/kotlin/mods/octarinecore/client/resource/ResourceGeneration.kt

@@ -1,6 +1,5 @@
 package mods.octarinecore.client.resource
 
-import mods.betterfoliage.client.resource.Identifier
 import mods.octarinecore.HasLogger
 import mods.octarinecore.common.completedVoid
 import mods.octarinecore.common.map
@@ -9,10 +8,10 @@ import net.minecraft.client.resources.ClientResourcePackInfo
 import net.minecraft.resources.*
 import net.minecraft.resources.ResourcePackType.CLIENT_RESOURCES
 import net.minecraft.resources.data.IMetadataSectionSerializer
+import net.minecraft.util.ResourceLocation
 import net.minecraft.util.text.StringTextComponent
 import org.apache.logging.log4j.Logger
 import java.io.IOException
-import java.lang.IllegalStateException
 import java.util.*
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.ExecutionException
@@ -31,18 +30,18 @@ class GeneratedBlockTexturePack(val nameSpace: String, val packName: String, ove
     override fun getResourceNamespaces(type: ResourcePackType) = setOf(nameSpace)
     override fun <T : Any?> getMetadata(deserializer: IMetadataSectionSerializer<T>) = null
     override fun getRootResourceStream(id: String) = null
-    override fun getAllResourceLocations(type: ResourcePackType, path: String, maxDepth: Int, filter: Predicate<String>) = emptyList<Identifier>()
+    override fun getAllResourceLocations(type: ResourcePackType, path: String, maxDepth: Int, filter: Predicate<String>) = emptyList<ResourceLocation>()
     override fun close() {}
 
     protected var manager: CompletableFuture<IResourceManager>? = null
-    val identifiers = Collections.synchronizedMap(mutableMapOf<Any, Identifier>())
+    val identifiers = Collections.synchronizedMap(mutableMapOf<Any, ResourceLocation>())
-    val resources = Collections.synchronizedMap(mutableMapOf<Identifier, CompletableFuture<ByteArray>>())
+    val resources = Collections.synchronizedMap(mutableMapOf<ResourceLocation, CompletableFuture<ByteArray>>())
 
-    fun register(key: Any, func: (IResourceManager)->ByteArray): Identifier {
+    fun register(key: Any, func: (IResourceManager)->ByteArray): ResourceLocation {
         if (manager == null) throw IllegalStateException("Cannot register resources unless block textures are being reloaded")
         identifiers[key]?.let { return it }
 
-        val id = Identifier(nameSpace, UUID.randomUUID().toString())
+        val id = ResourceLocation(nameSpace, UUID.randomUUID().toString())
         val resource = manager!!.map { func(it) }
 
         identifiers[key] = id
@@ -51,12 +50,12 @@ class GeneratedBlockTexturePack(val nameSpace: String, val packName: String, ove
         return id
     }
 
-    override fun getResourceStream(type: ResourcePackType, id: Identifier) =
+    override fun getResourceStream(type: ResourcePackType, id: ResourceLocation) =
         if (type != CLIENT_RESOURCES) null else
             try { resources[id]!!.get().inputStream() }
             catch (e: ExecutionException) { (e.cause as? IOException)?.let { throw it } }   // rethrow wrapped IOException if present
 
-    override fun resourceExists(type: ResourcePackType, id: Identifier) =
+    override fun resourceExists(type: ResourcePackType, id: ResourceLocation) =
         type == CLIENT_RESOURCES && resources.containsKey(id)
 
     override fun setup(manager: IResourceManager, bakeryF: CompletableFuture<ModelBakery>, atlas: AtlasFuture): StitchPhases {

src/main/kotlin/mods/octarinecore/client/resource/ResourceHandler.kt

@@ -1,8 +1,7 @@
 package mods.octarinecore.client.resource
 
 import mods.betterfoliage.BetterFoliage
-import mods.betterfoliage.client.resource.Identifier
+import mods.octarinecore.Sprite
-import mods.betterfoliage.client.resource.Sprite
 import mods.octarinecore.client.render.Model
 import mods.octarinecore.common.Double3
 import mods.octarinecore.common.Int3
@@ -11,6 +10,7 @@ import mods.octarinecore.common.sink
 import mods.octarinecore.stripEnd
 import mods.octarinecore.stripStart
 import net.minecraft.resources.IResourceManager
+import net.minecraft.util.ResourceLocation
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.MathHelper
 import net.minecraft.world.IWorld
@@ -20,7 +20,7 @@ import net.minecraftforge.event.world.WorldEvent
 import net.minecraftforge.eventbus.api.IEventBus
 import net.minecraftforge.eventbus.api.SubscribeEvent
 import net.minecraftforge.fml.config.ModConfig
-import java.util.*
+import java.util.Random
 import java.util.concurrent.CompletableFuture
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
@@ -29,8 +29,8 @@ enum class Atlas(val basePath: String) {
     BLOCKS("textures"),
     PARTICLES("textures/particle");
 
-    fun wrap(resource: Identifier) = Identifier(resource.namespace, "$basePath/${resource.path}.png")
+    fun wrap(resource: ResourceLocation) = ResourceLocation(resource.namespace, "$basePath/${resource.path}.png")
-    fun unwrap(resource: Identifier) = resource.stripStart("$basePath/").stripEnd(".png")
+    fun unwrap(resource: ResourceLocation) = resource.stripStart("$basePath/").stripEnd(".png")
     fun matches(event: TextureStitchEvent) = event.map.basePath == basePath
 }
 
@@ -62,11 +62,11 @@ open class ResourceHandler(
     // ============================
     // Resource declarations
     // ============================
-    fun sprite(id: Identifier) = sprite { id }
+    fun sprite(id: ResourceLocation) = sprite { id }
-    fun sprite(idFunc: ()->Identifier) = AsyncSpriteDelegate(idFunc).apply { BetterFoliage.getSpriteManager(targetAtlas).providers.add(this) }
+    fun sprite(idFunc: ()->ResourceLocation) = AsyncSpriteDelegate(idFunc).apply { BetterFoliage.getSpriteManager(targetAtlas).providers.add(this) }
-    fun spriteSet(idFunc: (Int)->Identifier) = AsyncSpriteSet(idFunc).apply { BetterFoliage.getSpriteManager(targetAtlas).providers.add(this) }
+    fun spriteSet(idFunc: (Int)->ResourceLocation) = AsyncSpriteSet(targetAtlas, idFunc).apply { BetterFoliage.getSpriteManager(targetAtlas).providers.add(this) }
-    fun spriteSetTransformed(check: (Int)->Identifier, register: (Identifier)->Identifier) =
+    fun spriteSetTransformed(check: (Int)->ResourceLocation, register: (ResourceLocation)->ResourceLocation) =
-        AsyncSpriteSet(check, register).apply { BetterFoliage.getSpriteManager(targetAtlas).providers.add(this) }
+        AsyncSpriteSet(targetAtlas, check, register).apply { BetterFoliage.getSpriteManager(targetAtlas).providers.add(this) }
     fun model(init: Model.()->Unit) = ModelHolder(init).apply { resources.add(this) }
     fun modelSet(num: Int, init: Model.(Int)->Unit) = ModelSet(num, init).apply { resources.add(this) }
     fun vectorSet(num: Int, init: (Int)-> Double3) = VectorSet(num, init).apply { resources.add(this) }
@@ -88,7 +88,7 @@ open class ResourceHandler(
 // ============================
 // Resource container classes
 // ============================
-class AsyncSpriteDelegate(val idFunc: ()->Identifier) : ReadOnlyProperty<Any, Sprite>, AsyncSpriteProvider<Any> {
+class AsyncSpriteDelegate(val idFunc: ()->ResourceLocation) : ReadOnlyProperty<Any, Sprite>, AsyncSpriteProvider<Any> {
     protected lateinit var value: Sprite
     override fun getValue(thisRef: Any, property: KProperty<*>) = value
 
@@ -108,7 +108,7 @@ interface SpriteSet {
     operator fun get(idx: Int): Sprite
 }
 
-class AsyncSpriteSet(val idFunc: (Int)->Identifier, val transform: (Identifier)->Identifier = { it }) : AsyncSpriteProvider<Any> {
+class AsyncSpriteSet(val targetAtlas: Atlas = Atlas.BLOCKS, val idFunc: (Int)->ResourceLocation, val transform: (ResourceLocation)->ResourceLocation = { it }) : AsyncSpriteProvider<Any> {
     var num = 0
         protected set
     protected var sprites: List<Sprite> = emptyList()
@@ -119,7 +119,7 @@ class AsyncSpriteSet(val idFunc: (Int)->Identifier, val transform: (Identifier)-
         return StitchPhases(
             discovery = sourceF.sink {
                 list = (0 until 16).map { idFunc(it) }
-                    .filter { manager.hasResource( Atlas.BLOCKS.wrap(it)) }
+                    .filter { manager.hasResource( targetAtlas.wrap(it)) }
                     .map { transform(it) }
                     .map { atlas.sprite(it) }
             },

src/main/resources/assets/betterfoliage/cactus_default.cfg

@@ -1,2 +0,0 @@
-// Vanilla
-net.minecraft.block.CactusBlock

src/main/resources/assets/betterfoliage/netherrack_blocks_default.cfg

@@ -1,2 +0,0 @@
-// Vanilla
-net.minecraft.block.NetherrackBlock

src/main/resources/assets/betterfoliage/sand_default.cfg

@@ -1,5 +0,0 @@
-// Vanilla
-net.minecraft.block.BlockSand
-
-// TerraFirmaCraft
-com.bioxx.tfc.Blocks.Terrain.BlockSand

src/main/resources/mcmod.info

@@ -2,7 +2,7 @@
   "modid": "betterfoliage",
   "name": "Better Foliage",
   "version": "$version",
-  "mcversion": "$mcversion",
+  "mcversion": "$mcVersion",
   "description": "Leafier leaves and grassier grass",
   "authorList" : ["octarine-noise (code)", "Meringue (textures)"]
 }]