feat(vr-dlss): VR DLSS viewport scaling with periphery TAA

features/Extended Materials/Shaders/ExtendedMaterials/ExtendedMaterials.hlsli

@@ -325,6 +325,7 @@ namespace ExtendedMaterials
 	float2 GetParallaxCoords(float distance, float2 coords, float mipLevel, float3 viewDir, float3x3 tbn, float noise, Texture2D<float4> tex, SamplerState texSampler, uint channel, DisplacementParams params, out float pixelOffset)
 #endif
 	{
+		pixelOffset = 0.5;
 		float3 viewDirTS = normalize(mul(tbn, viewDir));
 #if defined(LANDSCAPE)
 		viewDirTS.xy /= viewDirTS.z * 0.7 + 0.3 + params[0].FlattenAmount;  // Fix for objects at extreme viewing angles
@@ -496,7 +497,7 @@ namespace ExtendedMaterials
 #endif
 				nearBlendToFar *= nearBlendToFar;
 			float offset = (1.0 - parallaxAmount) * -maxHeight + minHeight;
-			pixelOffset = lerp(parallaxAmount * scale, 0, nearBlendToFar);
+			pixelOffset = saturate(lerp(parallaxAmount, 0.5, nearBlendToFar));
 			return lerp(viewDirTS.xy * offset + coords.xy, coords, nearBlendToFar);
 		}
 
@@ -509,7 +510,7 @@ namespace ExtendedMaterials
 		weights[5] = input.LandBlendWeights2.y;
 #endif
 
-		pixelOffset = 0;
+		pixelOffset = 0.5;
 		return coords;
 	}
 

features/Upscaling/Shaders/Upscaling/ClearHMDMaskCS.hlsl

@@ -4,20 +4,53 @@
 // depth == 0.0 is the unrendered/hidden area value (Skyrim reversed-Z: far plane = 0).
 // DepthIn is the combined stereo depth buffer; DepthOffsetX selects the eye's half.
 // ColorInOut is the isolated per-eye buffer; ColorOffsetX is always 0.
+//
+// When DepthWidth > 0, coordinate scaling is enabled: depth is at render-res while
+// color is at display-res. The shader maps display-res color coordinates to render-res
+// depth coordinates for the mask lookup.
+//
+// FallbackIn (t1): when bound, masked pixels read from this texture instead of writing
+// black. When unbound, D3D11 returns (0,0,0,0) — same as clearing to black.
+// FallbackOffsetX selects the eye's half in the stereo fallback texture.
 
 cbuffer ClearHMDMaskCB : register(b0)
 {
-	uint DepthOffsetX;  // X offset into combined stereo depth (0 = left, eyeWidth = right)
-	uint ColorOffsetX;  // X offset into color target (always 0 for per-eye buffers)
-	uint pad0;
-	uint pad1;
+	uint DepthOffsetX;     // X offset into combined stereo depth (0 = left, eyeWidth = right)
+	uint ColorOffsetX;     // X offset into color target (always 0 for per-eye buffers)
+	uint DepthOffsetY;     // Y offset into combined stereo depth (non-zero when viewport scaling crops vertically)
+	uint FallbackOffsetX;  // X offset into FallbackIn for stereo (0 when unused or left eye)
+	// Optional coordinate scaling (zero = disabled, for backwards compat)
+	uint DepthWidth;   // render-res eye width; if 0, no scaling (1:1 depth/color coords)
+	uint DepthHeight;  // render-res eye height
+	uint ColorWidth;   // display-res eye width
+	uint ColorHeight;  // display-res eye height
 };
 
 Texture2D<float> DepthIn : register(t0);
+Texture2D<float4> FallbackIn : register(t1);
 RWTexture2D<float4> ColorInOut : register(u0);
 
 [numthreads(8, 8, 1)] void main(uint3 dispatchID : SV_DispatchThreadID) {
-	// Read from stereo depth, write to potentially stereo color
-	if (DepthIn[dispatchID.xy + uint2(DepthOffsetX, 0)] == 0.0)
-		ColorInOut[dispatchID.xy + uint2(ColorOffsetX, 0)] = float4(0.0, 0.0, 0.0, 0.0);
+	uint w, h;
+	ColorInOut.GetDimensions(w, h);
+	if (dispatchID.x >= w || dispatchID.y >= h)
+		return;
+
+	uint2 colorPos = dispatchID.xy + uint2(ColorOffsetX, 0);
+	uint2 depthPos;
+
+	if (DepthWidth > 0) {
+		// Scale from display-res color coordinates to render-res depth coordinates
+		depthPos = uint2(
+					   (dispatchID.x * DepthWidth) / ColorWidth,
+					   (dispatchID.y * DepthHeight) / ColorHeight) +
+		           uint2(DepthOffsetX, DepthOffsetY);
+	} else {
+		depthPos = dispatchID.xy + uint2(DepthOffsetX, DepthOffsetY);
+	}
+
+	if (DepthIn[depthPos] == 0.0)
+		ColorInOut[colorPos] = FallbackIn[dispatchID.xy + uint2(FallbackOffsetX, 0)];
+	// When FallbackIn is unbound (existing callers): returns (0,0,0,0) → clears to black
+	// When FallbackIn is bound (TAA mask restore): returns display RT content
 }

features/Upscaling/Shaders/Upscaling/DLSSCompositePS.hlsl

@@ -0,0 +1,48 @@
+// Format-converting fullscreen pixel shader with optional bilinear upscale.
+// Used by TAAReorder to composite between textures of different DXGI formats
+// (e.g. R8G8B8A8_UNORM conductor RTs <-> R11G11B10_FLOAT kMAIN).
+// The GPU's output merger handles format conversion automatically.
+//
+// BILINEAR_UPSCALE variant: upscales render-res content to display-res by
+// mapping output pixel positions through the dynamic resolution scale,
+// like PureDark's dynamicResScale in his blend shader.
+
+#include "Upscaling/UpscaleVS.hlsl"
+
+#ifdef PSHADER
+
+Texture2D<float4> Source : register(t0);
+
+#	ifdef BILINEAR_UPSCALE
+
+cbuffer CompositeCB : register(b0)
+{
+	float2 DynResScale;  // renderRes / displayRes (per-eye)
+	float2 EyeOffset;    // (i * eyeWidth, 0) in texels
+	float2 SrcTexSize;   // full texture dimensions in texels
+	float2 pad;
+};
+
+SamplerState LinearSampler : register(s0);
+
+float4 main(VS_OUTPUT input) : SV_Target
+{
+	// Map display-res pixel position to render-res source position.
+	// Subtract eye offset, scale to render-res, add eye offset back.
+	float2 localPos = input.Position.xy - EyeOffset;
+	float2 srcLocal = localPos * DynResScale;
+	float2 srcPos = srcLocal + EyeOffset;
+	float2 srcUV = srcPos / SrcTexSize;
+	return Source.SampleLevel(LinearSampler, srcUV, 0);
+}
+
+#	else
+
+float4 main(VS_OUTPUT input) : SV_Target
+{
+	return Source.Load(int3(input.Position.xy, 0));
+}
+
+#	endif  // BILINEAR_UPSCALE
+
+#endif  // PSHADER

features/Upscaling/Shaders/Upscaling/DepthUpscalePS.hlsl

@@ -0,0 +1,70 @@
+/**
+ * @file DepthUpscalePS.hlsl
+ * @brief Point-sampled depth buffer upscaling for VR depth-based culling
+ *
+ * When upscaling (FSR/DLSS) is active, the depth buffer is rendered at a lower
+ * resolution than the display. Skyrim VR's depth-based culling (OBBOcclusionTesting)
+ * reads from the depth buffer to determine object visibility, but with a mismatched
+ * resolution, objects may be incorrectly culled (appearing to flicker in/out of view).
+ *
+ * This shader upscales the low-resolution depth buffer to full resolution using
+ * pure point sampling. Previous conservative blending (GatherRed + lerp toward
+ * min depth) caused HAM mask bleed: depth == 0 values from the hidden area mesh
+ * leaked into valid depth through the 2x2 neighborhood blend, creating artifacts
+ * at the mask boundary after DRS upscaling.
+ *
+ * Based on depth upscaling approach by vrnord
+ * https://github.com/vrnord/skyrim-community-shaders-VR-DLSS
+ */
+
+#include "Upscaling/UpscaleVS.hlsl"
+
+#if defined(PSHADER)
+#	include "Common/FrameBuffer.hlsli"
+#	include "Common/SharedData.hlsli"
+
+typedef VS_OUTPUT PS_INPUT;
+
+struct PS_OUTPUT
+{
+	float Depth: SV_Depth;
+};
+
+Texture2D<float> DepthLowRes : register(t0);
+
+cbuffer DepthUpscaleCB : register(b0)
+{
+	float2 SourceDim;     // Full texture dimensions (texels)
+	float2 InvSourceDim;  // 1.0 / SourceDim
+	float2 Scale;         // resolutionScale (render/display ratio)
+	float2 Pad;
+};
+
+/**
+ * @brief Main pixel shader entry point
+ *
+ * Pure point-sampled depth upscaling. Maps display-res pixel position to
+ * render-res texel and loads directly — no blending, no mask bleed.
+ */
+PS_OUTPUT main(PS_INPUT input)
+{
+	PS_OUTPUT psout;
+
+	// Map full-res UV to render-res UV (same transform as the engine's
+	// GetDynamicResolutionAdjustedScreenPosition).
+	float2 uv = Scale * input.TexCoord;
+
+	// Per-eye clamping for SBS stereo: prevent sampling across the center seam.
+	bool isRight = input.TexCoord.x >= 0.5;
+	float halfScale = 0.5 * Scale.x;
+	uv.x = clamp(uv.x, isRight ? halfScale : 0.0, isRight ? Scale.x : halfScale);
+	uv.y = clamp(uv.y, 0.0, Scale.y);
+
+	// Nearest texel coordinate — pure point sampling, no blending
+	int2 texel = int2(floor(uv * SourceDim));
+	psout.Depth = DepthLowRes.Load(int3(texel, 0));
+
+	return psout;
+}
+
+#endif

features/Upscaling/Shaders/Upscaling/FeatheredCompositeCS.hlsl

@@ -0,0 +1,41 @@
+cbuffer FeatherCB : register(b0)
+{
+	uint CropX;          // paste position X in output space
+	uint CropY;          // paste position Y in output space
+	uint CropW;          // crop width
+	uint CropH;          // crop height
+	float FeatherWidth;  // feather distance in pixels (inward from crop edge)
+	float3 pad;
+};
+
+Texture2D<float4> CropTexture : register(t0);      // DLSS output (crop-sized, at {0,0})
+RWTexture2D<float4> OutputTexture : register(u0);  // vrFinalOutput (already filled with periphery)
+
+[numthreads(8, 8, 1)] void main(uint3 dispatchID : SV_DispatchThreadID) {
+	// dispatchID is in crop-local space (0..CropW-1, 0..CropH-1)
+	int2 cropLocal = int2(dispatchID.xy);
+	if (cropLocal.x >= (int)CropW || cropLocal.y >= (int)CropH)
+		return;
+
+	// Output pixel = crop-local + paste offset
+	int2 pixel = cropLocal + int2(CropX, CropY);
+
+	// Distance from nearest crop edge (positive = inside)
+	float distLeft = (float)cropLocal.x;
+	float distRight = (float)(CropW - 1 - cropLocal.x);
+	float distTop = (float)cropLocal.y;
+	float distBottom = (float)(CropH - 1 - cropLocal.y);
+	float distFromEdge = min(min(distLeft, distRight), min(distTop, distBottom));
+
+	float4 dlss = CropTexture.Load(int3(cropLocal, 0));
+
+	if (FeatherWidth <= 0.0 || distFromEdge >= FeatherWidth) {
+		// Inside crop interior or no feathering: 100% DLSS
+		OutputTexture[pixel] = dlss;
+	} else {
+		// Feather zone: smooth blend from periphery (TAA-stabilized) to DLSS
+		float blend = smoothstep(0.0, FeatherWidth, distFromEdge);
+		float4 periphery = OutputTexture[pixel];
+		OutputTexture[pixel] = lerp(periphery, dlss, blend);
+	}
+}

features/Upscaling/Shaders/Upscaling/FeatheredCompositePS.hlsl

@@ -0,0 +1,56 @@
+// Feathered DLSS crop composite using hardware alpha blending.
+// Based on PureDark's approach from Skyrim-Upscaler VR (MIT license).
+//
+// The render target already contains TAA'd periphery content.
+// We output float4(DLSSColor, featherAlpha) and let the output merger's
+// SrcAlpha/InvSrcAlpha blend preserve the periphery in the feather zone
+// and outside the crop rect entirely.
+
+#include "Upscaling/UpscaleVS.hlsl"
+
+#ifdef PSHADER
+
+Texture2D<float4> CropTexture : register(t0);
+SamplerState LinearSampler : register(s0);
+
+cbuffer FeatheredCompositeCB : register(b0)
+{
+	float2 CropOrigin;   // paste position (x, y) in output-eye pixel coords
+	float2 CropSize;     // crop width, height in pixels
+	float FeatherWidth;  // feather distance in pixels (inward from crop edge)
+	float _pad0;
+	float2 SrcUVOrigin;  // UV origin in source texture for this crop region
+	float2 SrcUVScale;   // UV scale: maps [0,1] crop-local UV to source texture UV range
+};
+
+float4 main(VS_OUTPUT input) : SV_Target
+{
+	float2 pixelPos = input.Position.xy;
+
+	// Distance from each edge of the crop rect (positive = inside)
+	float distLeft = pixelPos.x - CropOrigin.x;
+	float distRight = (CropOrigin.x + CropSize.x) - pixelPos.x;
+	float distTop = pixelPos.y - CropOrigin.y;
+	float distBottom = (CropOrigin.y + CropSize.y) - pixelPos.y;
+
+	float minDist = min(min(distLeft, distRight), min(distTop, distBottom));
+
+	// Outside crop rect: fully transparent (hardware blend preserves TAA'd periphery)
+	if (minDist <= 0.0)
+		return float4(0, 0, 0, 0);
+
+	// Feather alpha: smoothstep ramp from 0 at edge to 1 at FeatherWidth inside
+	// (matches the smoothstep from the original CS for visual consistency)
+	float alpha = (FeatherWidth > 0.0) ? smoothstep(0.0, FeatherWidth, minDist) : 1.0;
+
+	// Map pixel position to crop-local UV [0,1], then remap to source texture UV.
+	// For per-eye textures: SrcUVOrigin=(0,0), SrcUVScale=(1,1) (identity).
+	// For SBS textures: SrcUVOrigin/Scale select the correct eye's crop region.
+	float2 cropUV = (pixelPos - CropOrigin) / CropSize;
+	float2 srcUV = cropUV * SrcUVScale + SrcUVOrigin;
+	float3 dlssColor = CropTexture.SampleLevel(LinearSampler, srcUV, 0).rgb;
+
+	return float4(dlssColor, alpha);
+}
+
+#endif  // PSHADER

features/Upscaling/Shaders/Upscaling/ForceAlphaCS.hlsl

@@ -0,0 +1,17 @@
+// Forces alpha to 1.0 across the entire texture.
+// Used after DLSS center paste onto submit texture to ensure Scaleform UI renders.
+// DLSS output may have alpha=0 (from R11G11B10→R8G8B8A8 conversion with no alpha source),
+// which can prevent UI compositing in the DLSS center area.
+
+RWTexture2D<float4> ColorInOut : register(u0);
+
+[numthreads(8, 8, 1)] void main(uint3 dispatchID : SV_DispatchThreadID) {
+	uint w, h;
+	ColorInOut.GetDimensions(w, h);
+	if (dispatchID.x >= w || dispatchID.y >= h)
+		return;
+
+	float4 c = ColorInOut[dispatchID.xy];
+	c.a = 1.0;
+	ColorInOut[dispatchID.xy] = c;
+}

features/Upscaling/Shaders/Upscaling/VRPeripheryFillCS.hlsl

@@ -0,0 +1,24 @@
+// Bilinear upscale from render-resolution per-eye buffer to display-resolution per-eye buffer.
+// Used for VR viewport scaling: fills the full eye output with a cheap upscale so the
+// periphery (outside the DLSS-processed center) is not black/empty.
+
+cbuffer PeripheryFillCB : register(b0)
+{
+	uint SrcWidth;
+	uint SrcHeight;
+	uint DstWidth;
+	uint DstHeight;
+};
+
+Texture2D<float4> SrcTexture : register(t0);
+SamplerState LinearSampler : register(s0);
+RWTexture2D<float4> DstTexture : register(u0);
+
+[numthreads(8, 8, 1)] void main(uint3 dispatchID : SV_DispatchThreadID) {
+	if (dispatchID.x >= DstWidth || dispatchID.y >= DstHeight)
+		return;
+
+	// Normalized UV with half-pixel offset for correct bilinear sampling
+	float2 uv = (float2(dispatchID.xy) + 0.5) / float2(DstWidth, DstHeight);
+	DstTexture[dispatchID.xy] = SrcTexture.SampleLevel(LinearSampler, uv, 0);
+}

package/Shaders/Common/SharedData.hlsli

@@ -23,7 +23,7 @@ namespace SharedData
 		bool InInterior;  // If the area lacks a directional shadow light e.g. the sun or moon
 		bool InMapMenu;   // If the world/local map is open (note that the renderer is still deferred here)
 		bool HideSky;     // HideSky flag in WorldSpace, e.g. Blackreach
-		float MipBias;    // Offset to mip level for TAA sharpness#
+		float MipBias;    // Offset to mip level for TAA sharpness
 		float pad0;
 		float4 AmbientSHR;
 		float4 AmbientSHG;
@@ -52,7 +52,7 @@ namespace SharedData
 		bool EnableShadows;
 		bool ExtendShadows;
 		bool EnableParallaxWarpingFix;
-		float1 pad0;
+		bool pad0;
 	};
 
 	struct CubemapCreatorSettings

package/Shaders/Common/VR.hlsli

@@ -21,6 +21,7 @@ cbuffer VRValues : register(b13)
 	float2 EyeOffsetScale : packoffset(c0.z);
 	float4 EyeClipEdge[2] : packoffset(c1);
 }
+
 #endif
 
 namespace Stereo