ayo
a617c818de
network natively on HIP with Vulkan->HIP shared memory, extend K kernels to
gfx11 (RDNA3), and add dependency/packaging/test tooling around them.
Windows: FSR RR backend, native HIP K runner, gfx11 K kernels, tooling
FSR Ray Regeneration (experimental)
- Add fsr_rr_backend.{h,cpp}, fsr_rr_passes.h and the fsr_rr/ prepare and
compose compute shaders. They run AMD's FidelityFX denoiser
(amd_fidelityfx_denoiser_dx12.dll, SDK 2.3, not bundled) on a private
vkd3d-proton device.
- Add the amdxc64 shim (tools/windows/amdxc64_shim) and two vkd3d-proton
patches for libcxx includes. AMD's amdxc64.dll is never loaded.
- d4r_nvngx_windows: RrFeature now selects between the native DLSS RR
backend and the FSR backend (D4R_RR_BACKEND=fsr). After the denoiser it
runs an internal Super Sampling stage (feature 1) to upscale. If SR is
unavailable and output != render size, the frame fails; it is never
returned noisy.
- d4r.ini / player_config: new [RayReconstruction] FsrDenoiser,
FsrStabilityBias (auto or >= 0) and FsrDetail (0-1), with validation, and
matching D4R_FSR_* environment variables.
- Add the FSR RR fixture, output-check and ngx test scripts, and a shader
compile script.
Native HIP K runner (Windows)
- CMake: add d4r_engine_k_hip (d4r-k-hip) plus separate volk/engine copies,
because VK_USE_PLATFORM_WIN32_KHR changes volk's entry points.
- Share Vulkan memory with HIP via Win32 opaque handles on Windows
(VK_KHR_external_memory_win32) and via fds on Linux. Handle types are now
intptr_t, and the platform choice is in D4R_EXT_MEMORY_* macros.
- HipNetwork: add debugRepeatHashes and debugNodeMicros, exposed as
D4R_HIP_REPEAT_CHECK, D4R_HIP_REPEAT_ALL and D4R_HIP_NODE_PROFILE in
replay.cpp.
- replay.cpp: display-resolution-motion frames (FrameFlagDisplayMotion) no
longer require near2rnd == out2rnd. Both values must still be in (0, 1].
K kernels on gfx11
- Allow position-token and enc1 tiling on __GFX11__ as well as gfx12.
- Add an opt-in ds_bpermute cross-half exchange
(D4R_WINDOWS_GFX11_DS_EXCHANGE, enabled for K on Windows gfx11). M keeps
its LDS path.
- Fix a block-barrier race in the position layer. Without POS_VSHARE a fast
wave could overwrite its hb rows while a slower wave still read them for a
later head, giving rare wrong results on gfx1101 (enc0 outputs differing
between identical launches).
Packaging and install
- install.bat, d4r.ini, WINDOWS_README: FSR option, and
install_dependencies.py to install pinned NVIDIA dependencies with staged,
hash-verified replacement and rollback.
- Update the release package, local package refresh and test scripts.
- Add the InteropBatchInputCopies option (default false). Batching is faster
on some synthetic runs, but player temporal exactness is unresolved.
Tooling and tests
- K model: capture_k_weights, build_k_model, compare_k_outputs,
benchmark_k_hip, build_capture_runtime, test_k_model and the
zluda-k-output-capture patch. Captured weights and models are private
local assets and must not enter release archives.
- Synthetic probes: test_m_ngx, test_sr_dynamic,
prepare_rr_dynamic_fixture and the d3d12/rr_ngx probe updates.
- Add tests/windows/test_install_dependencies.py.
Docs
- Update the windows-fsr-rr, k-performance, local-package, rr-interop and
rr-model-cache docs. Add windows-parity-handoff.md and
windows-parity-continuation-prompt.md.
42 lines
2.3 KiB
C++
42 lines
2.3 KiB
C++
#pragma once
|
|
#include "d3d12_external.h"
|
|
#include "rr_ngx_snapshot.h"
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
namespace d4r::win::rr {
|
|
// Where the experimental FSR Ray Regeneration backend finds its pieces. All paths are explicit: nothing is
|
|
// searched for, and AMD's amdxc64.dll is never loaded.
|
|
struct FsrConfig {
|
|
std::wstring vkd3dCore; // d4r's vkd3d-proton d3d12core.dll, renamed so it cannot collide with the system's
|
|
std::wstring denoiserDll; // AMD's amd_fidelityfx_denoiser_dx12.dll (FidelityFX SDK 2.3), unmodified
|
|
std::wstring amdxcShim; // d4r's amdxc64 shim (tools/windows/amdxc64_shim)
|
|
std::wstring cacheDir; // vkd3d-proton's shader cache: the denoiser's shaders are compiled once
|
|
static FsrConfig from_environment();
|
|
};
|
|
|
|
// FSR Ray Regeneration as the Ray Reconstruction backend on native Windows. The game's guides cross to a private
|
|
// vkd3d-proton device (D3D12 over Vulkan, dxil-spirv FP8 emulation) through the same shared packet the native
|
|
// DLSS backend uses; AMD's denoiser runs there. Evaluation is synchronous, as the native backend's is.
|
|
// The denoiser works at render resolution. When the output is larger (or a Super Sampling stage is wanted at all),
|
|
// the owner installs one with set_super_sampling(): the denoised colour is then copied into a texture on the game's
|
|
// device and handed to that callback together with the frame, which must record/submit the upscale into the game's
|
|
// output on `queue`. Without it an output larger than the render size is refused, never returned noisy.
|
|
class FsrBackend {
|
|
struct Impl;
|
|
std::unique_ptr<Impl> impl;
|
|
public:
|
|
FsrBackend(ID3D12Device* device, const Creation& creation, const FsrConfig& config);
|
|
~FsrBackend();
|
|
FsrBackend(const FsrBackend&) = delete;
|
|
FsrBackend& operator=(const FsrBackend&) = delete;
|
|
using SuperSampling = std::function<void(ID3D12CommandQueue*, ID3D12Resource* denoised, const Snapshot&,
|
|
const std::array<ResourceAccess, Snapshot::Count>&)>;
|
|
void set_super_sampling(SuperSampling stage, const std::array<unsigned, 4>& renderLimits);
|
|
void validate_frame(const Snapshot& frame);
|
|
void evaluate(ID3D12CommandQueue* queue, const Snapshot& frame, const std::array<ResourceAccess, Snapshot::Count>& access);
|
|
void drain();
|
|
};
|
|
}
|