it works...?

build.gradle.kts

@@ -11,7 +11,7 @@ val FABRIC_API_VERSION by extra { "0.102.0+1.21.1" }
 val SODIUM_FILE by extra { "sodium-LOADER-0.6.0-beta.2+mc1.21.1.jar" }
 
 // https://semver.org/
-val MOD_VERSION by extra { "1.8.0-beta.4" }
+val MOD_VERSION by extra { "1.8.0+hdr-horror-beta.4" }
 
 allprojects {
     apply(plugin = "java")

common/src/main/java/net/irisshaders/iris/GLFWAccess.java

@@ -0,0 +1,36 @@
+package net.irisshaders.iris;
+
+import net.minecraft.client.Minecraft;
+import org.lwjgl.glfw.GLFW;
+import org.lwjgl.system.JNI;
+import org.lwjgl.system.SharedLibrary;
+
+import java.lang.reflect.Field;
+
+public class GLFWAccess {
+	private static SharedLibrary lib;
+
+	static {
+		Class<?> clas = GLFW.class;
+
+		try {
+			Field field = clas.getDeclaredField("GLFW");
+			field.setAccessible(true);
+			lib = (SharedLibrary) field.get(null);
+		} catch (NoSuchFieldException | IllegalAccessException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	public static GLFWHDRConfig conf;
+
+	private static boolean done;
+
+	public static void tryHDRConf() {
+		if (done) return;
+		done = true;
+		long addr = JNI.invokePP(Minecraft.getInstance().getWindow().getWindow(), lib.getFunctionAddress("glfwGetHDRConfig"));
+		conf = GLFWHDRConfig.create(addr);
+		System.out.println("Testing red primary X: " + conf.getPrimaryRedX());
+	}
+}

common/src/main/java/net/irisshaders/iris/GLFWHDRConfig.java

@@ -0,0 +1,148 @@
+package net.irisshaders.iris;
+
+import org.jetbrains.annotations.NotNull;
+import org.lwjgl.system.MemoryUtil;
+import org.lwjgl.system.Struct;
+import org.lwjgl.system.StructBuffer;
+
+import java.nio.ByteBuffer;
+
+import static org.lwjgl.system.MemoryUtil.memGetFloat;
+
+public class GLFWHDRConfig extends Struct<GLFWHDRConfig> {
+	public static final int SIZEOF, ALIGNOF;
+
+	private static final int OFFSET_TRANSFER_FUNCTION;
+	private static final int OFFSET_PRIMARY_RED_X;
+	private static final int OFFSET_PRIMARY_RED_Y;
+	private static final int OFFSET_PRIMARY_GREEN_X;
+	private static final int OFFSET_PRIMARY_GREEN_Y;
+	private static final int OFFSET_PRIMARY_BLUE_X;
+	private static final int OFFSET_PRIMARY_BLUE_Y;
+	private static final int OFFSET_WHITE_POINT_X;
+	private static final int OFFSET_WHITE_POINT_Y;
+	private static final int OFFSET_MAX_LUMINANCE;
+	private static final int OFFSET_MIN_LUMINANCE;
+	private static final int OFFSET_MAX_FRAME_LUMINANCE;
+
+	static {
+		var layout = __struct(
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES),
+			__member(Float.BYTES)
+		);
+
+		SIZEOF = layout.getSize();
+		ALIGNOF = layout.getAlignment();
+
+		OFFSET_TRANSFER_FUNCTION = layout.offsetof(0);
+		OFFSET_PRIMARY_RED_X = layout.offsetof(1);
+		OFFSET_PRIMARY_RED_Y = layout.offsetof(2);
+		OFFSET_PRIMARY_GREEN_X = layout.offsetof(3);
+		OFFSET_PRIMARY_GREEN_Y = layout.offsetof(4);
+		OFFSET_PRIMARY_BLUE_X = layout.offsetof(5);
+		OFFSET_PRIMARY_BLUE_Y = layout.offsetof(6);
+		OFFSET_WHITE_POINT_X = layout.offsetof(7);
+		OFFSET_WHITE_POINT_Y = layout.offsetof(8);
+		OFFSET_MAX_LUMINANCE = layout.offsetof(9);
+		OFFSET_MIN_LUMINANCE = layout.offsetof(10);
+		OFFSET_MAX_FRAME_LUMINANCE = layout.offsetof(11);
+	}
+
+	GLFWHDRConfig(long address, ByteBuffer container) {
+		super(address, container);
+	}
+
+	@Override
+	protected GLFWHDRConfig create(long address, ByteBuffer container) {
+		return new GLFWHDRConfig(address, container);
+	}
+
+	public static GLFWHDRConfig create(long address) {
+		return new GLFWHDRConfig(address, null);
+	}
+
+	public static Buffer calloc(int count) {
+		return new Buffer(MemoryUtil.nmemCalloc(count, SIZEOF), count);
+	}
+
+	public float getTransferFunction() {
+		return memGetFloat(this.address + OFFSET_TRANSFER_FUNCTION);
+	}
+
+	public float getPrimaryRedX() {
+		return memGetFloat(this.address + OFFSET_PRIMARY_RED_X);
+	}
+
+	public float getPrimaryRedY() {
+		return memGetFloat(this.address + OFFSET_PRIMARY_RED_Y);
+	}
+
+	public float getPrimaryGreenX() {
+		return memGetFloat(this.address + OFFSET_PRIMARY_GREEN_X);
+	}
+
+	public float getPrimaryGreenY() {
+		return memGetFloat(this.address + OFFSET_PRIMARY_GREEN_Y);
+	}
+
+	public float getPrimaryBlueX() {
+		return memGetFloat(this.address + OFFSET_PRIMARY_BLUE_X);
+	}
+
+	public float getPrimaryBlueY() {
+		return memGetFloat(this.address + OFFSET_PRIMARY_BLUE_Y);
+	}
+
+	public float getWhitePointX() {
+		return memGetFloat(this.address + OFFSET_WHITE_POINT_X);
+	}
+
+	public float getWhitePointY() {
+		return memGetFloat(this.address + OFFSET_WHITE_POINT_Y);
+	}
+
+	public float getMaxLuminance() {
+		return memGetFloat(this.address + OFFSET_MAX_LUMINANCE);
+	}
+
+	public float getMaxFrameLuminance() {
+		return memGetFloat(this.address + OFFSET_MAX_FRAME_LUMINANCE);
+	}
+
+	public float getMinLuminance() {
+		return memGetFloat(this.address + OFFSET_MIN_LUMINANCE);
+	}
+
+	@Override
+	public int sizeof() {
+		return SIZEOF;
+	}
+
+	static class Buffer extends StructBuffer<GLFWHDRConfig, Buffer> {
+		private static final GLFWHDRConfig ELEMENT_FACTORY = GLFWHDRConfig.create(-1L);
+
+		protected Buffer(long address, int capacity) {
+			super(address, null, -1, 0, capacity, capacity);
+		}
+
+		@Override
+		protected @NotNull GLFWHDRConfig getElementFactory() {
+			return ELEMENT_FACTORY;
+		}
+
+		@Override
+		protected @NotNull Buffer self() {
+			return this;
+		}
+	}
+}

common/src/main/java/net/irisshaders/iris/Iris.java

@@ -104,8 +104,7 @@ public class Iris {
 	private static boolean loadShaderPackWhenPossible;
 
 	static {
-		if (!BuildConfig.ACTIVATE_RENDERDOC && IrisPlatformHelpers.getInstance().isDevelopmentEnvironment() && System.getProperty("user.name").contains("ims") && Util.getPlatform() == Util.OS.LINUX) {
-		}
+		Configuration.GLFW_LIBRARY_NAME.set(IrisPlatformHelpers.getInstance().getGameDir().resolve("glfw3.dll").toAbsolutePath().toString());
 	}
 
 	/**

common/src/main/java/net/irisshaders/iris/mixin/MixinRenderTarget.java

@@ -1,14 +1,20 @@
 package net.irisshaders.iris.mixin;
 
 import com.mojang.blaze3d.pipeline.RenderTarget;
+import com.mojang.blaze3d.platform.GlStateManager;
+import net.irisshaders.iris.GLFWAccess;
 import net.irisshaders.iris.targets.Blaze3dRenderTargetExt;
+import org.lwjgl.opengl.GL46C;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import java.nio.IntBuffer;
+
 /**
  * Allows Iris to detect when the depth texture was re-created, so we can re-attach it
  * to the shader framebuffers. See DeferredWorldRenderingPipeline and RenderTargets.
@@ -27,6 +33,12 @@ public class MixinRenderTarget implements Blaze3dRenderTargetExt {
 	private void iris$onDestroyBuffers(CallbackInfo ci) {
 		iris$depthBufferVersion++;
 		iris$colorBufferVersion++;
+		GLFWAccess.tryHDRConf();
+	}
+
+	@Redirect(method = "createBuffers", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/platform/GlStateManager;_texImage2D(IIIIIIIILjava/nio/IntBuffer;)V", ordinal = 1))
+	private void create(int i, int j, int k, int l, int m, int n, int o, int p, IntBuffer intBuffer) {
+		GlStateManager._texImage2D(i, j, GL46C.GL_RGBA16F, l, m, n, o, p, intBuffer);
 	}
 
 	@Override

common/src/main/java/net/irisshaders/iris/uniforms/CommonUniforms.java

@@ -116,6 +116,7 @@ public static void addCommonUniforms(DynamicUniformHolder uniforms, IdMap idMap,
 	public static void addNonDynamicUniforms(UniformHolder uniforms, IdMap idMap, PackDirectives directives, FrameUpdateNotifier updateNotifier) {
 		CameraUniforms.addCameraUniforms(uniforms, updateNotifier);
 		ViewportUniforms.addViewportUniforms(uniforms);
+		HDRUniforms.addHDRUniforms(uniforms);
 		WorldTimeUniforms.addWorldTimeUniforms(uniforms);
 		SystemTimeUniforms.addSystemTimeUniforms(uniforms);
 		BiomeUniforms.addBiomeUniforms(uniforms);

common/src/main/java/net/irisshaders/iris/uniforms/HDRUniforms.java

@@ -0,0 +1,21 @@
+package net.irisshaders.iris.uniforms;
+
+import net.irisshaders.iris.GLFWAccess;
+import net.irisshaders.iris.GLFWHDRConfig;
+import net.irisshaders.iris.gl.uniform.UniformHolder;
+import net.irisshaders.iris.gl.uniform.UniformUpdateFrequency;
+import org.joml.Vector2f;
+
+public class HDRUniforms {
+	public static void addHDRUniforms(UniformHolder holder) {
+		GLFWHDRConfig config = GLFWAccess.conf;
+
+		holder.uniform2f(UniformUpdateFrequency.ONCE, "redPrimary", () -> new Vector2f(config.getPrimaryRedX(),config.getPrimaryRedY()));
+		holder.uniform2f(UniformUpdateFrequency.ONCE, "bluePrimary", () -> new Vector2f(config.getPrimaryBlueX(),config.getPrimaryBlueY()));
+		holder.uniform2f(UniformUpdateFrequency.ONCE, "greenPrimary", () -> new Vector2f(config.getPrimaryGreenX(),config.getPrimaryGreenY()));
+		holder.uniform2f(UniformUpdateFrequency.ONCE, "whitePoint", () -> new Vector2f(config.getWhitePointX(),config.getWhitePointY()));
+		holder.uniform1f(UniformUpdateFrequency.ONCE, "maxLuminance", () -> config.getMaxLuminance());
+		holder.uniform1f(UniformUpdateFrequency.ONCE, "maxFrameLuminance", () -> config.getMaxFrameLuminance());
+		holder.uniform1f(UniformUpdateFrequency.ONCE, "minLuminance", () -> config.getMinLuminance());
+	}
+}

settings.gradle.kts

@@ -17,4 +17,4 @@ pluginManagement {
     }
 }
 
-include("common", "fabric", "neoforge")
+include("common", "fabric")