diff --git a/.editorconfig b/.editorconfig index cdab4d9f..7e649dbc 100644 --- a/.editorconfig +++ b/.editorconfig @@ -263,6 +263,12 @@ resharper_cpp_if_can_be_replaced_by_constexpr_if_highlighting = none [src/native/{FrameLedger.Injector/src/fl_guard_sources.cpp,FrameLedger.ProcessStats/src/fl_process_stats.cpp,tools/fl-probe-guard/main.cpp,tests/vklayer_test.cpp}] resharper_cpp_declarator_never_used_highlighting = none +# fl::patch::Install takes its hook engine as a template parameter and calls Create / Enable / Disable on it. The +# test's two stand-in engines are used that way and no other, which ReSharper's "never used" does not follow through a +# dependent call: six reports, one per member (Qodana, 2026-11-12). The members are the test. +[src/native/tests/unhook_inline_test.cpp] +resharper_cpp_declarator_never_used_highlighting = none + # The linter's compiler, not the build's: NVAPI's header makes NvU32 `unsigned int` under clang and `unsigned long` # under MSVC, which is the compiler that builds this probe - and `%lu` is right for it. [src/native/tools/fl-probe-nvapi/main.cpp] diff --git a/CHANGELOG.md b/CHANGELOG.md index ede4d0ff..540162d7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -35,6 +35,13 @@ numeric core and does not move; the heading is the full version — corrected 20 ## [Unreleased] +### Added + +- **Advanced metrics: FSR's depth plane at infinity is shown as "∞".** Engines with an infinite depth range tell + FSR that one of the two camera planes is at infinity, and FrameLedger took that value for "not set" — so a + session's depth range showed one plane where the game had given two. The plane at infinity is now stored and + shown as such. Only for FSR, and only while Advanced metrics is on; nothing else about what is read changed. + ### Changed - **The Overlay's log is whole after a game exits, and says more.** The log FrameLedger's part inside the game diff --git a/docs/07_IPC.md b/docs/07_IPC.md index 89e595ab..ed2d2a2e 100644 --- a/docs/07_IPC.md +++ b/docs/07_IPC.md @@ -125,7 +125,7 @@ What the region is, as a contract between the two sides: inside on every attempt — a watchdog killed with its process leaves `seq` odd for good, and what it published before is still what the game said. - **Zero is "not read", never a value.** A Streamline `Boolean` and a DLSS preset are stored as the vendor's value - plus one; a float as its bits, with `FL_ADV_FLOAT_NONE` for "none seen" — the vendors' own sentinels are refused in + plus one; a float as its bits, with `FL_ADV_FLOAT_NONE` for "none seen" — and, in `ffxNearBits` / `ffxFarBits` alone, `FL_ADV_FLOAT_INFINITE` (`0x7F800000`, +infinity's own bits) for a plane at infinity *(0.1.0-beta.42, owner decision D119: an engine with an infinite depth hands FSR `FLT_MAX` or +infinity for one plane; for Streamline `FLT_MAX` is "not set" and stays refused)* — the vendors' own sentinels are refused in the detour and never reach the region; a size of 0 is "not given". - **A per-frame value is summarised where it is seen**: a flag is an "ever seen" mask, a jitter the largest magnitude, a field of view its lowest and highest (D114), the reported frame time a count and a sum the watchdog drains. diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 873ba6ea..a7d300a7 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -139,9 +139,11 @@ the traps — is [`handoff/history/0.1.0-beta.40.md`](handoff/history/0.1.0-beta [`handoff/history/0.1.0-beta.40.md`](handoff/history/0.1.0-beta.40.md) §NEXT lists (`kMaxPatches = 48`, the window of `sl::Constants` pinned outside the camera members, the per-call overhead, the gate's list for the two new structs): - - **`FLT_MAX` in an FSR depth plane.** Lies of P gave `cameraFar = 10` and no `cameraNear`; most likely the + - ~~**`FLT_MAX` in an FSR depth plane.** Lies of P gave `cameraFar = 10` and no `cameraNear`; most likely the plane at infinity is `FLT_MAX`, which the Overlay refuses as "nobody set this". Decide whether it is stored as - "infinite" — an Overlay change, with its overhead stated. + "infinite" — an Overlay change, with its overhead stated.~~ *(Decided, D119, and built in beta.42: + `FL_ADV_FLOAT_INFINITE`, shown "∞". Whether Lies of P's missing plane IS `FLT_MAX` is still the hypothesis it + was — item 40 reads it.)* - ~~**Valor Mortis.** One exit by access violation 51 seconds after injection under beta.40, none under an earlier build, not attributed. Its crash count is 1; a second such end switches its hooking off. Before adding a hook to that game's process, ask the owner whether it happened again.~~ **Answered by the owner, 2026-11-12: it was diff --git a/src/FrameLedger.Application/Capture/InGameAdvancedSampler.cs b/src/FrameLedger.Application/Capture/InGameAdvancedSampler.cs index f923bfa2..d30bf2b3 100644 --- a/src/FrameLedger.Application/Capture/InGameAdvancedSampler.cs +++ b/src/FrameLedger.Application/Capture/InGameAdvancedSampler.cs @@ -193,8 +193,8 @@ public sealed class InGameAdvancedSampler } var depth = new List(3); - AddNumber(depth, "cameraNear", s.FfxNearBits); - AddNumber(depth, "cameraFar", s.FfxFarBits); + AddDepthPlane(depth, "cameraNear", s.FfxNearBits); + AddDepthPlane(depth, "cameraFar", s.FfxFarBits); // A range, lowest to highest - never a series, which would say when the player aimed (D114). if (Number(s.FfxFovMinBits) is double low && Number(s.FfxFovMaxBits) is double high) { @@ -232,6 +232,19 @@ public sealed class InGameAdvancedSampler } } + // A depth plane of FSR's: a number, or the plane at infinity (owner decision D119) - which Number, rightly for every + // other field, takes for no value at all. + private static void AddDepthPlane(List rows, string member, uint bits) + { + if (bits == FlAdvancedState.FloatInfinite) + { + rows.Add(new AdvancedRow(member, "∞")); + return; + } + + AddNumber(rows, member, bits); + } + private static void AddNumber(List rows, string member, uint bits) { if (Number(bits) is double value) diff --git a/src/FrameLedger.Shared/ShmLayout.cs b/src/FrameLedger.Shared/ShmLayout.cs index f7dd8619..6931fe3c 100644 --- a/src/FrameLedger.Shared/ShmLayout.cs +++ b/src/FrameLedger.Shared/ShmLayout.cs @@ -755,13 +755,13 @@ public enum FlAdvancedValid : uint /// The game asked ffxQuery for the upscaler's memory, and it answered. FfxMemory = 1u << 2, - /// 0.1.0-beta.41: ffxConfigure with a frame-generation descriptor was seen. + /// 0.1.0-beta.43 (D118, D122): ffxConfigure with a frame-generation descriptor was seen. FfxFgConfig = 1u << 3, - /// 0.1.0-beta.41: slSetConstants was seen. + /// 0.1.0-beta.43 (D118, D122): slSetConstants was seen. SlConstants = 1u << 4, - /// 0.1.0-beta.42: at least one feature slot is filled. + /// 0.1.0-beta.44 (D118, D122): at least one feature slot is filled. SlFeatures = 1u << 5, } @@ -788,6 +788,14 @@ public unsafe struct FlAdvancedState /// A float nobody saw: the bits no detour stores. public const uint FloatNone = 0xFFFFFFFFu; + /// + /// The plane at infinity (0.1.0-beta.42, owner decision D119): +infinity's own bits, in + /// or and in no other field. An engine with an infinite depth hands FSR + /// FLT_MAX or +infinity for one plane; the Overlay stores either as this. Never from Streamline, whose + /// FLT_MAX is "not set". + /// + public const uint FloatInfinite = 0x7F800000u; + /// How many feature slots holds. public const int FeatureSlots = 12; @@ -942,7 +950,7 @@ public unsafe struct FlAdvancedState /// Must be zero. public fixed uint ReservedSl[3]; - /// slots of words each (0.1.0-beta.42). + /// slots of words each (0.1.0-beta.44). public fixed uint Features[FeatureSlots * FeatureWords]; } diff --git a/src/native/FrameLedger.Overlay/include/fl_adv_fields.h b/src/native/FrameLedger.Overlay/include/fl_adv_fields.h index 5c201ed5..8f8033c0 100644 --- a/src/native/FrameLedger.Overlay/include/fl_adv_fields.h +++ b/src/native/FrameLedger.Overlay/include/fl_adv_fields.h @@ -57,6 +57,18 @@ inline bool Usable(float v) noexcept { return (std::bit_cast(v) & 0x7FFFFFFFu) < 0x7F7FFFFFu; } +// A depth plane as FSR is handed one (owner decision D119): an ordinary value as its bits; FLT_MAX or +infinity -- +// how an engine with an infinite depth says "this plane is at infinity" -- as FL_ADV_FLOAT_INFINITE; anything else +// (a NaN, a negative infinity, -FLT_MAX) as "no value". FOR THE ffx ROUTE ONLY: Streamline's INVALID_FLOAT is +// FLT_MAX and means nobody set it, which is why Usable refuses it everywhere else. +inline uint32_t FfxDepthPlaneBits(float v) noexcept { + const uint32_t bits = std::bit_cast(v); + if (Usable(v)) { + return bits; + } + return bits == 0x7F7FFFFFu || bits == FL_ADV_FLOAT_INFINITE ? FL_ADV_FLOAT_INFINITE : FL_ADV_FLOAT_NONE; +} + inline float Magnitude(float v) noexcept { return std::bit_cast(std::bit_cast(v) & 0x7FFFFFFFu); } @@ -237,11 +249,12 @@ inline void ObserveFfxUpscale(uint32_t leaf, const ffxDispatchDescUpscale& d, Ac KeepMax(a.ffxPreExposureMaxBits, d.preExposure); } - if (Usable(d.cameraNear)) { - a.ffxNearBits.store(std::bit_cast(d.cameraNear), std::memory_order_relaxed); + // The two depth planes, the last of each; one of them may be at infinity (D119). + if (const uint32_t nearBits = FfxDepthPlaneBits(d.cameraNear); nearBits != FL_ADV_FLOAT_NONE) { + a.ffxNearBits.store(nearBits, std::memory_order_relaxed); } - if (Usable(d.cameraFar)) { - a.ffxFarBits.store(std::bit_cast(d.cameraFar), std::memory_order_relaxed); + if (const uint32_t farBits = FfxDepthPlaneBits(d.cameraFar); farBits != FL_ADV_FLOAT_NONE) { + a.ffxFarBits.store(farBits, std::memory_order_relaxed); } // The field of view as a range (owner decision D114): the lowest and the highest, never a series. if (Usable(d.cameraFovAngleVertical) && d.cameraFovAngleVertical > 0.0f) { diff --git a/src/native/FrameLedger.Shm/include/fl_shm.h b/src/native/FrameLedger.Shm/include/fl_shm.h index e32977f9..48655b33 100644 --- a/src/native/FrameLedger.Shm/include/fl_shm.h +++ b/src/native/FrameLedger.Shm/include/fl_shm.h @@ -932,18 +932,30 @@ struct alignas(64) FlDisplayState { // FlAdvancedState.validMask: which groups below were ever read. Additive: a reader ignores a bit it does not know. enum FlAdvancedValid : uint32_t { - FL_ADV_VALID_DLSS_OPTIONS = 1u << 0, // sl::DLSSOptions seen chained into slEvaluateFeature's inputs - FL_ADV_VALID_FFX_UPSCALE = 1u << 1, // an ffx upscale dispatch's extra fields were read - FL_ADV_VALID_FFX_MEMORY = 1u << 2, // the game asked ffxQuery for the upscaler's memory, and it answered - FL_ADV_VALID_FFX_FG_CONFIG = 1u << 3, // (0.1.0-beta.41) ffxConfigure with a frame-generation descriptor seen - FL_ADV_VALID_SL_CONSTANTS = 1u << 4, // (0.1.0-beta.41) slSetConstants seen - FL_ADV_VALID_SL_FEATURES = 1u << 5, // (0.1.0-beta.42) at least one feature slot filled + FL_ADV_VALID_DLSS_OPTIONS = 1u << 0, // sl::DLSSOptions seen chained into slEvaluateFeature's inputs + FL_ADV_VALID_FFX_UPSCALE = 1u << 1, // an ffx upscale dispatch's extra fields were read + FL_ADV_VALID_FFX_MEMORY = 1u << 2, // the game asked ffxQuery for the upscaler's memory, and it answered + // The release numbers on the three groups below moved twice (owner decisions D118 and D122, 2026-11-12): beta.41 + // was a fix release and the second step became two. They are declared here and written by nothing until then. + FL_ADV_VALID_FFX_FG_CONFIG = 1u << 3, // (0.1.0-beta.43) ffxConfigure with a frame-generation descriptor seen + FL_ADV_VALID_SL_CONSTANTS = 1u << 4, // (0.1.0-beta.43) slSetConstants seen + FL_ADV_VALID_SL_FEATURES = 1u << 5, // (0.1.0-beta.44) at least one feature slot filled }; -// A float nobody saw. An all-ones pattern is a NaN no detour stores: every value is checked finite first. +// A float nobody saw. An all-ones pattern is a NaN no detour stores: every value is checked finite first -- with the +// one exception below. #define FL_ADV_FLOAT_NONE 0xFFFFFFFFu -// Feature slots (0.1.0-beta.42): FL_ADV_FEATURE_SLOTS slots of FL_ADV_FEATURE_WORDS uint32 each, in `features`. +// THE PLANE AT INFINITY (0.1.0-beta.42, owner decision D119): +infinity's own bits, in ffxNearBits or ffxFarBits and +// in no other field. An engine with an inverted, infinite depth hands FSR one finite plane and FLT_MAX -- or +// +infinity -- for the other; three of the first four FSR titles read gave `cameraFar` alone (10, 1, 0.1), the other +// plane having been refused as "nobody set this". For FSR that reading is wrong: its FLT_MAX is a plane, not a +// sentinel. For Streamline it is right -- INVALID_FLOAT is FLT_MAX -- so this is the ffx route's alone. Stored as +// the real +infinity rather than as a second all-ones-like pattern, so that a reader which knows nothing of this +// constant still decodes a float that means what it says. +#define FL_ADV_FLOAT_INFINITE 0x7F800000u + +// Feature slots (0.1.0-beta.44): FL_ADV_FEATURE_SLOTS slots of FL_ADV_FEATURE_WORDS uint32 each, in `features`. // [0] sl::Feature id PLUS ONE; 0 = an empty slot // [1] bit 0: slGetFeatureVersion answered; bit 1: slGetFeatureRequirements answered // [2..4] versionSL major, minor, build [5..7] versionNGX @@ -988,7 +1000,7 @@ struct alignas(64) FlAdvancedState { uint32_t ffxJitterMaxYBits; // @148 uint32_t ffxPreExposureMinBits; // @152 uint32_t ffxPreExposureMaxBits; // @156 - uint32_t ffxNearBits; // @160 cameraNear, the last one seen + uint32_t ffxNearBits; // @160 cameraNear, the last one seen; FL_ADV_FLOAT_INFINITE = at infinity uint32_t ffxFarBits; // @164 uint32_t ffxFovMinBits; // @168 cameraFovAngleVertical, radians: the lowest and the highest (D114) uint32_t ffxFovMaxBits; // @172 @@ -1001,15 +1013,15 @@ struct alignas(64) FlAdvancedState { uint64_t ffxMemoryTotalBytes; // @192 FfxApiEffectMemoryUsage, as the last answered query gave it uint64_t ffxMemoryAliasableBytes; // @200 uint32_t ffxMemoryQueries; // @208 answered memory queries (wraps) - uint32_t ffxFgConfigures; // @212 (beta.41) ffxConfigure calls with a frame-generation descriptor - uint32_t ffxFgEnabledSeen; // @216 (beta.41) bit 0: seen off; bit 1: seen on - uint32_t ffxFgAsyncSeen; // @220 (beta.41) allowAsyncWorkloads, the same two bits - uint32_t ffxFgOnlyGeneratedSeen; // @224 (beta.41) onlyPresentGenerated, the same two bits - uint32_t ffxFgFlagsSeen; // @228 (beta.41) every dispatch flag any configure carried - int32_t ffxFgRect[4]; // @232..247 (beta.41) generationRect: left, top, width, height - the last + uint32_t ffxFgConfigures; // @212 (beta.43) ffxConfigure calls with a frame-generation descriptor + uint32_t ffxFgEnabledSeen; // @216 (beta.43) bit 0: seen off; bit 1: seen on + uint32_t ffxFgAsyncSeen; // @220 (beta.43) allowAsyncWorkloads, the same two bits + uint32_t ffxFgOnlyGeneratedSeen; // @224 (beta.43) onlyPresentGenerated, the same two bits + uint32_t ffxFgFlagsSeen; // @228 (beta.43) every dispatch flag any configure carried + int32_t ffxFgRect[4]; // @232..247 (beta.43) generationRect: left, top, width, height - the last uint32_t reservedFfx[2]; // @248..255 must be zero - // ---- line 4: sl::Constants, summarised (beta.41) - never the camera's position, axes or matrices ----------- + // ---- line 4: sl::Constants, summarised (beta.43) - never the camera's position, axes or matrices ----------- uint32_t slConstantsCalls; // @256 slSetConstants calls, every viewport together (wraps) uint32_t slResets; // @260 calls with `reset` true uint32_t slJitterMaxXBits; // @264 @@ -1027,7 +1039,7 @@ struct alignas(64) FlAdvancedState { uint32_t slFlagsSeenFalse; // @304 uint32_t reservedSl[3]; // @308..319 must be zero - // ---- lines 5..22: Streamline's features (beta.42) -------------------------------------------------------------- + // ---- lines 5..22: Streamline's features (beta.44) -------------------------------------------------------------- uint32_t features[FL_ADV_FEATURE_SLOTS * FL_ADV_FEATURE_WORDS]; // @320..1471 }; diff --git a/src/native/tests/ffx_types_test.cpp b/src/native/tests/ffx_types_test.cpp index 5a399eb3..71b9e29e 100644 --- a/src/native/tests/ffx_types_test.cpp +++ b/src/native/tests/ffx_types_test.cpp @@ -113,6 +113,7 @@ TEST_CASE("threads that meet the same new types at once keep each exactly once", for (int round = 0; round < 200; ++round) { fl::ffxtypes::Seen seen; std::vector threads; + threads.reserve(8); for (int t = 0; t < 8; ++t) { threads.emplace_back([&seen, t] { for (int i = 0; i < 6; ++i) { diff --git a/src/native/tests/guard_test.cpp b/src/native/tests/guard_test.cpp index 83bb421f..d803d7c3 100644 --- a/src/native/tests/guard_test.cpp +++ b/src/native/tests/guard_test.cpp @@ -6835,7 +6835,7 @@ uint32_t BitsOf(float v) { return std::bit_cast(v); } -// What 0.1.0-beta.41 and beta.42 fill: declared now, written by nothing in this release. +// What 0.1.0-beta.43 and beta.44 fill (beta.41 and beta.42 until D118 and D122): declared, written by nothing yet. bool LaterGroupsAreZero(const fl::FlAdvancedState& a) { bool zero = a.ffxFgConfigures == 0u && a.ffxFgEnabledSeen == 0u && a.ffxFgFlagsSeen == 0u && a.slConstantsCalls == 0u && a.slResets == 0u && a.slFlagsSeenTrue == 0u && a.slFlagsSeenFalse == 0u; @@ -6942,6 +6942,42 @@ TEST_CASE("region 5 stays empty until the Agent asks, then carries what an FSR t CHECK(r.st->status == fl::FL_STATUS_READY); } +TEST_CASE("FSR's plane at infinity (beta.42, D119): a far plane of FLT_MAX reaches region 5 as +infinity, beside " + "the finite near plane", + "[guard][inject][shm][advanced]") { + // An engine with an infinite depth hands FSR FLT_MAX for one plane. The Overlay took that for Streamline's "not + // set" and dropped it, so three real titles showed one plane of two. Through the shipped DLL, on the SDK 1.1.x + // monolith: the same target as the case above, with the far plane at infinity. + Child child; + REQUIRE(StartHarness(child, L"--real --ffx-topology 1x --advanced --ffx-infinite-far --hold-presenting-ffx 30")); + + ResetFake(); + g.modules = {"kernel32.dll"}; + g.scanSet = {child.pi.dwProcessId}; + REQUIRE(GuardedInjectWithSources(child.pi.dwProcessId, FL_OVERLAY_DLL, FakeSources()).Allowed()); + + MappedRing r; + REQUIRE(OpenRingFor(child.pi.dwProcessId, r)); + if (r.st == nullptr || r.ctl == nullptr) { + return; // not reached after the REQUIRE; said in the form a static analyser follows (cpp:S2259) + } + REQUIRE(WaitForIdentityHook(r.st)); + + SetAdvancedRequest(r, 11u); + fl::FlAdvancedState a{}; + REQUIRE(ReadAdvanced(r, 11u, a, 0u, fl::FL_ADV_VALID_FFX_UPSCALE)); + INFO("near 0x" << std::hex << a.ffxNearBits << " far 0x" << a.ffxFarBits); + CHECK(a.ffxFarBits == FL_ADV_FLOAT_INFINITE); + CHECK(std::bit_cast(a.ffxFarBits) > 3.0e38f); // the float it decodes to IS infinity + CHECK(a.ffxNearBits == BitsOf(kAdvFfxNear)); + // And nothing else of the descriptor took the pattern. + CHECK(a.ffxPreExposureMaxBits == BitsOf(kAdvFfxPreExposure)); + CHECK(a.ffxFovMaxBits == BitsOf(kAdvFfxFovHigh)); + CHECK(a.ffxSharpnessMaxBits == BitsOf(kAdvFfxSharpness)); + CHECK(r.st->faultCount == 0u); + CHECK(r.st->status == fl::FL_STATUS_READY); +} + TEST_CASE("region 5 carries the DLSS options a title chains into its evaluation, and only while asked", "[guard][inject][shm][advanced]") { Child child; diff --git a/src/native/tools/hook-harness/main.cpp b/src/native/tools/hook-harness/main.cpp index 1e86da29..bd8708e1 100644 --- a/src/native/tools/hook-harness/main.cpp +++ b/src/native/tools/hook-harness/main.cpp @@ -116,6 +116,9 @@ // sl::DLSSOptions into slEvaluateFeature's inputs, --hold-presenting-ffx fills the rest of the // UPSCALE descriptor (sharpening, jitter, exposure, depth range, field of view, flags, frame time). // The values are the kAdv* constants below; the injected fl_guard cases assert them +// --ffx-infinite-far +// with --advanced: the UPSCALE descriptor's cameraFar is FLT_MAX, as an engine with an infinite +// depth states the plane at infinity (0.1.0-beta.42, D119), instead of kAdvFfxFar // --ffx-memory-query v1|v2 // before every UPSCALE, ask the entry module ffxQuery how much memory the upscaler holds, in // the descriptor of ffx-api 1.1.2 (v1) or 2.0 (v2); the stub answers kAdvMemory* @@ -2159,6 +2162,60 @@ bool ProbeAdvFields() { Check(off.ffxFlagsSeen.load() == 0u && off.ffxResets.load() == 0u, "nothing is invented"); } + // --- FSR's plane at infinity (0.1.0-beta.42, owner decision D119) + // ------------------------------------------------- + { + const float flatMax = std::bit_cast(0x7F7FFFFFu); + const float plusInf = std::bit_cast(0x7F800000u); + Check(fl::adv::FfxDepthPlaneBits(0.1f) == bitsOf(0.1f) && fl::adv::FfxDepthPlaneBits(0.0f) == bitsOf(0.0f), + "an ordinary plane is its own bits"); + Check(fl::adv::FfxDepthPlaneBits(flatMax) == FL_ADV_FLOAT_INFINITE && + fl::adv::FfxDepthPlaneBits(plusInf) == FL_ADV_FLOAT_INFINITE, + "FLT_MAX and +infinity are the plane at infinity"); + Check(fl::adv::FfxDepthPlaneBits(std::bit_cast(0x7FC00000u)) == FL_ADV_FLOAT_NONE && + fl::adv::FfxDepthPlaneBits(std::bit_cast(0xFF800000u)) == FL_ADV_FLOAT_NONE && + fl::adv::FfxDepthPlaneBits(std::bit_cast(0xFF7FFFFFu)) == FL_ADV_FLOAT_NONE, + "a NaN, a negative infinity and -FLT_MAX are no plane"); + Check(std::bit_cast(static_cast(FL_ADV_FLOAT_INFINITE)) > flatMax, + "the stored pattern IS +infinity, so a reader that never heard of it still reads a float that means it"); + + // Lies of P's shape: an inverted, infinite depth -- the far plane a small number, the near one FLT_MAX. + fl::adv::Accumulators a; + ffxDispatchDescUpscale d{}; + d.cameraNear = flatMax; + d.cameraFar = 10.0f; + fl::adv::ObserveFfxUpscale(0u, d, a); + Check(a.ffxNearBits.load() == FL_ADV_FLOAT_INFINITE && a.ffxFarBits.load() == bitsOf(10.0f), + "the plane at infinity is kept beside the finite one -- it used to be dropped"); + // ...and the other way round, as +infinity; then a NaN changes nothing that was kept. + d.cameraNear = 0.05f; + d.cameraFar = plusInf; + fl::adv::ObserveFfxUpscale(0u, d, a); + Check(a.ffxNearBits.load() == bitsOf(0.05f) && a.ffxFarBits.load() == FL_ADV_FLOAT_INFINITE, + "either plane may be the infinite one, and the last value of each is what is kept"); + d.cameraNear = std::bit_cast(0x7FC00000u); + d.cameraFar = std::bit_cast(0xFF800000u); + fl::adv::ObserveFfxUpscale(0u, d, a); + Check(a.ffxNearBits.load() == bitsOf(0.05f) && a.ffxFarBits.load() == FL_ADV_FLOAT_INFINITE, + "a plane that is no plane leaves the last one in place"); + + // THE STREAMLINE ROUTE IS UNCHANGED: there FLT_MAX is INVALID_FLOAT, nobody's value. + fl::adv::Accumulators s; + sl::DLSSOptions o; + o.preExposure = sl::INVALID_FLOAT; + o.exposureScale = plusInf; + fl::adv::ObserveDlssOptions(o, s); + Check(s.dlssPreExposureBits.load() == FL_ADV_FLOAT_NONE && s.dlssExposureScaleBits.load() == FL_ADV_FLOAT_NONE, + "for Streamline FLT_MAX stays 'not set' and an infinity stays no value: the rule is the ffx route's"); + d.preExposure = flatMax; + d.cameraFovAngleVertical = plusInf; + fl::adv::Accumulators other; + fl::adv::ObserveFfxUpscale(0u, d, other); + Check(other.ffxPreExposureMaxBits.load() == FL_ADV_FLOAT_NONE && + other.ffxFovMaxBits.load() == FL_ADV_FLOAT_NONE, + "an exposure or a field of view of FLT_MAX or infinity is still no value"); + } + // --- the ffx upscaler's memory, both query versions // ------------------------------------------------------------------ { @@ -3021,6 +3078,9 @@ void AskQuality(PfnFfxQuery query, FfxQuery what) { } } +// --ffx-infinite-far (with --advanced): cameraFar is FLT_MAX rather than kAdvFfxFar. +bool g_ffxInfiniteFar = false; + int HoldPresentingFfx(Gfx& g, int seconds, bool real, int presentsPerEval, FfxTopology topology, bool prepare, FfxQuery ask, bool advanced, FfxMemoryQuery askMemory) { if (!HaveD3D11(g, "--hold-presenting-ffx")) { @@ -3143,7 +3203,8 @@ int HoldPresentingFfx(Gfx& g, int seconds, bool real, int presentsPerEval, FfxTo up.sharpness = kAdvFfxSharpness; up.preExposure = kAdvFfxPreExposure; up.cameraNear = kAdvFfxNear; - up.cameraFar = kAdvFfxFar; + // --ffx-infinite-far: the plane at infinity as an engine with an infinite depth states it (D119). + up.cameraFar = g_ffxInfiniteFar ? std::bit_cast(0x7F7FFFFFu) : kAdvFfxFar; up.frameTimeDelta = kAdvFfxFrameTimeMs; up.flags = FFX_UPSCALE_FLAG_NON_LINEAR_COLOR_PQ; } @@ -3418,6 +3479,8 @@ int main(int argc, char** argv) { ffxQuery = std::strcmp(q, "sizes") == 0 ? FfxQuery::Sizes : std::strcmp(q, "ratios") == 0 ? FfxQuery::Ratios : FfxQuery::None; + } else if (std::strcmp(argv[i], "--ffx-infinite-far") == 0) { + g_ffxInfiniteFar = true; } else if (std::strcmp(argv[i], "--advanced") == 0) { advancedInputs = true; } else if (std::strcmp(argv[i], "--ffx-memory-query") == 0 && i + 1 < argc) { @@ -3464,7 +3527,7 @@ int main(int argc, char** argv) { std::strcmp(argv[i], "--ffx-topology") == 0 || std::strcmp(argv[i], "--ffx-no-prepare") == 0 || std::strcmp(argv[i], "--ffx-query") == 0 || std::strcmp(argv[i], "--sl-tag-for-frame") == 0 || std::strcmp(argv[i], "--advanced") == 0 || std::strcmp(argv[i], "--ffx-memory-query") == 0 || - std::strcmp(argv[i], "--sl-tag-whole-resource") == 0 || + std::strcmp(argv[i], "--ffx-infinite-far") == 0 || std::strcmp(argv[i], "--sl-tag-whole-resource") == 0 || std::strcmp(argv[i], "--sl-tag-dlssg-inputs") == 0 || std::strcmp(argv[i], "--load") == 0 || std::strcmp(argv[i], "--load-after-ms") == 0) { if (std::strcmp(argv[i], "--plus-ui") == 0 || std::strcmp(argv[i], "--present-interval-ms") == 0 || diff --git a/tests/FrameLedger.Application.Tests/Capture/InGameAdvancedSamplerTests.cs b/tests/FrameLedger.Application.Tests/Capture/InGameAdvancedSamplerTests.cs index 48a9b259..5cbd8a65 100644 --- a/tests/FrameLedger.Application.Tests/Capture/InGameAdvancedSamplerTests.cs +++ b/tests/FrameLedger.Application.Tests/Capture/InGameAdvancedSamplerTests.cs @@ -96,6 +96,46 @@ public sealed class InGameAdvancedSamplerTests sampler.Facts.Should().NotContain(static f => f.Id.StartsWith("sl.", StringComparison.Ordinal)); } + [Fact] + public void AnFsrDepthPlaneAtInfinityIsShownAsInfiniteAndInNoOtherFieldIsInfinityAValue() + { + // Owner decision D119: an engine with an infinite depth hands FSR FLT_MAX for one plane, and the Overlay + // stores that as +infinity's own bits. Lies of P's shape: the far plane a small number, the near one at + // infinity. + var sampler = new InGameAdvancedSampler(); + sampler.Take(new InGameAdvanced(InGameStates.Ffx() with + { + FfxNearBits = FlAdvancedState.FloatInfinite, + FfxFarBits = BitConverter.SingleToUInt32Bits(10f), + })); + + Rows(Fact(sampler, "ffx.upscale.depth")).Should().StartWith(["cameraNear=∞", "cameraFar=10"]); + + // The other way round, in the same session: the fact follows what the game says now. + sampler.Take(new InGameAdvanced(InGameStates.Ffx(2) with + { + FfxNearBits = BitConverter.SingleToUInt32Bits(0.05f), + FfxFarBits = FlAdvancedState.FloatInfinite, + })); + Rows(Fact(sampler, "ffx.upscale.depth")).Should().StartWith(["cameraNear=0.05", "cameraFar=∞"]); + + // Infinity is a depth plane's value and nobody else's: an exposure or a jitter carrying the pattern is, as + // before, no value - the Overlay never stores it there, and a reader does not invent a meaning for it. + var other = new InGameAdvancedSampler(); + other.Take(new InGameAdvanced(InGameStates.Ffx() with + { + FfxPreExposureMinBits = FlAdvancedState.FloatInfinite, + FfxPreExposureMaxBits = FlAdvancedState.FloatInfinite, + FfxJitterMaxXBits = FlAdvancedState.FloatInfinite, + FfxJitterMaxYBits = FlAdvancedState.FloatInfinite, + FfxNearBits = FlAdvancedState.FloatNone, + FfxFarBits = 0xFF800000u, + })); + other.Facts.Should().NotContain(static f => f.Id == "ffx.upscale.exposure" || f.Id == "ffx.upscale.jitter"); + Rows(Fact(other, "ffx.upscale.depth")).Should().OnlyContain(static row => row.StartsWith("cameraFov", StringComparison.Ordinal), + "a plane nobody gave and a negative infinity are not planes"); + } + [Fact] public void SharpeningSeenBothWaysARangeAndAFlagNobodyNamedAreSaidAsTheyAre() {