Engine: native presets K and M in the D3D12 shim, wider game coverage

A standalone Vulkan inference engine (engine/) for DLSS presets K and M that
runs from weights extracted from the user's own nvngx_dlss.dll, with d4r's
own input, network and reconstruction shaders or the native HIP network
layers, recorded into the game's command list by the shim. Opt-in
([Engine] Enabled / D4R_ENGINE=1); anything uncovered falls back to the
CUDA/ZLUDA path with the reason logged.

Byte-identical to NGX's CUDA backend under the phase-capable reference
(1706x960 -> 2560x1440, native HIP network, eleven frames, RX 9070 XT):
- K render- and display-resolution motion vectors, HDR and LDR
- K game-supplied exposure and automatic exposure with any pre-exposure
  and exposure scale (one residual: effective exposure exactly 2 or 4)
- K and M with the DLSS indicator's inverted-axis parameters
- M with any exposure settings (NGX ignores them for M)
K packages need the current compile_k.py (marker D4RO0003).

Also: HIP shared buffers are pooled across feature recreation (ROCm leaks
destroyed imports), hipnet.bin must match the preset, M-only games do not
load the K model, install_d4r_runtime.sh stages k, k-ldr, m, m-ldr with
hip/, the activation table has a generator (gen_activation_m.py), and
package_release.sh can bundle the engine's shaders (never its weights).

Signed-off-by: woutermans <[email protected]>

scripts/package_release.sh

@@ -32,6 +32,10 @@
 #                    Accuracy texture sets go in accuracy/<target>/, built with D4R_PREFER_ACCURACY=1.
 #   D4R_ZLUDA_EMIT  d4r_emit from the patched ZLUDA build; required in full builds when an accuracy
 #                    texture set or L's unfolded texture variants are not supplied in D4R_BUNDLE_TEX.
+#   D4R_BUNDLE_ENGINE  optional: the native engine's preset K model (the folder engine/compile_k.py wrote),
+#                    packaged as d4r/engine/k for d4r.ini [Engine]. Only d4r's shaders are taken from it: the
+#                    weights and reconstruction table are values read from NVIDIA's DLSS and are never packaged,
+#                    in any variant. Users produce them from their own nvngx_dlss.dll (engine/README.md).
 # D4R_BUNDLE_NVIDIA=installer (default) ships install.sh instead of NVIDIA DLLs, retaining texture kernels.
 # D4R_BUNDLE_NVIDIA=1 bundles both DLLs; =0 omits DLLs and texture kernels (nonvidia ZIP).
 set -euo pipefail
@@ -119,6 +123,16 @@ if [[ "$VARIANT" != clean ]]; then
 else
   printf 'Put NVIDIA'"'"'s NGX runtime, _nvngx.dll, in this folder (see D4R_README.txt).\r\n' > "$STAGE/d4r/ngx/README.txt"
 fi
+if [[ -n "${D4R_BUNDLE_ENGINE:-}" ]]; then
+  for f in input_k.spv output_k.spv exposure_k0.spv exposure_k1.spv; do
+    [[ -f "$D4R_BUNDLE_ENGINE/$f" ]] || { echo "D4R_BUNDLE_ENGINE lacks $f (run engine/compile_k.py)" >&2; exit 2; }
+  done
+  mkdir -p "$STAGE/d4r/engine/k"
+  cp "$D4R_BUNDLE_ENGINE"/*.spv "$STAGE/d4r/engine/k/"
+  # d4r's own shader-revision marker; every other .bin in the model holds values read from NVIDIA's DLSS
+  [[ ! -f "$D4R_BUNDLE_ENGINE/direct_origins.bin" ]] || cp "$D4R_BUNDLE_ENGINE/direct_origins.bin" "$STAGE/d4r/engine/k/"
+  printf 'The native engine needs weights.bin, offsets.bin and lut.bin here (see D4R_README.txt).\r\n' > "$STAGE/d4r/engine/k/README.txt"
+fi
 IFS=: read -r -a DLLS <<< "$D4R_DLSS_DLLS"
 # one folder per target; RDNA4 targets also get <target>-fp8 (native FP8 WMMA, d4r.ini NativeFp8), which the
 # bridge serves instead when that setting is on
@@ -253,3 +267,6 @@ rm -f "$OUT/$NAME.zip"
 (cd "$STAGE" && find . -type f | LC_ALL=C sort | sed 's|^\./||' | zip -q -X -9 "$OUT/$NAME.zip" -@)
 (cd "$OUT" && sha256sum "$NAME.zip" > "$NAME.zip.sha256")
 printf 'Built %s (%s)\n' "$OUT/$NAME.zip" "$(du -h "$OUT/$NAME.zip" | cut -f1)"
+if [[ "$VARIANT" == full ]]; then
+  echo "This zip contains NVIDIA's DLLs and kernels built from NVIDIA's code. Do not publish or share it." >&2
+fi