Added mechanism to allow resource packs with modified core shaders to declare compatible features

Closes #323

Author: RaphiMC

common/src/main/java/net/raphimc/immediatelyfast/feature/core/ImmediatelyFastResourcePackMetadata.java

@@ -0,0 +1,37 @@
+/*
+ * This file is part of ImmediatelyFast - https://github.com/RaphiMC/ImmediatelyFast
+ * Copyright (C) 2023-2025 RK_01/RaphiMC and contributors
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package net.raphimc.immediatelyfast.feature.core;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.resource.metadata.ResourceMetadataSerializer;
+
+import java.util.Collections;
+import java.util.List;
+
+public record ImmediatelyFastResourcePackMetadata(List<String> compatibleFeatures) {
+
+    public static final ImmediatelyFastResourcePackMetadata DEFAULT = new ImmediatelyFastResourcePackMetadata(Collections.emptyList());
+    public static final Codec<ImmediatelyFastResourcePackMetadata> CODEC = RecordCodecBuilder.create(instance ->
+            instance.group(
+                    Codec.STRING.listOf().fieldOf("compatible_features").forGetter(ImmediatelyFastResourcePackMetadata::compatibleFeatures)
+            ).apply(instance, ImmediatelyFastResourcePackMetadata::new)
+    );
+    public static final ResourceMetadataSerializer<ImmediatelyFastResourcePackMetadata> SERIALIZER = ResourceMetadataSerializer.fromCodec("immediatelyfast", CODEC);
+
+}

common/src/main/java/net/raphimc/immediatelyfast/injection/mixins/core/compat/MixinGameRenderer.java

@@ -24,9 +24,11 @@
 import net.minecraft.client.render.GameRenderer;
 import net.minecraft.resource.Resource;
 import net.minecraft.resource.ResourceFactory;
+import net.minecraft.resource.ResourcePack;
 import net.minecraft.util.Identifier;
 import net.raphimc.immediatelyfast.ImmediatelyFast;
 import net.raphimc.immediatelyfast.compat.CoreShaderBlacklist;
+import net.raphimc.immediatelyfast.feature.core.ImmediatelyFastResourcePackMetadata;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -35,55 +37,70 @@
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.io.IOException;
+import java.util.*;
 
 @Mixin(GameRenderer.class)
 public abstract class MixinGameRenderer {
 
-    @Shadow
-    @Final
-    MinecraftClient client;
-
     @Shadow
     @Final
     private Map<String, ShaderProgram> programs;
 
     @Inject(method = "loadPrograms", at = @At("RETURN"))
     private void checkForCoreShaderModifications(ResourceFactory factory, CallbackInfo ci) {
-        boolean modified = false;
-        for (Map.Entry<String, ShaderProgram> shaderProgramEntry : this.programs.entrySet()) {
-            if (!CoreShaderBlacklist.isBlacklisted(shaderProgramEntry.getKey())) continue;
+        if (ImmediatelyFast.config.experimental_disable_resource_pack_conflict_handling) {
+            return;
+        }
 
-            final Identifier vertexShaderIdentifier = new Identifier("shaders/core/" + shaderProgramEntry.getValue().getVertexShader().getName() + ".vsh");
-            final Resource vertexShaderResource = factory.getResource(vertexShaderIdentifier).orElse(null);
-            if (vertexShaderResource != null && !vertexShaderResource.getPack().equals(this.client.getDefaultResourcePack())) {
-                modified = true;
-                break;
+        ResourcePack resourcePackWhichBreaksFontAtlasResizing = null;
+        ResourcePack resourcePackWhichBreaksHudBatching = null;
+        try {
+            final Set<ResourcePack> breakingResourcePacks = new HashSet<>();
+            for (Map.Entry<String, ShaderProgram> shaderProgramEntry : this.programs.entrySet()) {
+                if (!CoreShaderBlacklist.isBlacklisted(shaderProgramEntry.getKey())) continue;
+
+                final Identifier vertexShaderIdentifier = new Identifier("shaders/core/" + shaderProgramEntry.getValue().getVertexShader().getName() + ".vsh");
+                final ResourcePack vertexShaderResourcePack = factory.getResource(vertexShaderIdentifier).map(Resource::getPack).orElse(null);
+                if (vertexShaderResourcePack != null && !vertexShaderResourcePack.equals(MinecraftClient.getInstance().getDefaultResourcePack())) {
+                    breakingResourcePacks.add(vertexShaderResourcePack);
+                }
+                final Identifier fragmentShaderIdentifier = new Identifier("shaders/core/" + shaderProgramEntry.getValue().getFragmentShader().getName() + ".fsh");
+                final ResourcePack fragmentShaderResourcePack = factory.getResource(fragmentShaderIdentifier).map(Resource::getPack).orElse(null);
+                if (fragmentShaderResourcePack != null && !fragmentShaderResourcePack.equals(MinecraftClient.getInstance().getDefaultResourcePack())) {
+                    breakingResourcePacks.add(fragmentShaderResourcePack);
+                }
             }
-            final Identifier fragmentShaderIdentifier = new Identifier("shaders/core/" + shaderProgramEntry.getValue().getFragmentShader().getName() + ".fsh");
-            final Resource fragmentShaderResource = factory.getResource(fragmentShaderIdentifier).orElse(null);
-            if (fragmentShaderResource != null && !fragmentShaderResource.getPack().equals(this.client.getDefaultResourcePack())) {
-                modified = true;
-                break;
+            for (ResourcePack resourcePack : breakingResourcePacks) {
+                ImmediatelyFastResourcePackMetadata metadata = resourcePack.parseMetadata(ImmediatelyFastResourcePackMetadata.SERIALIZER);
+                if (metadata == null) {
+                    metadata = ImmediatelyFastResourcePackMetadata.DEFAULT;
+                }
+                if (!metadata.compatibleFeatures().contains("font_atlas_resizing")) {
+                    resourcePackWhichBreaksFontAtlasResizing = resourcePack;
+                }
+                if (!metadata.compatibleFeatures().contains("hud_batching")) {
+                    resourcePackWhichBreaksHudBatching = resourcePack;
+                }
             }
+        } catch (IOException e) {
+            ImmediatelyFast.LOGGER.error("Failed to check for core shader modifications", e);
         }
 
-        if (modified && !ImmediatelyFast.config.experimental_disable_resource_pack_conflict_handling) {
-            ImmediatelyFast.LOGGER.warn("Core shader modifications detected. Temporarily disabling some parts of ImmediatelyFast.");
-            if (ImmediatelyFast.runtimeConfig.font_atlas_resizing) {
-                ImmediatelyFast.runtimeConfig.font_atlas_resizing = false;
-                this.immediatelyFast$reloadFontStorages();
-            }
-
-            ImmediatelyFast.runtimeConfig.hud_batching = false;
+        if (ImmediatelyFast.runtimeConfig.font_atlas_resizing && resourcePackWhichBreaksFontAtlasResizing != null) {
+            ImmediatelyFast.LOGGER.warn("Resource pack " + resourcePackWhichBreaksFontAtlasResizing.getName() + " is not compatible with font atlas resizing. Temporarily disabling font atlas resizing.");
+            ImmediatelyFast.runtimeConfig.font_atlas_resizing = false;
+            this.immediatelyFast$reloadFontStorages();
         } else {
             if (!ImmediatelyFast.runtimeConfig.font_atlas_resizing && ImmediatelyFast.config.font_atlas_resizing) {
                 ImmediatelyFast.runtimeConfig.font_atlas_resizing = true;
                 this.immediatelyFast$reloadFontStorages();
             }
-
+        }
+        if (ImmediatelyFast.runtimeConfig.hud_batching && resourcePackWhichBreaksHudBatching != null) {
+            ImmediatelyFast.LOGGER.warn("Resource pack " + resourcePackWhichBreaksHudBatching.getName() + " is not compatible with HUD batching. Temporarily disabling HUD batching.");
+            ImmediatelyFast.runtimeConfig.hud_batching = false;
+        } else {
             ImmediatelyFast.runtimeConfig.hud_batching = ImmediatelyFast.config.hud_batching;
         }
     }