Add custom global textures

4 files changed, 282 insertions, 0 deletions

diff --git a/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomGlobalTextures.kt b/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomGlobalTextures.kt
new file mode 100644
index 0000000..2eb4ee1
--- /dev/null
+++ b/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomGlobalTextures.kt
@@ -0,0 +1,161 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Linnea Gräf <nea@nea.moe>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+@file:UseSerializers(IdentifierSerializer::class, CustomModelOverrideParser.FirmamentRootPredicateSerializer::class)
+
+package moe.nea.firmament.features.texturepack
+
+
+import java.util.concurrent.CompletableFuture
+import org.slf4j.LoggerFactory
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.UseSerializers
+import kotlin.jvm.optionals.getOrNull
+import net.minecraft.client.render.item.ItemModels
+import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.util.ModelIdentifier
+import net.minecraft.item.ItemStack
+import net.minecraft.resource.ResourceManager
+import net.minecraft.resource.SinglePreparationResourceReloader
+import net.minecraft.util.Identifier
+import net.minecraft.util.profiler.Profiler
+import moe.nea.firmament.Firmament
+import moe.nea.firmament.annotations.Subscribe
+import moe.nea.firmament.events.BakeExtraModelsEvent
+import moe.nea.firmament.events.EarlyResourceReloadEvent
+import moe.nea.firmament.events.FinalizeResourceManagerEvent
+import moe.nea.firmament.events.ScreenChangeEvent
+import moe.nea.firmament.events.subscription.SubscriptionOwner
+import moe.nea.firmament.features.FirmamentFeature
+import moe.nea.firmament.util.IdentifierSerializer
+import moe.nea.firmament.util.MC
+import moe.nea.firmament.util.runNull
+
+object CustomGlobalTextures : SinglePreparationResourceReloader<CustomGlobalTextures.CustomGuiTextureOverride>(),
+    SubscriptionOwner {
+    override val delegateFeature: FirmamentFeature
+        get() = CustomSkyBlockTextures
+
+    class CustomGuiTextureOverride(
+        val classes: List<ItemOverrideCollection>
+    )
+
+    @Serializable
+    data class GlobalItemOverride(
+        val screen: Identifier,
+        val model: Identifier,
+        val predicate: FirmamentModelPredicate,
+    )
+
+    @Serializable
+    data class ScreenFilter(
+        val title: StringMatcher,
+    )
+
+    data class ItemOverrideCollection(
+        val screenFilter: ScreenFilter,
+        val overrides: List<GlobalItemOverride>,
+    )
+
+    @Subscribe
+    fun onStart(event: FinalizeResourceManagerEvent) {
+        MC.resourceManager.registerReloader(this)
+    }
+
+    @Subscribe
+    fun onEarlyReload(event: EarlyResourceReloadEvent) {
+        preparationFuture = CompletableFuture
+            .supplyAsync(
+                {
+                    prepare(event.resourceManager)
+                }, event.preparationExecutor)
+    }
+
+    @Subscribe
+    fun onBakeModels(event: BakeExtraModelsEvent) {
+        for (guiClassOverride in preparationFuture.join().classes) {
+            for (override in guiClassOverride.overrides) {
+                event.addModel(ModelIdentifier(override.model, "inventory"))
+            }
+        }
+    }
+
+    @Volatile
+    var preparationFuture: CompletableFuture<CustomGuiTextureOverride> = CompletableFuture.completedFuture(
+        CustomGuiTextureOverride(listOf()))
+
+    override fun prepare(manager: ResourceManager?, profiler: Profiler?): CustomGuiTextureOverride {
+        return preparationFuture.join()
+    }
+
+    override fun apply(prepared: CustomGuiTextureOverride, manager: ResourceManager?, profiler: Profiler?) {
+        this.guiClassOverrides = prepared
+    }
+
+    val logger = LoggerFactory.getLogger(CustomGlobalTextures::class.java)
+    fun prepare(manager: ResourceManager): CustomGuiTextureOverride {
+        val overrideResources =
+            manager.findResources("overrides/item") { it.namespace == "firmskyblock" && it.path.endsWith(".json") }
+                .mapNotNull {
+                    Firmament.tryDecodeJsonFromStream<GlobalItemOverride>(it.value.inputStream).getOrElse { ex ->
+                        logger.error("Failed to load global item override at ${it.key}", ex)
+                        null
+                    }
+                }
+
+        val byGuiClass = overrideResources.groupBy { it.screen }
+        val guiClasses = byGuiClass.entries
+            .mapNotNull {
+                val key = it.key
+                val guiClassResource =
+                    manager.getResource(Identifier(key.namespace, "filters/screen/${key.path}.json"))
+                        .getOrNull()
+                        ?: return@mapNotNull runNull {
+                            logger.error("Failed to locate screen filter at $key")
+                        }
+                val screenFilter =
+                    Firmament.tryDecodeJsonFromStream<ScreenFilter>(guiClassResource.inputStream)
+                        .getOrElse { ex ->
+                            logger.error("Failed to load screen filter at $key", ex)
+                            return@mapNotNull null
+                        }
+                ItemOverrideCollection(screenFilter, it.value)
+            }
+        logger.info("Loaded ${overrideResources.size} global item overrides")
+        return CustomGuiTextureOverride(guiClasses)
+    }
+
+    var guiClassOverrides = CustomGuiTextureOverride(listOf())
+
+    var matchingOverrides: List<ItemOverrideCollection> = listOf()
+
+    @Subscribe
+    fun onOpenGui(event: ScreenChangeEvent) {
+        val newTitle = event.new?.title
+        matchingOverrides =
+            if (newTitle == null) listOf()
+            else guiClassOverrides.classes.filter { it.screenFilter.title.matches(newTitle) }
+    }
+
+    @JvmStatic
+    fun replaceGlobalModel(
+        models: ItemModels,
+        stack: ItemStack,
+        cir: CallbackInfoReturnable<BakedModel>
+    ) {
+        for (guiClassOverride in matchingOverrides) {
+            for (override in guiClassOverride.overrides) {
+                if (override.predicate.test(stack)) {
+                    cir.returnValue = models.modelManager.getModel(ModelIdentifier(override.model, "inventory"))
+                    return
+                }
+            }
+        }
+    }
+
+
+}
diff --git a/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomModelOverrideParser.kt b/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomModelOverrideParser.kt
index ad1f436..d512dec 100644
--- a/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomModelOverrideParser.kt
+++ b/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomModelOverrideParser.kt
@@ -7,9 +7,27 @@
 package moe.nea.firmament.features.texturepack
 
 import com.google.gson.JsonObject
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
 import net.minecraft.util.Identifier
 
 object CustomModelOverrideParser {
+    object FirmamentRootPredicateSerializer : KSerializer<FirmamentModelPredicate> {
+        val delegateSerializer = kotlinx.serialization.json.JsonObject.serializer()
+        override val descriptor: SerialDescriptor
+            get() = SerialDescriptor("FirmamentModelRootPredicate", delegateSerializer.descriptor)
+
+        override fun deserialize(decoder: Decoder): FirmamentModelPredicate {
+            val json = decoder.decodeSerializableValue(delegateSerializer).intoGson() as JsonObject
+            return AndPredicate(parsePredicates(json).toTypedArray())
+        }
+
+        override fun serialize(encoder: Encoder, value: FirmamentModelPredicate) {
+            TODO("Cannot serialize firmament predicates")
+        }
+    }
 
     val predicateParsers = mutableMapOf<Identifier, FirmamentModelPredicateParser>()
 
diff --git a/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomSkyBlockTextures.kt b/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomSkyBlockTextures.kt
index e66a24a..7c2d5ab 100644
--- a/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomSkyBlockTextures.kt
+++ b/src/main/kotlin/moe/nea/firmament/features/texturepack/CustomSkyBlockTextures.kt
@@ -17,6 +17,7 @@ import net.minecraft.client.util.ModelIdentifier
 import net.minecraft.component.type.ProfileComponent
 import net.minecraft.util.Identifier
 import moe.nea.firmament.annotations.Subscribe
+import moe.nea.firmament.events.BakeExtraModelsEvent
 import moe.nea.firmament.events.CustomItemModelEvent
 import moe.nea.firmament.events.TickEvent
 import moe.nea.firmament.features.FirmamentFeature
@@ -48,6 +49,23 @@ object CustomSkyBlockTextures : FirmamentFeature {
     }
 
     @Subscribe
+    fun bakeCustomFirmModels(event: BakeExtraModelsEvent) {
+        val resources =
+            MinecraftClient.getInstance().resourceManager.findResources("models/item"
+            ) { it: Identifier ->
+                "firmskyblock" == it.namespace && it.path
+                    .endsWith(".json")
+            }
+        for (identifier in resources.keys) {
+            val modelId = ModelIdentifier("firmskyblock",
+                                          identifier.path.substring("models/item/".length,
+                                                                    identifier.path.length - ".json".length),
+                                          "inventory")
+            event.addModel(modelId)
+        }
+    }
+
+    @Subscribe
     fun onCustomModelId(it: CustomItemModelEvent) {
         if (!TConfig.enabled) return
         val id = it.itemStack.skyBlockId ?: return
diff --git a/src/main/kotlin/moe/nea/firmament/features/texturepack/StringMatcher.kt b/src/main/kotlin/moe/nea/firmament/features/texturepack/StringMatcher.kt
index 8c1ccbc..1c2675f 100644
--- a/src/main/kotlin/moe/nea/firmament/features/texturepack/StringMatcher.kt
+++ b/src/main/kotlin/moe/nea/firmament/features/texturepack/StringMatcher.kt
@@ -6,15 +6,24 @@
 
 package moe.nea.firmament.features.texturepack
 
+import com.google.gson.JsonArray
 import com.google.gson.JsonElement
+import com.google.gson.JsonNull
 import com.google.gson.JsonObject
 import com.google.gson.JsonPrimitive
+import com.google.gson.internal.LazilyParsedNumber
 import java.util.function.Predicate
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
 import net.minecraft.nbt.NbtString
 import net.minecraft.text.Text
 import moe.nea.firmament.util.MC
 import moe.nea.firmament.util.removeColorCodes
 
+@Serializable(with = StringMatcher.Serializer::class)
 interface StringMatcher {
     fun matches(string: String): Boolean
     fun matches(text: Text): Boolean {
@@ -46,7 +55,28 @@ interface StringMatcher {
         }
     }
 
+    object Serializer : KSerializer<StringMatcher> {
+        val delegateSerializer = kotlinx.serialization.json.JsonElement.serializer()
+        override val descriptor: SerialDescriptor
+            get() = SerialDescriptor("StringMatcher", delegateSerializer.descriptor)
+
+        override fun deserialize(decoder: Decoder): StringMatcher {
+            val delegate = decoder.decodeSerializableValue(delegateSerializer)
+            val gsonDelegate = delegate.intoGson()
+            return parse(gsonDelegate)
+        }
+
+        override fun serialize(encoder: Encoder, value: StringMatcher) {
+            encoder.encodeSerializableValue(delegateSerializer, Companion.serialize(value).intoKotlinJson())
+        }
+
+    }
+
     companion object {
+        fun serialize(stringMatcher: StringMatcher):JsonElement {
+            TODO("Cannot serialize string matchers rn")
+        }
+
         fun parse(jsonElement: JsonElement): StringMatcher {
             if (jsonElement is JsonPrimitive) {
                 return Equals(jsonElement.asString, true)
@@ -69,3 +99,58 @@ interface StringMatcher {
         }
     }
 }
+
+fun JsonElement.intoKotlinJson(): kotlinx.serialization.json.JsonElement {
+    when (this) {
+        is JsonNull -> return kotlinx.serialization.json.JsonNull
+        is JsonObject -> {
+            return kotlinx.serialization.json.JsonObject(this.entrySet()
+                                                             .associate { it.key to it.value.intoKotlinJson() })
+        }
+
+        is JsonArray -> {
+            return kotlinx.serialization.json.JsonArray(this.map { it.intoKotlinJson() })
+        }
+
+        is JsonPrimitive -> {
+            if (this.isString)
+                return kotlinx.serialization.json.JsonPrimitive(this.asString)
+            if (this.isBoolean)
+                return kotlinx.serialization.json.JsonPrimitive(this.asBoolean)
+            return kotlinx.serialization.json.JsonPrimitive(this.asNumber)
+        }
+
+        else -> error("Unknown json variant $this")
+    }
+}
+
+fun kotlinx.serialization.json.JsonElement.intoGson(): JsonElement {
+    when (this) {
+        is kotlinx.serialization.json.JsonNull -> return JsonNull.INSTANCE
+        is kotlinx.serialization.json.JsonPrimitive -> {
+            if (this.isString)
+                return JsonPrimitive(this.content)
+            if (this.content == "true")
+                return JsonPrimitive(true)
+            if (this.content == "false")
+                return JsonPrimitive(false)
+            return JsonPrimitive(LazilyParsedNumber(this.content))
+        }
+
+        is kotlinx.serialization.json.JsonObject -> {
+            val obj = JsonObject()
+            for ((k, v) in this) {
+                obj.add(k, v.intoGson())
+            }
+            return obj
+        }
+
+        is kotlinx.serialization.json.JsonArray -> {
+            val arr = JsonArray()
+            for (v in this) {
+                arr.add(v.intoGson())
+            }
+            return arr
+        }
+    }
+}