Draft: native D3D12 renderer and reproducible contributor handoff

.github/workflows/native-gpu-checks.yml

@@ -0,0 +1,18 @@
+name: Native GPU portable checks
+on:
+  pull_request:
+  push:
+    branches: [codex/native-renderer]
+permissions:
+  contents: read
+jobs:
+  portable:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure asset-free checks
+        run: cmake -S tools/gpu-aot -B native-checks -DCMAKE_BUILD_TYPE=Release
+      - name: Build
+        run: cmake --build native-checks --parallel 2
+      - name: Test
+        run: ctest --test-dir native-checks --output-on-failure

.gitignore

@@ -21,6 +21,12 @@
 !/rexglue-sdk
 !/DimensionsModManager
 !/DimensionsSaveConverter
+!/thirdparty/
+!/thirdparty/plume
+!/thirdparty/miniz/
+!/thirdparty/miniz/**
+!/thirdparty/zstd/
+!/thirdparty/zstd/**
 !/xexdump/
 !/tools/
 

.gitmodules

@@ -8,3 +8,6 @@
 [submodule "DimensionsSaveConverter"]
 	path = DimensionsSaveConverter
 	url = https://github.com/NeverCookFirst/DimensionsSaveConverter.git
+[submodule "thirdparty/plume"]
+	path = thirdparty/plume
+	url = https://github.com/zolaware/plume.git

rexlego/src/cheat_menu.cpp

@@ -273,8 +273,6 @@ void Shutdown() {
 // menu gets a plain on/off instead of a hex string.
 namespace {
 
-constexpr std::string_view kDofPixelShaderHash = "CFEAC7ADB912F8A9";
-
 void ApplyDepthOfField(bool enabled) {
   const std::string current = rex::cvar::GetFlagByName("skip_pixel_shaders");
   std::string next;

rexlego/src/cheat_menu.h

@@ -6,13 +6,15 @@
 #pragma once
 
 #include <memory>
+#include <string_view>
 
 namespace rex::ui {
 class ImGuiDialog;
 class ImGuiDrawer;
 }  // namespace rex::ui
 
 namespace legodimensions::cheats {
+inline constexpr std::string_view kDofPixelShaderHash = "CFEAC7ADB912F8A9";
 
 // Creates the DEL dialog. The caller owns it; destroying it closes the menu,
 // the same way the mod menu and the SDK overlays are toggled. The scanner

rexlego/src/gpu/shaders/linked_shader_cache.h

@@ -0,0 +1,7 @@
+/**
+ * Compatibility include for the source emitted by lego_gpu_prelink.
+ */
+
+#pragma once
+
+#include "gpu_native/linked_shader_cache.h"

rexlego/src/gpu/shaders/shader_cache.h

@@ -0,0 +1,7 @@
+/**
+ * Compatibility include for the source emitted by XenosRecomp.
+ */
+
+#pragma once
+
+#include "gpu_native/shader_archive.h"

rexlego/src/gpu_native/alpha_test.h

@@ -0,0 +1,16 @@
+#pragma once
+#include <cstdint>
+
+namespace legodimensions::gpu_native {
+struct NativeAlphaState {
+  bool enabled;
+  std::uint32_t function;
+  float reference;
+};
+inline NativeAlphaState DecodeNativeAlphaState(std::uint32_t color_control,
+                                               float reference) {
+  // TU23 83FB7E00 / 83FB82C0: enable bit 3, raw Xenos compare bits 0..2.
+  // 83FB92B8 stores FLOAT BITS unchanged; no integer /255 or /256 mapping.
+  return {(color_control & 8u) != 0, color_control & 7u, reference};
+}
+}  // namespace legodimensions::gpu_native

rexlego/src/gpu_native/blend_state.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <cstdint>
+
+namespace legodimensions::gpu_native {
+struct ColorBlendState {
+  uint32_t source, destination, operation;
+  uint32_t alpha_source, alpha_destination, alpha_operation;
+  bool enabled, supported;
+};
+constexpr bool SupportedBlendFactor(uint32_t value) {
+  // Constant alpha for RGB needs a distinct host representation, not silently
+  // substituting constant RGB. Keep that case explicitly unsupported for now.
+  return value <= 1 || (value >= 4 && value <= 13) || value == 16;
+}
+constexpr ColorBlendState DecodeColorBlend(uint32_t control) {
+  ColorBlendState state{control & 31, (control >> 8) & 31, (control >> 5) & 7,
+      (control >> 16) & 31, (control >> 24) & 31, (control >> 21) & 7};
+  state.enabled = (control & 0x1FFF1FFFu) != 0x00010001u;
+  state.supported = state.operation <= 4 && state.alpha_operation <= 4 &&
+      SupportedBlendFactor(state.source) && SupportedBlendFactor(state.destination) &&
+      SupportedBlendFactor(state.alpha_source) && SupportedBlendFactor(state.alpha_destination);
+  return state;
+}
+}  // namespace legodimensions::gpu_native

rexlego/src/gpu_native/buffer_header.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <cstdint>
+
+namespace legodimensions::gpu_native {
+struct PlacementBufferInfo {
+  uint32_t address = 0;
+  uint32_t size = 0;
+  uint32_t index_format = 0;  // Native convention: 1 = 16-bit, 2 = 32-bit.
+};
+
+// TU23 asset headers observed in game.log; matches re:Blue's physical-buffer
+// adoption. These are initialized fetch headers, not XGSet*BufferHeader inputs.
+constexpr PlacementBufferInfo DecodePlacementBuffer(uint32_t common,
+    uint32_t fetch_lo, uint32_t fetch_hi, bool index) {
+  if ((common & 31u) != (index ? 2u : 1u)) return {};
+  const uint32_t address = fetch_lo & ~3u;
+  const uint32_t size = fetch_hi & 0x03FFFFFCu;
+  if (!address || !size || uint64_t(address) + size > 0x100000000ull) return {};
+  return {address, size, index ? ((common & 0x80000000u) ? 2u : 1u) : 0u};
+}
+}

rexlego/src/gpu_native/buffer_window.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <cstdint>
+
+namespace legodimensions::gpu_native {
+struct VertexBufferWindow { uint32_t offset = 0, length = 0; };
+// The rebased index is index-min_index; the upload starts at
+// stream_offset+(min_index+original_base_vertex)*stride.
+constexpr VertexBufferWindow DrawVertexWindow(uint32_t min_index, uint32_t max_index,
+    int32_t base_vertex, uint32_t stride, uint32_t stream_offset, uint32_t buffer_length) {
+  const int64_t first = int64_t(min_index) + base_vertex;
+  const int64_t last = int64_t(max_index) + base_vertex;
+  if (!stride || first < 0 || last < first) return {};
+  const uint64_t offset = uint64_t(stream_offset) + uint64_t(first) * stride;
+  const uint64_t length = uint64_t(last - first + 1) * stride;
+  if (offset > buffer_length || length > buffer_length - offset ||
+      offset % 4 || length % 4) return {};
+  return {uint32_t(offset), uint32_t(length)};
+}
+}