woutermans
f0b55a850a
- layer_m.comp builds relaxed by default (M_RELAXED: f32 accumulators, paired FP8 conversions, no activation table) with two windows per wave sharing weight tiles (WPW=2); M_EXACT=1 keeps NVIDIA's roundings, bit-identical to the CUDA path - layer.comp reuses weight tiles across its waves (TPW=2 in the 32-channel layers) - engine/rr/rr2_w.comp: one wave per window for preset F's dec0_0 and enc0, used by compile_rr2.py at the new default D4R_RR_RELAXED=3 (build_native_model.sh too); D4R_RR_FUSE=1 matches the reference's fused multiply-adds, ptx2rr.py --snorm16 - [Engine] Network defaults to vulkan; the HIP network is opt-in
188 lines
10 KiB
Plaintext
188 lines
10 KiB
Plaintext
; Modified in this fork for CUDA Ray Reconstruction support and validation (2026).
|
|
; d4r configuration: official NVIDIA DLSS on AMD (ZLUDA + Wine CUDA bridge + NGX shim)
|
|
;
|
|
; Read by scripts/run_game_d4r_optiscaler_proton.sh at every game launch. The first launch copies
|
|
; this file to ~/.config/d4r/d4r.ini (or D4R_CONFIG); edit that copy. Changes apply at the next launch.
|
|
;
|
|
; Every value can be left as "auto" (or empty) to keep the built-in default. An environment variable
|
|
; set before launching (e.g. D4R_DLSS_PRESET=11) always wins over this file.
|
|
; Paths may use ~ for your home directory.
|
|
|
|
[Launch]
|
|
; Used by scripts/d4r_play.sh (one-command launch). Examples:
|
|
; ProtonDir = ~/.local/share/Steam/compatibilitytools.d/GE-Proton11-3
|
|
; CompatDataDir = ~/.local/share/Steam/steamapps/compatdata/<appid>
|
|
; GameExe = ~/Games/MyGame/Binaries/Win64/MyGame-Win64-Shipping.exe
|
|
ProtonDir =
|
|
CompatDataDir =
|
|
GameExe =
|
|
|
|
[DLSS]
|
|
; DLSS model recommendations:
|
|
;
|
|
; Model | DLSS | Recommended modes | Notes
|
|
; ------+-------+---------------------------------+----------------------------------
|
|
; K | 4 | DLAA / Quality / Balanced | Default; faster alternative to M/L
|
|
; M | 4.5 | Performance | More demanding on RDNA3
|
|
; L | 4.5 | Ultra Performance | Especially 4K; experimental
|
|
; E | 3 CNN | Quality / Balanced / Performance | Legacy faster fallback
|
|
; F | 3 CNN | DLAA / Ultra Performance | Deprecated; prefer K or L
|
|
;
|
|
; Select the upscaling mode separately in game/OptiScaler. These are recommendations;
|
|
; other modes are allowed. L requires the L texture build.
|
|
; Aliases: CNN = E, DLSS4 = K, DLSS4.5 = M. A/B/C/D/G/J use K in this DLL version.
|
|
; auto = use the game/OptiScaler choice. Benchmarks: docs/performance.md.
|
|
Model = K
|
|
|
|
[RayReconstruction]
|
|
; Runs NVIDIA's nvngx_dlssd.dll denoiser, separate from Super Resolution.
|
|
; auto enables the CUDA route when the NGX core reports the denoiser initialized and available.
|
|
; false disables it. Select Ray Reconstruction and ray tracing in the game.
|
|
; RR D/E temporal validation on gfx1201 requires native FP8 WMMA ([Kernels] NativeFp8 = true).
|
|
; The scalar FP8 RR path is not validated.
|
|
Enable = auto
|
|
; auto preserves the game's choice; default = NVIDIA's default, D/E = transformer models.
|
|
; These presets are independent of [DLSS] Model. E requires a DLL that contains that model.
|
|
Model = auto
|
|
|
|
[Latency]
|
|
; How many frames old the upscaled image the game presents may be.
|
|
; 0 = same frame (no added latency, no trailing artefacts; needs VkD3DDir below)
|
|
; 1 = at most 1 frame old
|
|
; 2 = 2 frames old (roughly +20% fps with DLSS 4.5, adds ~2 frames of input latency,
|
|
; fast motion can trail)
|
|
; 3 = 2-3 frames old (about the same fps as 2 in practice)
|
|
FrameAge = 0
|
|
|
|
[Kernels]
|
|
; Prefer NVIDIA's original arithmetic over speed for every native kernel and the translated fallback.
|
|
; Restores intermediate FP8 quantization, per-MMA f16 rounding and original denormal handling; keeps
|
|
; NGX's synchronizations. Selects accuracy variants in NativeKernelDir*/accuracy (or a marked accuracy
|
|
; directory directly). Missing accuracy kernels use translated PTX, never the fast set. Slower; this
|
|
; aims for fidelity, but RTX image parity is not proven. (D4R_PREFER_ACCURACY)
|
|
PreferAccuracy = false
|
|
; false: use original translated enc1/enc2 layers for L/M, retaining other native kernels.
|
|
; Reduces the native encoders' motion trails seen in Townfall; best paired with PreferAccuracy.
|
|
; Costs some GPU time. Manifest required for selective fallback; flat sets fall back entirely.
|
|
; (D4R_NATIVE_SWIN_ENCODERS)
|
|
NativeSwinEncoders = true
|
|
; Native RDNA3 / RDNA4 kernels for the DLSS 4 and 4.5 network layers (replace ZLUDA's translated code).
|
|
; fast = native kernels with relaxed numerics (unless PreferAccuracy is true)
|
|
; exact = a separately built directory with conservative FP8/f16 rounding; not an RTX parity guarantee
|
|
; off = ZLUDA-translated kernels only
|
|
; fast/exact need the code objects built by the native-kernel tools ([Paths] NativeKernelDir*).
|
|
NativeKernels = off
|
|
; FP8 tensor-core emulation on RDNA3 WMMA (much faster than the scalar path).
|
|
Fp8Wmma = true
|
|
; RDNA4 only: FP8 MMAs on the native FP8 WMMA (and the -fp8 native kernel variants); off widens FP8 to f16 as
|
|
; on RDNA3. Ignored on other GPUs. (D4R_ZLUDA_WMMA_FP8_NATIVE)
|
|
NativeFp8 = true
|
|
; Drop per-instruction flush-to-zero mode switches in ZLUDA-compiled kernels
|
|
; (only values below ~1e-38 differ; a little faster).
|
|
IgnoreDenormals = true
|
|
; Thread-block bound assumed for kernels without launch bounds (256 avoids register spills).
|
|
ImplicitMaxBlock = 256
|
|
|
|
[Interop]
|
|
; Experimental foreground motion coverage for thin geometry. 0 = original vectors;
|
|
; 1/2 = opaque-surface dilation radius in render pixels; both automatically fill sky gaps
|
|
; from the nearest foreground within 8 render pixels. Needs render- or display-resolution, unjittered motion vectors
|
|
; and same-frame linear VRAM inputs; unsupported features retain original vectors.
|
|
; Default off. May affect disocclusion edges. (D4R_MOTION_DILATION)
|
|
MotionVectorDilation = 0
|
|
; Keep DLSS inputs and output in VRAM (vkd3d-proton Vulkan interop) instead of copying through
|
|
; system memory. Falls back automatically when the game's resources do not qualify.
|
|
VramInterop = true
|
|
; Wait for the input copies before DLSS runs (prevents beaded thin lines in motion). Keep on.
|
|
InputSync = true
|
|
; Faster hand-offs between the game and DLSS (same frame, same result). Need FrameAge = 0 and VRAM
|
|
; interop, and a runtime built from this checkout (scripts/install_d4r_runtime.sh).
|
|
; Input readiness is checked with CPU sleeps; recorded-but-discarded lists never queue GPU waits.
|
|
; LinearInputs: DLSS reads the game's inputs in place once the input marker is ready
|
|
; DirectOutput: the result is written straight into the game-side buffer (preset K, and only while
|
|
; NGX runs the native output kernel; drops NVIDIA's "DLSS SDK" watermark)
|
|
; ElideNgxSync: removes NGX's internal CPU waits between its GPU stages
|
|
; EvalSync = false: no CPU wait between DLSS and the output copy
|
|
; MarkerPollUs: how often (microseconds) the CPU checks for the game's inputs
|
|
LinearInputs = true
|
|
DirectOutput = true
|
|
ElideNgxSync = true
|
|
EvalSync = false
|
|
MarkerPollUs = 200
|
|
|
|
[Engine]
|
|
; Experimental. Runs DLSS 4 and 4.5 (models K, L and M) on d4r's own Vulkan inference engine instead of NVIDIA's
|
|
; kernels through ZLUDA: the whole evaluation is recorded into the game's own command list, the game shows the
|
|
; result of the frame it just rendered, and FrameAge and the [Interop] hand-off settings do not apply.
|
|
; Needs VkD3DDir, a driver with VK_KHR_cooperative_matrix (Mesa RADV on RDNA3/RDNA4) and the model folders
|
|
; (RuntimeDir/engine/k, k-ldr, m, m-ldr, l, l-ldr; scripts/install_d4r_runtime.sh). A game or setting the engine
|
|
; does not cover uses the normal path, with the reason in d4r_nvngx.log: other models than K, L and M,
|
|
; display-resolution motion vectors with L or M, or a K model built before the current engine/compile_k.py for display-resolution
|
|
; motion, non-inverted depth or exposure supplied by the game. Details and measurements: engine/README.md.
|
|
; (D4R_ENGINE)
|
|
Enabled = false
|
|
; The model K folder for games with the HDR flag: the folder engine/compile_k.py writes (weights extracted
|
|
; from your nvngx_dlss.dll plus d4r's shaders). auto = RuntimeDir/engine/k, where scripts/install_d4r_runtime.sh
|
|
; puts D4R_ENGINE_MODEL. The other folders: D4R_ENGINE_MODEL_LDR_DIR, D4R_ENGINE_MODEL_M_DIR,
|
|
; D4R_ENGINE_MODEL_M_LDR_DIR, D4R_ENGINE_MODEL_L_DIR and D4R_ENGINE_MODEL_L_LDR_DIR. (D4R_ENGINE_MODEL_DIR)
|
|
ModelDir = auto
|
|
; Where the network between the engine's Vulkan stages runs (K and M). vulkan = the engine's cooperative-matrix
|
|
; shader, everything in one command list. hip = d4r's native HIP layer kernels: the game's command list is split
|
|
; around the network like a split frame, so it needs VkD3DDir, the CUDA bridge and a model built with --hip; when
|
|
; they are missing the Vulkan network runs and the log says why. auto = vulkan. (D4R_ENGINE_NETWORK)
|
|
Network = auto
|
|
|
|
[Paths]
|
|
; auto = defaults of scripts/d4r_proton_env.sh
|
|
RuntimeDir = auto
|
|
; ZLUDA build (directory with libcuda.so / libnvcuda.so)
|
|
ZludaDir = auto
|
|
RocmDir = auto
|
|
; Matching lifetime-aware d4r vkd3d-proton (both d3d12.dll + d3d12core.dll); required for all shim paths.
|
|
VkD3DDir = auto
|
|
; JIT cache directory (XDG_CACHE_HOME): auto = the default ~/.cache; per-zluda = one per ZLUDA build,
|
|
; ~/.cache/d4r-perf-game-jit-<ZludaDir name> (a new ZLUDA build compiles every kernel once on first use)
|
|
JitCacheDir = auto
|
|
; Native kernel code objects, one directory per NativeKernels mode
|
|
NativeKernelDirFast = auto
|
|
NativeKernelDirExact = auto
|
|
|
|
[Game]
|
|
; Unreal Engine games: extra console variables applied for this launch only (the game's Engine.ini is
|
|
; backed up and restored on exit). Example for sharper thin lines in SILENT HILL Townfall:
|
|
; EngineIni = ~/.local/share/Steam/steamapps/compatdata/<appid>/pfx/drive_c/users/steamuser/AppData/Local/Townfall/Saved/Config/Windows/Engine.ini
|
|
; Cvars = r.Tonemapper.Sharpen=0;r.SceneColorFringeQuality=0
|
|
EngineIni =
|
|
Cvars =
|
|
|
|
[OptiScaler]
|
|
; OptiScaler's own FPS overlay (top left)
|
|
FpsOverlay = true
|
|
; 0 = simple ... 3 = detailed with frame-time graph
|
|
FpsOverlayType = 3
|
|
LogLevel = 2
|
|
; Override the render resolution OptiScaler requests per quality mode, e.g. 2.0 turns the game's
|
|
; "Quality" into Performance-level input (1280x720 for 1440p). auto = the game's choice.
|
|
QualityRatioQuality = auto
|
|
QualityRatioBalanced = auto
|
|
QualityRatioPerformance = auto
|
|
QualityRatioUltraPerformance = auto
|
|
; Any other OptiScaler.ini settings for this launch, "Section.Key=value;Section.Key=value"
|
|
Extra =
|
|
|
|
[Overlay]
|
|
; MangoHud FPS counter (top right)
|
|
MangoHud = false
|
|
MangoHudConfig = fps,frametime,frame_timing=0,gpu_stats=0,cpu_stats=0,position=top-right,font_size=36
|
|
|
|
[Debug]
|
|
; Per-frame timing lines in the shim log (d4r_nvngx.log)
|
|
Profile = false
|
|
; Log directory (auto = ~/.cache/d4r-dlss-captures/game-<exe>-<time>)
|
|
LogDir = auto
|
|
|
|
[Env]
|
|
; Anything else, passed through as environment variables (one per line):
|
|
; D4R_SHIM_SPLIT_TIMEOUT_MS = 200
|
|
; D4R_SHIM_BLOCKING_SYNC = 0 ; A/B only: restore context waits instead of default event queries/sleeps
|