fix(VR): apply per eye upscaling

[alandtse]

• Split upscaling across each eye for correctness and to avoid DLSS failing over 8k x 8k limit
• Changes HMD mask color to black to hide artifacts with fast movement

Summary by CodeRabbit

• New Features

  • Per-eye VR upscaling for improved VR image quality
  • HMD mask clearing to prevent ghosting/ensure correct transparency
  • VR debug visualization for per-eye intermediates and buffers

• Improvements

  • Better VR resource management for stability and performance
  • Enhanced buffer viewer UI with clearer labels and null-safety checks

[coderabbitai]

📝 Walkthrough

Walkthrough

Adds VR per-eye upscaling: new HLSL compute shader to clear HMD hidden-area pixels, per-eye intermediate textures and lifecycle management in Upscaling, dual FSR3 contexts, and per-eye DLSS evaluation and frame-constants updates across Streamline/FidelityFX.

Changes

Cohort / File(s)	Summary
VR Shader features/Upscaling/Shaders/Upscaling/ClearHMDMaskCS.hlsl	New compute shader that clears per-eye hidden-area pixels by sampling stereo depth with an X offset and zeroing corresponding per-eye color pixels. Uses [numthreads(8,8,1)] and a CB for offsets.
Upscaling core (implementation & header) src/Features/Upscaling.cpp, src/Features/Upscaling.h	Adds per-eye intermediate textures (color in/out, typeless depth with R32_FLOAT SRV, motion vectors, reactive/transparency masks), VR allocation tracking, CreateTextureFromSource, CreateVRIntermediateTextures, PreparePerEyeInputs, FinalizePerEyeOutputs, ClearHMDMask dispatch + CB, and VR debug UI/resource lifecycle handling.
FidelityFX (FSR3) integration src/Features/Upscaling/FidelityFX.cpp, src/Features/Upscaling/FidelityFX.h	Converts single FSR3 context to an array of two contexts, initializes/destroys per-eye contexts, updates dispatch logic to loop per eye, and adapts scratch sizing and logging for per-eye FSR dispatches.
Streamline / DLSS per-eye changes src/Features/Upscaling/Streamline.cpp, src/Features/Upscaling/Streamline.h	Makes CheckFrameConstants and SetDLSSOptions per-viewport/eye, adds EvaluateDLSS for per-eye evaluation, adds viewportRight and resource-tracking flags, updates Upscale flow to prepare per-eye inputs and finalize outputs, and extends cleanup for VR resources.
UI macros src/Utils/UI.h	Replaces BUFFER_VIEWER_NODE with guarded BUFFER_VIEWER_NODE_IMPL and new BUFFER_VIEWER_NODE_TITLE; adds null checks and resolution-aware labeling for buffer viewer macros.

Sequence Diagram

sequenceDiagram
    participant App as Application
    participant Upscale as Upscaling Pipeline
    participant PrepEye as PreparePerEyeInputs
    participant ClearMask as ClearHMDMask CS
    participant FSR as FSR3 Context[per-eye]
    participant DLSS as Streamline/EvaluateDLSS
    participant FinalEye as FinalizePerEyeOutputs

    App->>Upscale: Submit frame
    Upscale->>Upscale: IsVR? (branch)
    alt VR
        Upscale->>PrepEye: Extract per-eye color/depth/mvec/reactive/transparency
        PrepEye->>ClearMask: Dispatch ClearHMDMask(depthSRV, colorUAV, offsets)
        ClearMask-->>PrepEye: Mask cleared
        loop For each eye (L,R)
            Upscale->>FSR: Dispatch per-eye FSR3 using fsrContext[eye]
            FSR-->>Upscale: Upscaled per-eye result
            Upscale->>DLSS: EvaluateDLSS(eye, per-eye resources)
            DLSS-->>Upscale: DLSS output per eye
        end
        Upscale->>FinalEye: Merge/write per-eye outputs to stereo target
    else Non-VR
        Upscale->>FSR: Dispatch single-context FSR3
        Upscale->>DLSS: EvaluateDLSS(eye=0, resources)
        Upscale-->>App: Frame upscaled
    end

Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

Possibly related PRs

• feat(VR): enable upscaling #1507 — Implements VR upscaling support and per-eye resource/state management; overlaps directly with VR resource and flow changes here.
• chore(upscaling): simplify interop and upscale methods #1514 — Modifies the upscaling subsystem and per-eye resource flows, touching FidelityFX/FSR3 integration similar to this PR.
• chore(upscaling): update streamline sdk #1450 — Changes Streamline's upscaling and mask handling; strongly related to the Streamline per-eye refactors in this PR.

Suggested reviewers

• doodlum
• jiayev

Poem

🐰 I hopped through stereo code tonight,

Cleared hidden masks so pixels are right,
Two FSR hearts beating left and right,
DLSS eyes set to sharp delight,
Hoppy frames now dance in VR light. ✨

🚥 Pre-merge checks | ✅ 2 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 9.09% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title 'fix(VR): apply per eye upscaling' directly describes the main objective of the changeset—implementing per-eye upscaling for VR to avoid DLSS size limits and improve correctness, which is clearly reflected across all modified files.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[github-actions]

Using provided base ref: b931d7e
Using base ref: b931d7e
Base commit date: 2026-02-04T23:20:25-08:00 (Wednesday, February 04, 2026 11:20 PM)
No actionable suggestions for changed features.

[Copilot]

Pull request overview

This pull request fixes VR upscaling by implementing per-eye processing for both DLSS and FSR3, addressing temporal ghosting issues and avoiding DLSS's 8k x 8k resolution limit in stereo rendering. The implementation splits the combined stereo buffer into separate per-eye textures, processes each eye independently through the upscaling pipeline, and merges the results back.

Changes:

• Implemented per-eye upscaling pipeline with intermediate buffers for VR to isolate left/right eye processing
• Added dual viewport support for Streamline DLSS and dual context support for FidelityFX FSR3
• Enhanced VR debugging UI with per-eye buffer visualization and resolution display macros

Reviewed changes

Copilot reviewed 8 out of 8 changed files in this pull request and generated 5 comments.

Show a summary per file

File	Description
src/Utils/UI.h	Enhanced BUFFER_VIEWER_NODE macros to display texture resolutions and add null-safety checks
src/Features/Upscaling/Streamline.h	Added viewportRight handle, resourcesAllocated tracking, and EvaluateDLSS helper for per-eye DLSS processing
src/Features/Upscaling/Streamline.cpp	Refactored CheckFrameConstants and SetDLSSOptions for per-viewport operation; implemented EvaluateDLSS helper; added runtime HDR detection; updated Upscale for VR/non-VR paths
src/Features/Upscaling/FidelityFX.h	Changed fsrContext from single instance to array[2] for per-eye contexts
src/Features/Upscaling/FidelityFX.cpp	Refactored FSR3 resource creation/destruction for per-eye contexts; updated Upscale with DispatchFSR lambda for VR/non-VR paths
src/Features/Upscaling.h	Added VR intermediate buffers, ClearHMDMask functionality, and helper methods for texture creation and per-eye pipeline processing
src/Features/Upscaling.cpp	Implemented CreateVRIntermediateTextures, PreparePerEyeInputs, FinalizePerEyeOutputs, and ClearHMDMask; added VR debug UI; updated CheckFrameConstants with early return for VR; enhanced resize detection

[coderabbitai]

Actionable comments posted: 1

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (2)

src/Features/Upscaling/FidelityFX.cpp (1)

197-241: ⚠️ Potential issue | 🟠 Major

Destroy already-created FSR3 contexts on partial failure.

If context creation fails for a later eye (i.e., when i > 0), earlier contexts remain allocated while the scratch buffer is freed. This leaves GPU resources leaked and the system in an inconsistent state. Add cleanup to tear down any contexts successfully created before the failure.

Proposed fix

 		if (ffxFsr3ContextCreate(&fsrContext[i], &contextDescription) != FFX_OK) {
 			logger::critical("[FidelityFX] Failed to initialize FSR3 context for eye {}!", i);
+			for (uint32_t j = 0; j < i; ++j) {
+				ffxFsr3ContextDestroy(&fsrContext[j]);
+			}
 			free(fsrScratchBuffer);
 			fsrScratchBuffer = nullptr;
 			return;
 		}

src/Features/Upscaling/Streamline.cpp (1)

455-464: ⚠️ Potential issue | 🟠 Major

Free DLSS resources for the right-eye viewport in VR.

In VR, EvaluateDLSS allocates resources for both eyes (viewport and viewportRight) and tracks allocation state in vrResourcesAllocated[0] and vrResourcesAllocated[1]. However, DestroyDLSSResources only frees the main viewport and resets the non-VR tracking flag, leaving right-eye resources and the VR allocation state inconsistent. This causes resource leaks when switching upscaling modes in VR and leaves stale allocations that can interfere with subsequent operations.

🛠️ Proposed fix

 void Streamline::DestroyDLSSResources()
 {
 	sl::DLSSOptions dlssOptions{};
 	dlssOptions.mode = sl::DLSSMode::eOff;
 	slDLSSSetOptions(viewport, dlssOptions);
 	slFreeResources(sl::kFeatureDLSS, viewport);
+	if (globals::game::isVR) {
+		slDLSSSetOptions(viewportRight, dlssOptions);
+		slFreeResources(sl::kFeatureDLSS, viewportRight);
+		globals::features::upscaling.vrResourcesAllocated[0] = false;
+		globals::features::upscaling.vrResourcesAllocated[1] = false;
+	}
 
 	// Non-VR resource tracking
 	resourcesAllocated = false;
 }

🤖 Fix all issues with AI agents

In `@src/Utils/UI.h`:
- Around line 19-24: Add a direct include of <cstdio> to the header and replace
the unqualified call to snprintf inside the BUFFER_VIEWER_NODE_IMPL macro with
std::snprintf to ensure header self-containment and avoid relying on transitive
includes; update the macro's snprintf usage to std::snprintf while keeping the
existing buffer size/format arguments and preserve the rest of the macro logic.

🧹 Nitpick comments (3)

features/Upscaling/Shaders/Upscaling/ClearHMDMaskCS.hlsl (1)

1-6: Conventional commit title + issue reference suggestion.

Consider updating the title to fix(vr): apply per-eye upscaling (lowercase scope, hyphenated) and, if there’s a tracking issue, add “Fixes #” / “Closes #”.
As per coding guidelines: **/*: provide suggestions for Conventional Commit Titles and Issue References.

src/Utils/UI.h (1)

20-27: Avoid multiple evaluation of a_value in the macro.

The macro reads a_value several times; if callers pass expressions with side effects, this can misbehave and adds redundant loads. Consider capturing once inside a do { ... } while(0) block.

♻️ Suggested refactor

-#define BUFFER_VIEWER_NODE_IMPL(a_value, a_label, a_scale)                                                       \
-	if (a_value && a_value->srv.get()) {                                                                         \
-		char buf[128];                                                                                           \
-		snprintf(buf, sizeof(buf), "%s (%ux%u)", a_label, a_value->desc.Width, a_value->desc.Height);            \
-		if (ImGui::TreeNode(buf)) {                                                                              \
-			ImGui::Image(a_value->srv.get(), { a_value->desc.Width * a_scale, a_value->desc.Height * a_scale }); \
-			ImGui::TreePop();                                                                                    \
-		}                                                                                                        \
-	}
+#define BUFFER_VIEWER_NODE_IMPL(a_value, a_label, a_scale)                                                        \
+	do {                                                                                                          \
+		auto* _val = (a_value);                                                                                   \
+		if (_val && _val->srv.get()) {                                                                            \
+			char buf[128];                                                                                        \
+			snprintf(buf, sizeof(buf), "%s (%ux%u)", a_label, _val->desc.Width, _val->desc.Height);               \
+			if (ImGui::TreeNode(buf)) {                                                                           \
+				ImGui::Image(_val->srv.get(), { _val->desc.Width * a_scale, _val->desc.Height * a_scale });       \
+				ImGui::TreePop();                                                                                 \
+			}                                                                                                     \
+		}                                                                                                         \
+	} while (0)

src/Features/Upscaling.cpp (1)

747-785: Add defensive validation for source resources.
Line 750 assumes src is a non-null ID3D11Texture2D; if a resource is missing or a different type slips in, this will crash. Consider guarding and logging so malformed configs fail gracefully. As per coding guidelines: Validate user input and prevent DirectX crashes from malformed configurations.

🛡️ Suggested guard

-	D3D11_TEXTURE2D_DESC srcDesc;
-	static_cast<ID3D11Texture2D*>(src)->GetDesc(&srcDesc);
+	if (!src) {
+		logger::error("[Upscaling] CreateTextureFromSource called with null source");
+		return nullptr;
+	}
+	winrt::com_ptr<ID3D11Texture2D> srcTex;
+	if (FAILED(src->QueryInterface(srcTex.put()))) {
+		logger::error("[Upscaling] CreateTextureFromSource expects ID3D11Texture2D");
+		return nullptr;
+	}
+	D3D11_TEXTURE2D_DESC srcDesc{};
+	srcTex->GetDesc(&srcDesc);

[github-actions]

✅ A pre-release build is available for this PR:
Download