feat: HDR rendering

features/Cloud Shadows/Shaders/Features/CloudShadows.ini

@@ -1,2 +1,2 @@
 [Info]
-Version = 1-2-0
+Version = 1-2-1

features/HDR Display/Shaders/Features/HDRDisplay.ini

@@ -0,0 +1,2 @@
+[Info]
+Version = 1-0-0

features/HDR Display/Shaders/HDRDisplay/HDROutputCS.hlsl

@@ -0,0 +1,100 @@
+/**
+ * @file HDROutputCS.hlsl
+ * @brief HDR: gamma decode, paper-white × (nits/203), BT.2020, PQ. SDR: passthrough + UI.
+ */
+
+#include "Common/Color.hlsli"
+#include "Common/SharedData.hlsli"
+
+Texture2D<float4> SceneTex : register(t0);
+Texture2D<float4> UITex : register(t1);
+RWTexture2D<float4> HDROutput : register(u0);
+
+cbuffer PerFrame : register(b0)
+{
+	float enableHDR : packoffset(c0.x);
+	float paperWhite : packoffset(c0.y);
+	float peakNits : packoffset(c0.z);
+	float skipUIComposite : packoffset(c0.w);
+	float uiBrightness : packoffset(c1.x);
+	float isSceneLinear : packoffset(c1.y);
+	float isMainOrLoadingMenu : packoffset(c1.z);
+	float fgTweenMenuMidAlphaBoost : packoffset(c1.w);  ///< TweenMenu: soften AA band when compositing here (UIBrightnessCS skips while paused)
+}
+
+[numthreads(8, 8, 1)] void main(uint3 dispatchID : SV_DispatchThreadID) {
+	uint width, height;
+	HDROutput.GetDimensions(width, height);
+	if (dispatchID.x >= width || dispatchID.y >= height)
+		return;
+
+	float4 scene = SceneTex[dispatchID.xy];
+	float4 ui = UITex[dispatchID.xy];
+
+	bool hdrEnabled = enableHDR > 0.5;
+	bool skipUI = skipUIComposite > 0.5;
+
+	float3 finalColor;
+
+	if (hdrEnabled) {
+		bool sceneIsLinear = isSceneLinear > 0.5;
+		float3 compositedColorLinear;
+
+		if (sceneIsLinear) {
+			float3 sceneLinear = max(0.0, scene.rgb);
+			if (skipUI) {
+				compositedColorLinear = sceneLinear;
+			} else {
+				float3 uiLinear = Color::SrgbToLinear(max(0.0, ui.rgb));
+				if (!(isMainOrLoadingMenu > 0.5)) {  // UI and scene can't be separated in main menu or loading screen
+					// scale UI brightness (multiplier based on paperWhite)
+					uiLinear *= uiBrightness;
+				}
+				compositedColorLinear = uiLinear + sceneLinear * (1.0 - ui.a);
+			}
+		} else {
+			float3 sceneGamma = scene.rgb;
+			float3 compositedColorGamma;
+			if (skipUI) {
+				compositedColorGamma = sceneGamma;
+			} else {
+				float3 uiGamma = ui.rgb;
+				if (!(isMainOrLoadingMenu > 0.5)) {  // UI and scene can't be separated in main menu or loading screen
+					// scale UI brightness (multiplier based on paperWhite)
+					float3 uiLinear = Color::SrgbToLinear(max(0, uiGamma));
+					uiLinear *= uiBrightness;
+					uiGamma = Color::LinearToSrgb(uiLinear);
+				}
+#if 0
+            if (fgTweenMenuMidAlphaBoost > 0.5 && ui.a > 1e-3) {
+                float midBand = smoothstep(0.3, 0.35, ui.a) * (1.0 - smoothstep(0.55, 0.6, ui.a));
+                const float fgMidAlphaBoost = 0.12;
+                ui.a = saturate(ui.a + midBand * fgMidAlphaBoost);
+            }
+#endif
+
+				compositedColorGamma = uiGamma + sceneGamma * (1.0 - ui.a);
+			}
+
+			// Non-LL path: ISHDR output is gamma-encoded at this stage.
+			compositedColorLinear = Color::GammaToLinearSafe(compositedColorGamma);
+		}
+
+		compositedColorLinear = Color::BT709ToBT2020(compositedColorLinear);
+		finalColor = Color::pq::Encode(max(0.0, compositedColorLinear), paperWhite);
+
+		finalColor = saturate(finalColor);
+	} else {
+		float3 sceneGamma = scene.rgb;
+
+		if (skipUI) {
+			finalColor = sceneGamma;
+		} else {
+			finalColor = ui.rgb + sceneGamma * (1.0 - ui.a);
+		}
+
+		finalColor = saturate(finalColor);
+	}
+
+	HDROutput[dispatchID.xy] = float4(finalColor, 1.0);
+}

features/HDR Display/Shaders/HDRDisplay/UIBrightnessCS.hlsl

@@ -0,0 +1,67 @@
+// Preprocess vanilla UI for Frame Gen compositing.
+// HDR path converts UI to PQ/BT.2020 using configured paper white.
+// SDR path keeps gamma UI and only clamps negatives.
+
+#include "Common/Color.hlsli"
+
+RWTexture2D<float4> UITex : register(u0);
+
+cbuffer PerFrame : register(b0)
+{
+	float enableHDR : packoffset(c0.x);                 ///< 1.0 = HDR output with PQ, 0.0 = SDR output with gamma
+	float paperWhite : packoffset(c0.y);                ///< Reference white in nits (used by HDR UI conversion)
+	float peakNits : packoffset(c0.z);                  ///< Maximum display brightness in nits for HDR (unused here)
+	float skipUIComposite : packoffset(c0.w);           ///< Unused in this shader
+	float uiBrightness : packoffset(c1.x);              ///< UI brightness multiplier
+	float isSceneLinear : packoffset(c1.y);             ///< Unused in this shader
+	float isMainOrLoadingMenu : packoffset(c1.z);       ///< Unused; layout matches HDRDataCB
+	float fgTweenMenuMidAlphaBoost : packoffset(c1.w);  ///< 1 = TweenMenu open: apply mid-alpha AA boost only for pause UI
+}
+
+[numthreads(8, 8, 1)] void main(uint3 dispatchID : SV_DispatchThreadID) {
+	// Bounds check to prevent UAV out-of-bounds reads/writes
+	uint width, height;
+	UITex.GetDimensions(width, height);
+	if (dispatchID.x >= width || dispatchID.y >= height)
+		return;
+
+	float4 ui = UITex[dispatchID.xy];
+
+	bool hdrEnabled = enableHDR > 0.5;
+
+	if (hdrEnabled) {
+		// FidelityFX FG blends in PQ space, so UI must be PQ/BT.2020.
+		const float uiReferenceNits = max(paperWhite, 1.0);
+
+		if (ui.a > 0.001) {
+			// Pause menu only: raise coverage in the soft AA band to avoid washout.
+			float aIn = ui.a;
+			float aOut = aIn;
+			if (fgTweenMenuMidAlphaBoost > 0.5) {
+				float midBand = smoothstep(0.3, 0.35, aIn) * (1.0 - smoothstep(0.55, 0.6, aIn));
+				const float fgMidAlphaBoost = 0.12;
+				aOut = saturate(aIn + midBand * fgMidAlphaBoost);
+			}
+
+			float3 uiStraight = ui.rgb / aIn;
+			float3 uiLinear = Color::SrgbToLinear(max(0, uiStraight));
+			float3 uiBT2020 = Color::BT709ToBT2020(uiLinear);
+			float3 uiNits = uiBT2020 * uiReferenceNits * uiBrightness;
+			ui.rgb = Color::pq::Encode(uiNits / 10000.0, 10000.0) * aOut;
+			ui.a = aOut;
+		} else {
+			// Broken-alpha path: transform premultiplied color and keep alpha at 0.
+			float3 uiLinear = Color::SrgbToLinear(max(0, ui.rgb));
+			float3 uiBT2020 = Color::BT709ToBT2020(uiLinear);
+			float3 uiNits = uiBT2020 * uiReferenceNits * uiBrightness;
+			ui.rgb = Color::pq::Encode(uiNits / 10000.0, 10000.0);
+		}
+	} else {
+		// SDR path: keep premultiplied gamma UI, clamp negatives only.
+		ui.rgb = max(0, ui.rgb);
+		UITex[dispatchID.xy] = ui;
+		return;
+	}
+
+	UITex[dispatchID.xy] = ui;
+}

features/Upscaling/Shaders/Features/Upscaling.ini

@@ -1,2 +1,2 @@
 [Info]
-Version = 1-3-1
+Version = 1-4-0