Updated to 1.21.5

build.gradle

@@ -1,5 +1,5 @@
 plugins {
-    id 'fabric-loom' version '1.7.+'
+    id 'fabric-loom' version '1.10.+'
     id 'io.github.juuxel.loom-quiltflower' version '1.8.0'
     id 'maven-publish'
 }
@@ -15,6 +15,10 @@ dependencies {
     modImplementation fabricApi.module("fabric-resource-loader-v0", project.fabric_version)
 }
 
+loom {
+    accessWidenerPath = file("src/main/resources/shaderreload.accesswidener")
+}
+
 processResources {
     inputs.property "version", project.version
 

gradle.properties

@@ -2,12 +2,12 @@ org.gradle.jvmargs=-Xmx1G
 
 # Fabric Properties
 # https://modmuss50.me/fabric.html
-minecraft_version=1.21
-yarn_mappings=1.21+build.7
-loader_version=0.15.11
-fabric_version=0.100.4+1.21
+minecraft_version=1.21.5
+yarn_mappings=1.21.5+build.1
+loader_version=0.16.14
+fabric_version=0.121.0+1.21.5
 
 # Mod Properties
-mod_version=1.12
+mod_version=1.13
 maven_group=suso
 archives_base_name=shader-reload

gradle/wrapper/gradle-wrapper.properties

@@ -1 +1 @@
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip

src/main/java/suso/shaderreload/ShaderReload.java

@@ -1,24 +1,22 @@
 package suso.shaderreload;
 
-import com.google.gson.JsonSyntaxException;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.gl.Framebuffer;
-import net.minecraft.client.gl.PostEffectProcessor;
-import net.minecraft.client.gl.ShaderProgram;
-import net.minecraft.client.render.VertexFormat;
-import net.minecraft.client.texture.TextureManager;
+import net.minecraft.client.gl.ShaderLoader;
 import net.minecraft.resource.*;
 import net.minecraft.text.Text;
 import net.minecraft.util.*;
+import net.minecraft.util.profiler.DummyProfiler;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.Nullable;
 import org.lwjgl.glfw.GLFW;
 import suso.shaderreload.mixin.KeyboardInvoker;
+import suso.shaderreload.mixin.ShaderLoaderAccessor;
 
-import java.io.IOException;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
@@ -30,10 +28,9 @@ public class ShaderReload implements ClientModInitializer {
     public static final int GLFW_KEY = GLFW.GLFW_KEY_R;
     public static final Logger LOGGER = LogManager.getLogger("Shader Reload");
 
-    private static final StopException STOP = new StopException();
     private static boolean reloading = false;
-    private static boolean stopReloading = false;
-    private static ResourceReloader shaderLoader;
+    public static boolean isReloadingBuiltin = false;
+    private static @Nullable ShaderLoader.Definitions vanillaOnlyDefinitions = null;
 
     @Override
     public void onInitializeClient() {
@@ -44,8 +41,8 @@ public static void reloadShaders() {
         if (reloading) return;
         var client = MinecraftClient.getInstance();
         reloading = true;
-        stopReloading = false;
-        SimpleResourceReload.start(client.getResourceManager(), List.of(shaderLoader, client.worldRenderer),
+        isReloadingBuiltin = false;
+        SimpleResourceReload.start(client.getResourceManager(), List.of(client.getShaderLoader(), client.worldRenderer),
                         Util.getMainWorkerExecutor(), client, CompletableFuture.completedFuture(Unit.INSTANCE), false)
                 .whenComplete()
                 .whenComplete((result, throwable) -> {
@@ -57,79 +54,51 @@ public static void reloadShaders() {
                     if (throwable instanceof CompletionException ex && ex.getCause() != null) {
                         throwable = ex.getCause();
                     }
-                    if (!(throwable instanceof StopException)) {
-                        ((KeyboardInvoker) client.keyboard).invokeDebugError("debug.reload_shaders.unknown_error");
-                        throwable.printStackTrace();
-                    }
+                    ((KeyboardInvoker) client.keyboard).invokeDebugError("debug.reload_shaders.unknown_error");
+                    throwable.printStackTrace();
                 });
     }
 
-    // Print a shader exception in chat.
-    private static void printShaderException(Exception exception, boolean builtin) {
+    public static void printShaderLogError(String errorMessage, Object... arguments) {
         var client = MinecraftClient.getInstance();
-        var throwable = (Throwable) exception;
-        while (!(throwable instanceof InvalidHierarchicalFileException)) {
-            var cause = throwable.getCause();
-            if (cause != null) throwable = cause;
-            else {
-                var translationKey = "debug.reload_shaders.unknown_error" + (builtin ? ".builtin" : "");
-                ((KeyboardInvoker) client.keyboard).invokeDebugError(translationKey);
-                throwable.printStackTrace();
-                return;
-            }
-        }
-        var translationKey = "debug.reload_shaders.error" + (builtin ? ".builtin" : "");
+        var translationKey = "debug.reload_shaders.error" + (isReloadingBuiltin ? ".builtin" : "");
         ((KeyboardInvoker) client.keyboard).invokeDebugError(translationKey);
-        client.inGameHud.getChatHud().addMessage(Text.literal(throwable.getMessage()).formatted(Formatting.GRAY));
-    }
-
-    // Try loading a core shader; if it fails, stop shader reloading or try loading a built-in core shader.
-    public static ShaderProgram onLoadShaders$new(ResourceFactory factory, String name, VertexFormat format) throws IOException {
-        try {
-            return new ShaderProgram(factory, name, format);
-        } catch (IOException e) {
-            printShaderException(e, false);
-            if (reloading) throw STOP;
-        }
-        try {
-            var defaultPack = MinecraftClient.getInstance().getDefaultResourcePack();
-            return new ShaderProgram(defaultPack.getFactory(), name, format);
-        } catch (IOException e) {
-            printShaderException(e, true);
-            throw e;
-        }
+        var logText = Text.translatable(
+                errorMessage.replace("{}", "%s"),
+                Arrays.stream(arguments)
+                        .map(String::valueOf)
+                        .map(ShaderReload::removeEx)
+                        .toArray()
+        ).formatted(Formatting.GRAY);
+        client.inGameHud.getChatHud().addMessage(logText);
     }
 
-    // Try loading a shader effect; if it fails, request stopping and try loading a built-in shader effect.
-    @SuppressWarnings("resource")
-    public static PostEffectProcessor onLoadShader$new(TextureManager textureManager, ResourceFactory resourceFactory,
-                                                       Framebuffer framebuffer, Identifier location) throws IOException {
-        try {
-            return new PostEffectProcessor(textureManager, resourceFactory, framebuffer, location);
-        } catch (IOException | JsonSyntaxException e) {
-            printShaderException(e, false);
-            stopReloading = true;
-        }
-        try {
-            var defaultPack = MinecraftClient.getInstance().getDefaultResourcePack();
-            resourceFactory = new LifecycledResourceManagerImpl(CLIENT_RESOURCES, List.of(defaultPack));
-            return new PostEffectProcessor(textureManager, resourceFactory, framebuffer, location);
-        } catch (IOException | JsonSyntaxException e) {
-            printShaderException(e, true);
-            throw e;
+    public static String removeEx(String msg) {
+        msg = msg.substring(msg.indexOf(": ") + 2);
+        while(true) {
+            final var colonIndex = msg.indexOf(": ");
+            if(colonIndex == -1)
+                break;
+            if(msg.substring(0, colonIndex).contains(" ")) {
+                // Definitely not an error name, so it shouldn't be removed
+                break;
+            }
+            msg = msg.substring(colonIndex + 2);
         }
+        return msg;
     }
 
-    // Stop shader reloading if it's requested.
-    public static void onLoadShader$end() {
-        if (reloading && stopReloading) throw STOP;
+    public static ResourceManager getDefaultResourceManager() {
+        var defaultPack = MinecraftClient.getInstance().getDefaultResourcePack();
+        return new LifecycledResourceManagerImpl(CLIENT_RESOURCES, List.of(defaultPack));
     }
 
-    public static void setShaderLoader(ResourceReloader value) {
-        shaderLoader = value;
-    }
+    public static ShaderLoader.Definitions getVanillaOnlyDefinitions() {
+        if(vanillaOnlyDefinitions != null)
+            return vanillaOnlyDefinitions;
 
-    private static class StopException extends RuntimeException {
-        private StopException() {}
+        vanillaOnlyDefinitions = ((ShaderLoaderAccessor)MinecraftClient.getInstance().getShaderLoader())
+                .callPrepare(getDefaultResourceManager(), DummyProfiler.INSTANCE);
+        return vanillaOnlyDefinitions;
     }
 }

src/main/java/suso/shaderreload/mixin/GlBackendMixin.java

@@ -0,0 +1,84 @@
+package suso.shaderreload.mixin;
+
+import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.mojang.blaze3d.pipeline.RenderPipeline;
+import com.mojang.blaze3d.shaders.ShaderType;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gl.CompiledShaderPipeline;
+import net.minecraft.client.gl.GlBackend;
+import net.minecraft.client.gl.ShaderLoader;
+import net.minecraft.util.Identifier;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.ModifyArg;
+import suso.shaderreload.ShaderReload;
+
+import java.util.Map;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+@Mixin(GlBackend.class)
+public class GlBackendMixin {
+    @ModifyArg(
+            method = {
+                    "compileShader(Lnet/minecraft/client/gl/GlBackend$ShaderKey;Ljava/util/function/BiFunction;)Lnet/minecraft/client/gl/CompiledShader;",
+                    "compileRenderPipeline"
+            },
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lorg/slf4j/Logger;error(Ljava/lang/String;[Ljava/lang/Object;)V",
+                    remap = false
+            )
+    )
+    private String shader_reload$printPipelineShaderErrors(String logMessage, Object... args) {
+        ShaderReload.printShaderLogError(logMessage, args);
+        return logMessage;
+    }
+
+    @ModifyArg(
+            method = {
+                    "compileShader(Lnet/minecraft/client/gl/GlBackend$ShaderKey;Ljava/util/function/BiFunction;)Lnet/minecraft/client/gl/CompiledShader;",
+                    "compileRenderPipeline"
+            },
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lorg/slf4j/Logger;error(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V",
+                    remap = false
+            )
+    )
+    private String shader_reload$printPipelineShaderErrors(String logMessage, Object arg1, Object arg2) {
+        ShaderReload.printShaderLogError(logMessage, arg1, arg2);
+        return logMessage;
+    }
+
+    @WrapMethod(method = "compileRenderPipeline")
+    private CompiledShaderPipeline shader_reload$retryFailedShadersWithDefault(RenderPipeline pipeline, BiFunction<Identifier, ShaderType, String> sourceRetriever, Operation<CompiledShaderPipeline> op) {
+        ShaderReload.isReloadingBuiltin = false;
+        var compiled = op.call(pipeline, sourceRetriever);
+        if(compiled.isValid())
+            return compiled;
+
+        ShaderReload.isReloadingBuiltin = true;
+        var vanillyOnlyDefinitions = ShaderReload.getVanillaOnlyDefinitions();
+        return op.call(
+                pipeline,
+                (BiFunction<Identifier, ShaderType, String>)(id, type) ->
+                        vanillyOnlyDefinitions.shaderSources().get(new ShaderLoader.ShaderSourceKey(id, type))
+        );
+    }
+
+    @WrapOperation(
+            method = "compileShader(Lnet/minecraft/util/Identifier;Lcom/mojang/blaze3d/shaders/ShaderType;Lnet/minecraft/client/gl/Defines;Ljava/util/function/BiFunction;)Lnet/minecraft/client/gl/CompiledShader;",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Ljava/util/Map;computeIfAbsent(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;"
+            )
+    )
+    private <K, V> Object shader_reload$skipCacheWhenReloadingBuiltin(Map<K, V> instance, K key, Function<? super K, ? extends V> mapping_function, Operation<V> op) {
+        if(ShaderReload.isReloadingBuiltin)
+            return mapping_function.apply(key);
+        return op.call(instance, key, mapping_function);
+    }
+}