Repository navigation
Merged
Conversation
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
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>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
VectorXR 0.20.1. Release notes:
release/notes/v0.20.1.md(also in the app's patch notes).What's in it
VECTORXR_D3D11_BRIDGE_DEPTH=privatestill works machine-wide (documented indocs/usage.md).xrEndFrameon PimaxXR / Virtual Desktop.edgeFillFrame 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.1passes.Testing
0.20.1-flight2(Nov 8, Pimax, RTX 5090):earlyProbeFailures=0), noTIME_INVALID; Hind in combat held the high 80s.🤖 Generated with Claude Code