Skip to content

VectorXR 0.20.1: depth for Direct3D 11 games, PimaxXR fixes, and Duplicate Pivot profiles - #136

Merged
mdiener87 merged 95 commits into
masterfrom
0.20.1
Nov 10, 2026
Merged

mdiener87 merged 95 commits into
masterfrom
0.20.1

Conversation

@mdiener87

@mdiener87 mdiener87 commented Nov 9, 2026 •

Copy link
Copy Markdown
Collaborator

VectorXR 0.20.1. Release notes: release/notes/v0.20.1.md (also in the app's patch notes).

What's in it

  • Direct3D 11 depth for Frame Generation: the Direct3D 11 → Direct3D 12 bridge now copies a game's depth into the runtime's depth images (UEVR, iRacing's D16), with the game's device lock taken before the layer's locks. A new per-profile Use game depth option under Frame Generation's advanced settings (on by default) turns it off: Frame Generation works without depth and both bridges keep depth private, as in 0.20.0 (no copy, no multithread protection turned on). VECTORXR_D3D11_BRIDGE_DEPTH=private still works machine-wide (documented in docs/usage.md).
  • PimaxXR: Frame Generation no longer stalls the game's own swapchain calls behind PimaxXR's end-of-frame lock (VDXR has the same lock pattern), a later frame instead of a lost refresh on PimaxXR ≤ 0.4.4, eye-tracked foveation stays on in native quad views, DCS focus views stay aligned, Pivot re-anchors after a silent recenter, and leftover events or unlocated views from a previous session are ignored.
  • Turbo: Auto rides out stalls right after async engages and retries a sequenced verdict from a probe that failed at once (or after a version/runtime change, or 30 days); sequenced pacing hands frames the runtime frame they end in; Turbo stands aside for OpenXR Toolkit's Turbo above VectorXR.
  • Quadviews and eye tracking: emulated quad views place focus insets through canted eyes; a frozen focused gaze falls back to head focus.
  • OpenXR Toolkit and Quad-Views-Foveated: games start on VIVE runtimes (second instance passed through); Frame Generation stays off with Toolkit below VectorXR, and the OSD (“Off / Layer conflict with OpenXR Toolkit”) and the OpenXR Layers page now say so; Toolkit's prediction dampening is no longer undone.
  • Depth outside its image is left out of every session's frames instead of failing xrEndFrame on PimaxXR / Virtual Desktop.
  • Pivot: Duplicate button for custom profiles (copy inserted below its source, scrolled into view with a brief highlight); Pivot state resets when a session is destroyed without being ended.
  • Also on the branch, not in the release notes: Vulkan late-depth detection (Star Citizen PTU; off unless depth looks empty), a hidden edgeFill Frame Generation option (Direct3D 12, not in the app), more diagnostics, and CTest running suites side by side.

Version 0.20.1 in every Set-Version file; Assert-VersionMatchesTag.ps1 -TagName v0.20.1 passes.

Testing

  • All 48 CTest suites pass on the Release build of this layer code (Nov 8); the app's tests pass (150/150).
  • Flown on 0.20.1-flight2 (Nov 8, Pimax, RTX 5090):
    • DCS, Frame Generation, ~55 minutes: 0 errors, 0 Frame Generation failures, 90 fps output, clean exit.
    • DCS, Turbo Auto, ~65 minutes: async held (earlyProbeFailures=0), no TIME_INVALID; Hind in combat held the high 80s.
    • MechWarrior 5 (UEVR, Direct3D 11), Frame Generation with depth, ~11 minutes: depth used 87-100% once settled, 0 failures or errors, no artifacts seen, clean quit.
  • Not flown: iRacing (D16 depth, tests only), the OSD conflict line with a real OpenXR Toolkit install (bridge test only), the installer.
  • Known, not blocking: with depth mirrored, MW5 showed slower bridge hand-overs (6.4% over 2 ms vs ~1% in DCS without depth), likely waiting on the game's device lock; not felt in play. Candidate for 0.20.2 if a depth on/off A/B shows a frame-time cost.

🤖 Generated with Claude Code

mdiener87 and others added 30 commits November 2, 2026 11:12
PimaxXR's xrEndFrame holds its swapchain mutex while it waits for its
submission thread; with "Prefer framerate over latency" that is nearly a
whole refresh. With Frame Generation engaged the presenter sat in that
call, so the game's acquire/wait/release (same mutex) blocked, its GPU
went idle, and DCS fell from ~37 to ~17 fps. When the runtime's
xrEndFrame blocks for over half a refresh, the presenter now calls it
about 2 ms before the learned slot (VECTORXR_FRAMEGEN_END_HOLD=off
disables it; summary runtimeEndHeldMs).

A shown layer the game waits on each frame (OpenKneeboard, UI quads)
CPU-waited for the newest held-back release, the game's whole previous
frame, draining its GPU queue. Waits now hold back for images the
runtime is not showing and otherwise wait only for the oldest release.

Also: the Dynamic benefit guard stands down when engaging slows the
game's own rate; GPU-aware pacing ignores paused and stalled windows;
the bridge line logs gameCallsMs and sharedMemory.

Tests: Pimax-like stand-in compositor with PimaxXR's lock and real GPU
load (gpu-bound-dynamic-pimax and -quad; -plain is the control), runtime-queue
ShownLayerPipelinedWaitTest, presenter benefit-guard and paused-window
pacing tests. All but the control fail on v0.20.0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ait on PimaxXR and Virtual Desktop

With Frame Generation's queue substitution, every xrWaitSwapchainImage made
the game's queue wait for the runtime's queue (AfterWait), so anything the
runtime queued for the image ran before the game rendered into it again. The
runtime's queue also carries Frame Generation's own work: each frame written
just in time waits there for the game's last frame to be measured. Every
image wait therefore made the game's next frame wait for Frame Generation
(through the bridge's queue and its copy for a Direct3D 11 game, directly
for a Direct3D 12 one).

PimaxXR and Virtual Desktop's runtime queue work for an application image
on the session's queue only once: a barrier batch at the first
xrEnumerateSwapchainImages. Their xrAcquire/xrWaitSwapchainImage queue
nothing, and their compositors read the images on a device of their own
after a fence at xrEndFrame. On those runtimes (by name: the behaviour cannot
be seen from the layer) only each image's first wait now orders the game's
queue after the runtime's; other runtimes keep every wait ordered.
VECTORXR_FRAMEGEN_AFTER_WAIT=every keeps the old behaviour for an A/B, and
the session log says which applies.

FirstUseOrderingTest (runtime-queue tests) holds the runtime's queue on a
gate standing for a frame waiting for its measurement: with the old
ordering the game's queue stops behind it at the next image wait; with
first-use ordering it runs on, and a new swapchain's first wait still
waits. The bridge stand-in names itself PimaxXR in its PimaxXR case, which
now checks the log line, and prints Direct3D 11's waits for the bridge's
copies per frame.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a runtime whose eyes are turned from the head (a canted display: Pimax
without parallel projection), each eye's FOV is in that eye's
own frame. The emulated quad views took head-forward, the configured offsets
and the gaze as angles in each eye's frame, so each inset sat on its own
eye's optical axis: about 10 degrees outward per eye on a canted Pimax, the
two eyes' sharp regions covering different directions.

Head-forward plus offsets plus gaze is now a direction in VIEW, placed in
each eye through its turn from the head, as Quad-Views-Foveated's and
PimaxXR's ProjectPoint do. The eyes' turn comes from the locate itself
(nothing changes, and nothing extra is asked, when the two eyes look the same
way); when they are canted, the eyes relative to VIEW are Pivot's eye offsets
for the same display time (one stereo locate in VIEW per display time, shared
with Pivot, never kept across display times). The first canted session logs
each eye's yaw.

Test: head_prediction_layer "canted eyes place the inset through each eye"
(stand-in eyes turned 10 degrees outward; gaze 0, 8 and -15 degrees, in LOCAL
and VIEW): the left inset's centre was tan(0) = 0 where the direction falls
at tan(10) = 0.176, and now matches within 1e-4; parallel eyes keep tan(gaze)
with no extra locate.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The bridge hands the game's releases over at its xrEndFrame (and at an
acquire or wait that comes before it) and forwarded each to the runtime
with the layer's mutex_ held. A runtime swapchain call can stall: PimaxXR's
xrEndFrame holds its swapchain lock for most of a refresh, and with Frame
Generation engaged that xrEndFrame is called from Frame Generation's thread
while the game's thread forwards its releases. Every other game thread
calling into the layer (xrLocateViews, xrWaitFrame) then waited out the
same stall behind mutex_.

The hand-over now does the bridge's copies and Frame Generation's captures
under mutex_ as before, collects the releases due, lets mutex_ go while they
reach the runtime (ForwardHandedOverReleases), then takes it again for the
bookkeeping. A new bridge_handover_mutex_, taken before mutex_ in the game's
xrAcquire/xrWaitSwapchainImage and in a bridged session's xrEndFrame, keeps
another hand-over or swapchain call from coming between a hand-over and its
releases, so the runtime sees the calls in the same order as before.

New bridge case runtime-stall-outside-layer-lock: with the stand-in
PimaxXR's swapchain lock held for 400 ms while the game's xrEndFrame hands
its releases over, xrLocateViews on another thread took 436 ms before and
0.004 ms after.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
OpenXR Toolkit holds every swapchain release back until its next
xrEndFrame, then releases every swapchain it held whether that frame shows
it or not, and writes its upscaled image into the runtime's only for the
swapchains the frame shows. Its swapchain map is touched by acquire and
release without its frame lock. Below VectorXR it gets Frame Generation's
frames: several per game frame, from Frame Generation's own thread, most
of them showing none of the game's swapchains. They make it release the
game's images without its work (a later frame then writes the runtime's
image after the release) and race its map against the game's thread. The
layer only logged where the Toolkit was.

The Toolkit's position now also notes its per-application bypass when it
is below ("below-bypassed"). Below and not bypassed, Frame Generation is
off for the instance's sessions (no bridge, no queue of its own), with a
plain log line saying why and how to use it (move the Toolkit above
VectorXR, turn it off for the game, or set its bypass).

New bridge case toolkit-below-framegen-off: a session with the Toolkit
named below VectorXR stays as it is and the log says why; it was bridged
with Frame Generation on before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PimaxXR recenters (Pimax Play, its system button held, a key, and each
session's start) with pvr_recenterTrackingOrigin and never queues
XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING: its xrPollEvent produces
only session-state and interaction-profile events. Pivot dropped its seated
anchor only on that event, so after a Pimax recenter the camera orbited the
old point, off by however far the head had drifted.

Pivot's drive now compares the head with the previous drive's. A step
between two consecutive frames of more than 10 cm that is also faster than
3 m/s, or of more than 15 degrees that is also faster than 1000 deg/s, is
past what a head does (about 2 m/s and 600 deg/s at most) and is taken as a
recenter: it goes through the same re-anchoring as the runtime's event, and
is logged (first five). Drives under 1 ms or over 100 ms apart are not
judged, and a runtime that has sent the event itself (VDXR) is taken at its
word for the session. The origin's captured yaw is left as the event path
leaves it.

Test: pivot_pose. A silent recenter (36 cm and 30 degrees in one 11 ms frame)
kept the old anchor before ("A silent recenter ... must re-anchor" failed)
and re-anchors now, with and without a captured origin; a second of 600
deg/s and 2 m/s motion, the same jump across a 200 ms gap, and a runtime
that sends the event all keep the anchor.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Pivot's origin, seated anchor, pending recenters and engagement were reset
only at xrEndSession and xrDestroyInstance. An application that destroys a
running session without ending it (a VR toggle, a session restart) left them
for its next session, and PimaxXR and VDXR give that session the same handle
((XrSession)1) and free and reallocate its spaces, so the next LOCAL space
can come back at the old address: the stale anchor then matched it and Pivot
came back engaged with the old origin. xrDestroySession of the active session
now resets Pivot's activation state as xrEndSession does.

Test: pivot_pose. With an origin, an anchor and Pivot engaged, an
xrDestroySession without xrEndSession kept all three before and clears them
now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… state

PimaxXR keeps its session event queue across sessions (it is never cleared
at xrDestroySession or xrCreateSession) and stamps every event with the one
handle it gives each session. An application that ends and destroys a
session without reading the last events (STOPPING, IDLE, EXITING) gets them
in its next session, ahead of that session's own IDLE, and VectorXR took
them as the new session's state (eye gaze is gated on it).

VectorXR now notes the runtime's time just before xrCreateSession: a state
event stamped earlier is the previous session's and is not adopted (without
the runtime's clock, anything before the session's first IDLE is). It is
logged (first eight) and still reaches the application exactly as sent, so
"VR will not start a second time" reports on Pimax can be told apart.

Test: eye_gaze. With the session created at 1000, the previous session's
STOPPING/IDLE/EXITING (400-600) left the observed state EXITING before and
leave it unknown now; the session's own IDLE, READY and FOCUSED are taken,
and each stale event is logged. Without the clock, an EXITING before the
first IDLE is not taken.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A new stand-in case (OpenKneeboard's per-frame quad acquired, waited for,
drawn and released inside the game's xrEndFrame, on the PimaxXR stand-in)
showed the game stalling for over a second now and then with Frame
Generation engaged when only each image's first wait ordered the game's
queue after the runtime's: about 3 runs in 23, 4-9 fps engaged against 45
passing through, every fence of the bridge and the queue substitution done
meanwhile. With every wait ordered it never did (11 runs). The cause is
not found, so the ordering stays as it was by default and first-use
ordering is VECTORXR_FRAMEGEN_AFTER_WAIT=first, for an A/B on the headset.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…w many

Layers below VectorXR get every frame Frame Generation shows (two to four
for each of the game's, from its own thread) and, in a Direct3D 12 or
bridged session, its high-priority queue as the session's queue.
OpenKneeboard below VectorXR (likely after one of its updates) renders its
kneeboard into each of them and puts a GPU wait on a fence of
OpenKneeboard.exe on that queue: a fence that never comes stalls Frame
Generation, and through the image waits the game. The log only listed the
layers below at the instance's start.

When Frame Generation is on and layers are below VectorXR, the session now
logs that they get its frames and its queue, and that a layer there that
waits for something that never comes stalls the game (move it above).
At the session's end it logs how many frames the runtime and those layers
got for the game's. A GPU-side timeout is not possible (a Direct3D 12
queue wait cannot time out, and once the game's queue waits on the
runtime's it inherits any stall), so this is a log line, not a watchdog.

The bridge case gpu-bound-dynamic now has a forwarding layer below
VectorXR (named as OpenKneeboard's) and checks both lines: 277 frames for
the game's 244 over its run, passing through then engaged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…nd-in

OpenKneeboard above VectorXR acquires, waits for, draws and releases its
kneeboard's image inside the game's xrEndFrame every frame, after the
game's eyes are released (OpenXRKneeboard.cpp), not at the frame's start as
the quad case's game does. The DCS report had it on PimaxXR. The GPU-bound
Dynamic case now takes that order (gpu-bound-dynamic-kneeboard, and
gpu-bound-dynamic-pimax-kneeboard in the suite), and a PimaxXR variant of
the quad case (gpu-bound-dynamic-pimax-quad, on request).

With the 0.20.1 shown-layer fix the game keeps its rate: WARP, 45.0 fps
passing through, 41.2-43.6 engaged on PimaxXR (the kneeboard's acquire and
wait 4.6-7.1 ms a frame, the same one-frame-ahead gate as the eyes'), and
50.3 / 47.2 on the plain stand-in. The case's lines now also give the
game's xrWaitFrame and xrEndFrame times and its longest frame, and
BRIDGE_TEST_STALL_DUMP=1 prints the queues' state while a frame takes over
300 ms.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The silent-recenter check (f335da8) also took a turn of more than 15
degrees faster than 1000 deg/s as a recenter. Pivot's anchor is a position:
how far it is off after a recenter is how far the head jumped, and a turn
made at the anchor leaves it right. Instant turns, as the snap tests drive
them and as a game-side snap could look, then re-anchored Pivot and re-based
a stacked snap's motion: pivot_snap "Position Assist in check six" failed
(lean (0, 0, 0) instead of (0.1, 0, 0)). The check now uses the position
step alone (more than 10 cm and faster than 3 m/s); the log line gives that
step.

Tests: pivot_snap 32/32 (was 31/32 with f335da8); pivot_pose's silent
recenter, fast-motion, pause and event-runtime cases pass unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
xrLocateViews' view state was never checked. PimaxXR answers all or
nothing: before its first valid head pose it returns flags 0 and leaves the
views as they were (later it falls back to its last valid pose). VectorXR
still adjusted those views, cached them as a quad views frame and derived
eye offsets from them (Pivot's internal stereo locate in VIEW too); in
emulated quad views they were the zero-initialised stereo views.

LocateViews now returns the runtime's answer untouched when the view state
has no ORIENTATION_VALID bit; emulated quad views take no canted-eye turn
from such views, and the internal eye-offset locate keeps nothing it did not
get. The turbo_frame Varjo stand-in now reports its views as located, as a
runtime does.

Test: head_prediction_layer "views the runtime did not locate are left
alone": the quad frame for an unlocated display time was cached and
EnsureEyeOffsets kept zero offsets before; neither happens now, and located
views are cached as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…me alike

With head prediction past the runtime's limit, each xrLocateSpace of VIEW in
a world space (or the reverse) extended the head anew: three extra runtime
locates per call (on PimaxXR each a pvr_getTrackedDevicePoseState IPC), each
against a later "now". DCS locates VIEW several times a frame, so the same
display time got that work several times, and slightly different answers.

Each query (space, base space) now keeps the answer its first locate at a
display time got, for that display time only (a few kept, cleared with the
session): a repeat costs the runtime's own locate alone and returns the same
pose; the runtime's flags still come from that locate. A new display time is
extended afresh, so nothing carries across display times.

Test: head_prediction_layer "repeated space locates of one display time
answer the same": three repeats 4 ms apart cost 4 runtime locates each and
moved by 0.048 degrees before; now 1 each and bit-identical, and the next
display time is extended afresh (4 locates, a different answer).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
In native quad views with Eye tracking, an application that sends no
foveated-rendering request gets one from VectorXR, active only when the
runtime's COMBINED_EYE_VARJO space locates as tracked. PimaxXR 0.4.4 gives
that space ORIENTATION_TRACKED alone (no VALID bit) while its tracker has
gaze, and its locateSpace returns flags 0 for any pose that is not valid
(Pose::IsPoseValid needs both VALID bits: the flags it does set cannot pass
it). Located against VIEW it is therefore never tracked, and VectorXR asked
PimaxXR for its fixed focus on every frame, switching its working gaze
foveation off (its own default, prefer_foveated_rendering, is off too).

A locate that succeeds with no flags at all says nothing about gaze; on a
runtime other than Varjo's (whose combined eye always carries VALID bits)
VectorXR now asks for gaze foveation and leaves validity to the runtime,
which falls back to its fixed focus FOVs while it has no gaze. This is
logged once. Varjo keeps the tracked bit's answer, including for a flagless
locate.

Test: eye_gaze. A PimaxXR stand-in (locateSpace as in 0.4.4) got
foveatedRenderingActive = false before and true now; Varjo untracked, tracked
and flagless keep false, true, false.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PimaxXR (0.4.4, quad views on), for an application named "DCS World", keeps
the focus FOVs each quad xrLocateViews returns for its display time and shows
the focus views with those at xrEndFrame, not with the submitted ones (DCS
submits other ones). Two things VectorXR did broke that:

- Depth's convergence shifts every view's FOV in xrLocateViews. Without Depth
  Anchor the periphery is shown as rendered (the game submits the shifted
  FOVs), but PimaxXR showed the focus views with its own unshifted FOVs: the
  inset was off against the periphery by the convergence. In this case the
  focus views are now given the runtime's own FOVs (convergence stays on the
  periphery; logged once). With Depth Anchor all four are shown shifted back
  to the runtime's, which was already consistent.
- Pivot's eye offsets, when they cannot come from the views it recomposes,
  are located by VectorXR with the session's quad configuration at the game's
  display time and without the game's foveated-rendering request: PimaxXR
  replaced the game's entry with its fixed focus. Where the runtime's focus
  views sit at their eyes' poses (seen in the game's own locates; PimaxXR's
  do), the stereo configuration is located instead and gives the same offsets.

Varjo's runtime is not known to do this and keeps the old behaviour. The
submitted-focus diagnostic no longer says the runtime always places the
insets by the submitted FOVs.

Test: turbo_frame TestPimaxDcsFocusFovQuirk (a PimaxXR stand-in with the
quirk). Without Depth Anchor the focus view was shown 0.05 tangent off
against what was rendered while the periphery was not; now both match, and
with Depth Anchor both move by the same 0.05. Pivot's eye-offset locate made
a second quad locate at the game's time, replacing its gaze focus with the
fixed one; now the entry stays the game's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PimaxXR's Droolon / aSeeVR path keeps reporting its last gaze sample as
valid once the tracker service is ready, even if the service stops sending
(eye_tracking.cpp: m_droolonGaze stays, flags stay tracked). VectorXR only
caught a frozen gaze while the session was visible but unfocused; focused,
the inset stayed where the eyes last were.

While focused, a gaze that is bit-for-bit the same for 180 display times in
a row (about 2 s at 90 Hz, far past any fixation: live gaze jitters every
sample) is now taken as lost, logged once per episode, and Quadviews falls
back to head focus until it moves again. Repeated locates of one display
time are not counted.

The other Pimax gaze notes were checked and left as they are: PimaxXR's
eye-gaze pose and its own 0.4.4 quad-view path do have opposite vertical
signs, but VectorXR's emulated quad views read the eye-gaze pose, which is
the one PimaxXR kept (HEAD dropped its quad views for Quad-Views-Foveated,
which reads the same pose), and native quad views leave gaze to PimaxXR.
Nothing is flipped.

Test: eye_gaze. 181 frames of the same valid gaze (two locates each) were
all used before; now the 181st falls back, and a gaze that moves is used at
once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
OpenXR Toolkit and Quad-Views-Foveated create a probe instance through the
chain before the game's, and on a VIVE runtime ("Vive Reality system") they
never destroy it (their dispatch.cpp). VectorXR serves one instance and
returned XR_ERROR_LIMIT_REACHED for the next one, so with either above it on
a VIVE runtime the game's real instance failed and the game never started
in VR.

An instance created while VectorXR's is alive now goes straight through to
the layers below; its xrGetInstanceProcAddr hands out their functions,
except xrDestroyInstance, which forgets the handle before calling theirs
(a handle can come back), and xrGetInstanceProcAddr itself. The first
instance's log says so. VectorXR stays with its first instance, so its
features are off for a game in that setup, but the game starts.

Test: layer_load, a new round through the real DLL with a stand-in runtime:
the second instance got -10 (XR_ERROR_LIMIT_REACHED) before; now it is
created, its functions are the runtime's, it is destroyed in the runtime and
then forgotten, the first keeps the layer's functions, and the log line is
there.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With Quad-Views-Foveated above VectorXR (its installer puts it first), a
Direct3D 11 game's quad views are its own and VectorXR sees a stereo
application, while VectorXR's settings may still show Quadviews on. Support
could not tell from the log who did the quad views.

The layer now looks for XR_APILAYER_MBUCCHIA_quad_views_foveated (its
manifest's layer name and DLL name, from its solution and installer) below
it in the chain, or its DLL loaded above it, as it already does for OpenXR
Toolkit, and logs one line for either.

Test: layer_load names a layer below the layer
XR_APILAYER_MBUCCHIA_quad_views_foveated and finds "Quad-Views-Foveated is
loaded below VectorXR" in the log (absent before).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Frame Generation summary gave the runtime's xrEndFrame time
(runtimeEndMs) but nothing for its xrWaitFrame, so a log could not tell
PimaxXR's "Prefer framerate over latency" (defer_frame_wait: its xrWaitFrame
never waits and the whole refresh lands in xrEndFrame) from a caller that
merely comes late. The threaded summary now adds runtimeWaitMs
(median/max) and runtimeWaitsBlocked (waits that blocked at least
max(1 ms, a tenth of the period), the rule NotePhaseLocked uses, over the
waits made). With defer_frame_wait every wait returns at once (0/N).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
When nothing current can be shown (the frame last shown as it is has
newer images in its swapchains), the just-in-time presenter begins the
runtime frame and leaves it open, so the runtime shows its last frame
again. PimaxXR up to 0.4.4 does not: its submission thread completes the
PVR frame ID that was skipped with a single disabled layer and waits a
refresh more for it (pimax-openxr frame.cpp asyncSubmissionThread,
quirk_complete_discarded_frames), most likely a blank refresh. Virtual
Desktop's runtime has no such gap fill, and PimaxXR 0.4.5 repeats the
layers, so only those versions are affected.

On such a runtime (PimaxXR by name, version below 0.4.5, with
async_submission and quirk_complete_discarded_frames not turned off in
HKLM\SOFTWARE\PimaxXR), the presenter now shows the next frame the layer
composed whose images are still current, even past frames it writes: the
frame's own images and views, possibly a step back later, rather than a
blank refresh. Counted as staleShownAhead and logged once. The layer also
logs PimaxXR's frame settings once (defer_frame_wait,
quirk_sync_gpu_work_in_end_frame, async_submission,
quirk_complete_discarded_frames, quirk_disable_running_start,
lock_framerate; read only) so a log tells which frame loop the runtime ran.

TestQuadNoOpenFrameOnBlankingRuntime: quad views at 3x interpolate, frames
the layer composes alternating with claimed frames whose writes fail.
Before: 6 refreshes left open (3 of 3 runs). After: none, 2 shown with a
later frame, no step back, no image shown with another frame's views.
Still open: the few refreshes right after engaging, before anything is
written (no consistent content exists yet).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Frame Generation learns how many periods after its given display time a
game ends its frames (MSFS ends them a period later) and tells engaged
frames that much earlier. OpenXR Toolkit's prediction dampening above
VectorXR rewrites the game's display time to now + d * (time - now) and
never restores it at xrEndFrame (its layer.cpp, the restore is #if 0), so
frames end earlier than given. The learner took that as a negative offset
(up to a period) and told engaged frames a later time, undoing the
dampening the user set.

A frame ending for an earlier time than given now counts as no offset;
after 30 such frames one line says a layer above scales its predictions
down. MSFS's later ends are compensated as before.

TestDampenedEndsAreNotCompensated (threaded 2x, the game ending a game
period earlier, as given, and a period later): before, the dampened game
was told times 2.0 periods further ahead than one ending as given; now
the same; the MSFS-like game is still told two refreshes earlier.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
OpenXR Toolkit's Turbo mode (its layer.cpp xrEndFrame) calls the next
layer's xrWaitFrame on a pool thread as soon as each xrEndFrame returns,
hands the game a made-up time, and calls xrBeginFrame right before the
next xrEndFrame. With VectorXR's Turbo also on, the frames were pipelined
twice: more latency for nothing.

At each xrEndFrame the layer now notes the pattern: the wait on another
thread than the end, entered within 2 ms of the last xrEndFrame's return,
and the begin after it, less than 1 ms before the end. Sixty frames in a
row of that mark a layer above that pipelines already; Turbo stands aside
for the session (an established async pipeline is released, with that
reason) and says so once in the log. Games that wait on a thread of their
own begin before they render (DCS, MSFS), so they keep Turbo.

TestUpstreamToolkitTurboStandsAside (async pacing): Toolkit's call order
leaves Turbo inactive after 90 frames (failed before: Turbo stayed
engaged); a game that begins, renders 3 ms, then ends keeps it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ming quirks

Three behaviours from the runtime audit, modelled in the presenter tests'
runtime from their sources; Frame Generation already handles each, so
these pin it:

- OpenXR Toolkit's Turbo above VectorXR (TestToolkitTurboAbove, fixed 2x
  and Dynamic): xrWaitFrame from a pool thread right after each xrEndFrame,
  xrBeginFrame right before the next xrEndFrame, which waits for that wait
  for a second at most. Engaged throughout, nothing demoted, abandoned or
  paused, no wait held past the second, every refresh filled.
- PimaxXR clamping a PVR prediction that did not advance to 1 ns after the
  last (TestClampedDisplayTimes, Runtime::clamp_next; two such waits every
  20 frames): engaged, the clock not taken for stalled, the game's frames
  told times at least half a refresh apart, submissions in order.
- Pimax Smart Smoothing reporting the doubled period one wait late
  (frame duration set in xrBeginFrame; Runtime::period_one_late, a new case
  of TestRuntimeHalvingStandsDown): detected and stood down for as when the
  period is reported at once, and no two submissions for one refresh.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The stand-in's PimaxXR mode (PimaxCompositor, case
gpu-bound-dynamic-pimax) now also does what the runtime audit found in
pimax-openxr 0.4.4:

- xrWaitFrame blocks, with no timeout, until the frame waited before has
  begun (frame.cpp, m_frameCondVar), so a second wait from the thread that
  would begin would hang as on PimaxXR; a 2 s watchdog fails the case
  instead of the earlier order check.
- A begin over an open frame returns XR_FRAME_DISCARDED and costs a PVR
  frame with one disabled layer plus a refresh's wait more
  (asyncSubmissionThread); counted as blank refreshes and printed. The case
  asserts none while engaged (the few right after engaging remain; nothing
  consistent exists to show then).
- It names itself PimaxXR (Unofficial) 0.4.4, so the layer takes it for
  PimaxXR (settings line, open-frame handling); the case checks the log
  has PimaxXR's frame settings and the runtime wait summary.
- BRIDGE_TEST_PIMAX_CLAMP_EVERY=N: every Nth wait, two display times
  clamped to 1 ns after the last (frame.cpp xrWaitFrame).
- BRIDGE_TEST_PIMAX_SYNC_GPU=1: quirk_sync_gpu_work_in_end_frame,
  xrEndFrame waiting on the CPU for the session queue with its locks held.
  WARP, defer on/off: 21.3 fps passing through (the game's own xrEndFrame
  waits for its GPU), 29.6/30.0 engaged, game swapchain calls 1.8-2.2 ms
  on average (at most 32-36 ms): the end hold still keeps the lock short.

The plain stand-in keeps reporting success for a begin over an open frame.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On WARP the PimaxXR case failed about 3 runs in 8 when the quad case ran
right before it (main() ran it after the PimaxXR case as a workaround), and
a full suite run could also fail the plain case (8.5 fps engaged against
49.8). Cause: engaging sets Frame Generation's GPU work up on the game's
frame thread. Its Executes that make pipelines and views (on WARP about
180 ms, then 1.2-1.5 s, now and then a third) each hold one game frame;
the trace showed the 1.18 s between the game's end and its frame being
kept, while every fence had completed and the presenter kept presenting.
The rate was measured from 300 ms after engaging, so whether such a frame
fell in the 1.5 s window was down to timing. It was not state left by the
quad case, nor a stall in the bridge or the stand-in (the "488 ms"
swapchain call was that frame seen through PimaxXR's lock).

The cases now run 300 ms windows until two in a row keep three quarters
of the rate passing through (6 s at most), then measure as before: a game
slowed on every frame never settles and still fails. main() runs the cases
in their natural order again (plain, quad, PimaxXR).

WARP, full suite: 12 of 12 runs passed (engaged 46.4-49.2 / 47.5-48.5 /
39.8-44.0 fps against 49.6-50.4 / 49.7-50.4 / 45.0 passing through), where
the measurement before the change failed 1 of 12 (plain, 8.5 fps) even
with the order restored.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The test failed about 2 runs in 70 (4 and 7 of some 120 frames more than
two refreshes past the median lead). The failure dumps showed the
presenter's own lead (leadSlots) had moved during the window: lead probes,
and raises after frames late in hitches of the test's own threads; the
frames' measured leads followed it. The test checks the frames' timing
against the runtime's period echo (the bug it guards: 8-20% of frames up
to 9 refreshes off), not lead adaptation.

Each frame's measured lead is now taken less the presenter's lead change
(its lead when the frame ended, minus that lead's median). FG_TEST_STATS
prints the lead's moves in the window; a failure prints the leads.
(A presenter-side cause, frames passed over by the missed refresh scored
late, was tried and dropped: the lead moved as much without misses.)

50 runs of the test alone: 0 failures (2 in 70 before).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
# Conflicts:
#	layer/tests/d3d11_bridge_layer_tests.cpp
mdiener87 and others added 29 commits November 4, 2026 20:19
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
An Auto fallback can run from NoteTurboRuntimeFailure on the app's wait
or begin thread and reads TurboProbeGuard's engagement time (Early,
SinceEngaged). Its writes in ForwardEndFrame run under the config lock
the fallback also holds, but the session-end Reset does not. The two
times are now atomic nanosecond counts, so no read can tear, and the
frame path takes no extra lock.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Where Direct3D 12 cannot draw a frame into its output (the copy fallback),
the frame is copied in at its content offset and the margin keeps whatever
the image held, yet the view went out widened across it: stale pixels at
the edge on a head turn. The backend now says whether the last write drew
every margin (FrameGenGpu::EdgesFilled); where it did not, the presenter
shows that frame from its own region with the game's field of view, as
without edge fill. Real frames' copies and generated frames alike, inline
and just in time; the quad views compose draw always fills its margin.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…s call

NoteThread turned the game device's multithread protection on inside the
second thread's swapchain or frame call, holding the bridge's mutex (and,
from ReleaseCalled and FrameEnded, the layer's). SetMultithreadProtected
waits for the device's lock. In a colour-only session (DCS: no depth
mirrored, protection off), a thread at the start of a hand-over holds that
lock (StageReleases' context hold) and then needs the bridge's mutex: the
two deadlocked, at most once a session, at its start.

NoteThread now only records that protection is wanted. StageReleases, which
the layer calls before any lock of its own at xrEndFrame, an acquire, a wait
and a destroy, turns it on before taking the context or the bridge's mutex,
and notes its own thread first, so a second thread seen at that frame's end
is protected before the frame's Direct3D 11 calls. Until then a second
thread's calls are not serialized, as calls before it never were. The log
line is unchanged.

Tests: one thread enters the device's lock; a second thread then makes its
first call (ReleaseCalled); the holder waits up to 2 s for it, then calls
StageReleases. Both return, protection goes on in StageReleases, reported
once. Driven by events; a deadlock ends the test after 10 s. With
protection turned on inside NoteThread again, the second thread's call
never returns. The second-thread case now checks that the call itself
leaves protection off and the next StageReleases turns it on.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The depth timing check (d3f9c8d) ran on every Vulkan depth swapchain about
once a second, so every game's hand-over then carried a grid read beside
its release barrier, and an acquire read followed. That broke the Vulkan
bridge's recorded-QFOT check ("the release is one submission signalling
written", depth-stencil array), which guards that each hand-over is the
release barrier alone; the earlier runs passed only because
FG_TEST_NO_STALL=1 skips that case.

The check now runs only while Frame Generation finds the game's bridged
depth the same all over in its last depth check (FrameGenStatus::
depth_uniform: sent, readable, no varying cells in either eye, as Star
Citizen's), polled by the layer every 500 ms (VulkanBridge::
WantDepthTimingCheck), or while depth is taken late, or with
VECTORXR_VULKAN_BRIDGE_DEPTH_CHECK=always. A game whose depth arrives in
time submits exactly as before the check. Logged once when first wanted.

Tests: the bridge's suite in full without FG_TEST_NO_STALL (the QFOT case
included) passes; a new case shows Star Citizen's order unchecked while not
wanted (each hand-over one release submission, nothing at the acquire, the
runtime's depth zero), then taken late three frames after it is wanted. The
other late-depth cases and the layer's run with the check forced on.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…empty

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
BRIDGE_TEST_MT_PERF=1 (or `only`) runs a game-like Direct3D 11 workload
on a device of its own (no debug layer) with protection off, on, and on
with a second thread taking the device's lock as the bridge's releases
do, alternating in rounds: CPU submit time per frame, calls a second and
the added cost a call. A watchdog ends a run that stops making frames.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…text is used under them

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… upload

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…dge's mutex

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A Duplicate button beside Remove copies a custom Pivot profile with its
settings, bindings and Quick Views under fresh ids (the nudge set stays
shared), named "<name> Copy" and placed directly below its source, one
step lower in priority. The new card fades in, the page scrolls to it
when it is out of view (clear of the sticky header), and an accent ring
fades out over about a second; reduced motion jumps without animating.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Frame Generation stays off while OpenXR Toolkit is loaded below
VectorXR (fe25e7d), but the OSD showed a plain "Disabled", which reads as
the user's own setting, and only the log said why.

- OSD: while Frame Generation is asked for and kept off for that reason,
  its row reads "Off / Layer conflict with OpenXR Toolkit", with "Move
  OpenXR Toolkit above VectorXR in the VectorXR app" under it.
- App: the OpenXR Layers page warns, per registry slice, when OpenXR
  Toolkit is enabled below VectorXR while Frame Generation is in use (the
  Toolkit's per-game bypass is not visible to the app). 11 languages.

Test: d3d11_bridge_layer toolkit-below-framegen-off checks the OSD row.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Replace the draft with the release notes for everything on 0.20.1:
Direct3D 11 depth, the PimaxXR fixes, Turbo Auto's fairer async trial,
eye-tracking and quad views fixes, Duplicate for Pivot profiles and the
OpenXR Toolkit conflict notice. In-app patch notes match.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Direct3D 11 depth is on by default in 0.20.1 and has flown in one game.
If another game stutters, hangs or shows depth artifacts with it, users
had only VECTORXR_D3D11_BRIDGE_DEPTH=private. A per-profile switch now
gives them the way out from the app.

useGameDepth (on by default; stored only when off, absent means on in the
app and the layer, so a profile does not inherit off from the defaults):
- Frame Generation neither captures nor uses the game's depth.
- The Direct3D 11 and Vulkan bridges keep every depth swapchain private,
  as before 0.20.1: no copy, no multithread protection turned on for it,
  and the runtime gets no depth from them. Read when the session starts.
  The environment variables still apply, and win.
- Direct3D 12 games still send their depth to the runtime.

App: a checkbox under Frame Generation's advanced settings with the
restart mark, "Without game depth" in the Advanced summary, cleared by
Reset; 11 languages. Schema and usage guide describe it.

Tests: d3d11_bridge_layer private-depth-profile (depth private, the
game's protection left off, no per-swapchain error line; a forced
mismatch showed the case runs), config useGameDepth parsing, app
normalization. CTest 48/48, app 150/150.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The app's backend saves Frame Generation settings through its own
struct, which dropped useGameDepth: unticking Use game depth and saving
wrote nothing, and the layer kept using depth (MW5, Nov 8). The field is
now kept, written only when off, as in the app's model and the layer.

Test: the Frame Generation config round trip carries useGameDepth false
in a profile and leaves it out of the defaults. cargo test 59/59.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On hosted CI the default adapter is the Basic Render Driver, so
`depthxr_d3d11_bridge_tests hw` ran there and its new UEVR depth case
failed to read back Frame Generation's linear depth on it (PR #136 CI).
The suite now skips (77) when its `hw` adapter renders on the processor,
as the bridge layer tests and the other hardware suites do; the WARP run
of the same cases passed there. On the 5090 the hw run still passes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GitHub's release downloads answered 504 for vcpkg.exe on three PR #136
runs in a row (the file downloads fine elsewhere), failing the job before
anything was built. Both downloading steps now try up to five times,
20 s apart and longer each time, before failing; the release workflow
has the same step.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Retrying alone did not get vcpkg.exe past GitHub's 504s. After three
failed bootstraps the step now copies the runner image's own vcpkg tool
(VCPKG_INSTALLATION_ROOT) into the pinned registry and goes on; the
OpenXR loader still comes from the pinned registry, retried five times.
Step output goes to the console so it cannot turn a failed attempt into
a truthy result.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… runners

PR #136's CI failed again on GitHub release downloads (vcpkg.exe, then
DXC), and a passing run took about 35 minutes: 6 for the OpenXR loader,
11.5 building one project at a time, 14.5 running the tests.

- .github/actions/layer-dependencies: the pinned vcpkg registry, its
  vcpkg tool and OpenXR loader cached between runs (a hit downloads
  nothing), with the retries and the runner-tool fallback for a miss;
  shared by CI and the release workflow.
- layer/CMakeLists.txt: the Vulkan headers and DXC archives go through
  depthxr_cached_archive, downloaded once into DEPTHXR_DOWNLOAD_CACHE (CI,
  cached) or <build>/_downloads, retried five times and hash-checked;
  FetchContent extracts the cached file.
- Build-Layer.ps1: builds projects side by side (--parallel), and
  -Tests Cpu|Graphics runs one kind of test (CTest labels cpu and
  graphics on every layer test; graphics tests stay RUN_SERIAL).
- ci.yml: "App and layer CPU tests" and "Layer graphics tests" run at
  once; "App tests and build", the check master's ruleset requires,
  passes only when both do.

Locally: configure downloads both archives into build/_downloads; the
split lists 31 CPU and 17 graphics tests of 48.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The first two-runner CI run failed one timing check in the D3D11 bridge
layer tests (side-by-side Interpolate, "steady": 47 of 48 refreshes
showed Frame Generation's outputs, none counted unwritten or uncaptured).
It passed on every earlier CI run and three local runs in a row; the
case's layer log stayed on the runner. A failing graphics job now
uploads %TEMP%\vectorxr-*\logs for 14 days.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@mdiener87
mdiener87 merged commit 8fffa72 into master Nov 10, 2026
3 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant