fix: guard Linux memory fixes to only Linux

Reserve only free guest address ranges

.github/ISSUE_TEMPLATE/kytyps5-game-emulation.yaml

@@ -1,6 +1,6 @@
-name: Game Emulation Status Report
-description: Submit a KytyPS5 game compatibility result, including boot, rendering, audio, input, or gameplay behavior.
-title: "[GAME STATUS]: "
+name: Game Emulation Bug Report
+description: Report KytyPS5 game boot, crash, freeze, rendering, audio, input, or gameplay behavior problems.
+title: "[GAME BUG]: "
 body:
   - type: markdown
     attributes:
@@ -10,7 +10,6 @@ body:
         Before submitting, please:
         - Search existing issues first.
         - Re-test with a clean game dump.
-        - Use the latest KytyPS5 build available to you.
         - Attach the complete log file instead of edited snippets.
 
   - type: markdown
@@ -45,28 +44,6 @@ body:
     validations:
       required: true
 
-  - type: dropdown
-    id: compatibility-status
-    attributes:
-      label: Compatibility status
-      description: Select the furthest point the game consistently reaches on this build.
-      options:
-        - "Doesn't boot"
-        - Logo
-        - Main menu
-        - In game
-    validations:
-      required: true
-
-  - type: markdown
-    attributes:
-      value: |
-        **Status guide**
-        - **Doesn't boot:** The game does not show its first logo or startup screen.
-        - **Logo:** The game shows a logo or startup screen but does not reach the main menu.
-        - **Main menu:** The game reaches its menus but does not enter gameplay.
-        - **In game:** The game reaches controllable gameplay, even if bugs prevent completion.
-
   - type: input
     id: regression-builds
     attributes:
@@ -77,22 +54,22 @@ body:
   - type: markdown
     attributes:
       value: |
-        ## Test result
+        ## Problem details
 
   - type: textarea
     id: what-happened
     attributes:
-      label: Result details
-      description: Describe what worked, what failed, and any visible or audible problems.
-      placeholder: "Example: The game reaches the main menu, then freezes after selecting Continue. Audio plays correctly until the freeze."
+      label: What happened?
+      description: Describe the failure or incorrect behavior as directly as possible.
+      placeholder: "Example: The game reaches the main menu, then freezes after selecting Continue."
     validations:
       required: true
 
   - type: textarea
     id: steps-to-reproduce
     attributes:
-      label: Steps to reproduce the result
-      description: List the shortest path to the reported status or failure from a fresh KytyPS5 start.
+      label: Steps to reproduce
+      description: List the shortest path that triggers the problem from a fresh KytyPS5 start.
       placeholder: |
         1. Open KytyPS5.
         2. Boot the game.
@@ -104,7 +81,7 @@ body:
     id: expected-behavior
     attributes:
       label: Expected behavior
-      description: Explain what should happen at the same point in the game. If there is no known problem, write "No known issue".
+      description: Explain what should happen at the same point in the game.
       placeholder: "Example: The save should load and gameplay should continue normally."
     validations:
       required: true

.github/workflows/build.yml

@@ -6,27 +6,9 @@ on:
     branches: [ main, master ]
   pull_request:
 
-env:
-  KYTY_BUILD_ORIGIN: ${{ github.repository != 'KytyPS5/KytyPS5' && 'Fork' || github.event_name == 'push' && 'Official' || 'Source' }}
-  KYTY_BUILD_REPOSITORY: ${{ github.repository }}
-
 jobs:
-  metadata:
-    name: Prepare build metadata
-    runs-on: ubuntu-latest
-    outputs:
-      release_tag: ${{ steps.release_tag.outputs.value }}
-
-    steps:
-      - name: Generate release tag
-        id: release_tag
-        shell: bash
-        run: |
-          echo "value=KytyPS5-$(date -u +'%Y-%m-%d')-${GITHUB_SHA::7}" >> "$GITHUB_OUTPUT"
-
   windows:
     name: Build KytyPS5 (Windows)
-    needs: metadata
     runs-on: windows-2022
 
     steps:
@@ -91,13 +73,9 @@ jobs:
       - name: Configure
         shell: cmd
         run: |
-          cmake -S . -B _Build/windows ^
+          cmake -S src -B _Build/windows ^
             -G Ninja ^
             -DCMAKE_BUILD_TYPE=Release ^
-            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON ^
-            -DKYTY_BUILD_ORIGIN=%KYTY_BUILD_ORIGIN% ^
-            -DKYTY_BUILD_REPOSITORY=%KYTY_BUILD_REPOSITORY% ^
-            -DKYTY_RELEASE_TAG=${{ needs.metadata.outputs.release_tag }} ^
             -DCMAKE_C_COMPILER=clang-cl ^
             -DCMAKE_CXX_COMPILER=clang-cl ^
             -DCMAKE_PREFIX_PATH="%Qt6_DIR%"
@@ -105,12 +83,12 @@ jobs:
       - name: Build
         shell: cmd
         run: |
-          cmake --build _Build/windows --target launcher audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests --parallel
+          cmake --build _Build/windows --target launcher virtual_memory_allocation_tests --parallel
 
       - name: Test
         shell: cmd
         run: |
-          ctest --test-dir _Build/windows --output-on-failure -R "^(audio_out2_port|ime_dialog|virtual_memory_allocation)$"
+          ctest --test-dir _Build/windows --output-on-failure -R "^virtual_memory_allocation$"
 
       - name: Install
         shell: cmd
@@ -126,7 +104,6 @@ jobs:
 
   macos:
     name: Build KytyPS5 (macOS)
-    needs: metadata
     runs-on: macos-15
 
     steps:
@@ -170,13 +147,9 @@ jobs:
       - name: Configure
         shell: bash
         run: |
-          cmake -S . -B _Build/macos \
+          cmake -S src -B _Build/macos \
             -G Ninja \
             -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
-            -DKYTY_BUILD_ORIGIN="$KYTY_BUILD_ORIGIN" \
-            -DKYTY_BUILD_REPOSITORY="$KYTY_BUILD_REPOSITORY" \
-            -DKYTY_RELEASE_TAG="${{ needs.metadata.outputs.release_tag }}" \
             -DCMAKE_OSX_ARCHITECTURES=x86_64 \
             -DCMAKE_C_COMPILER=clang \
             -DCMAKE_CXX_COMPILER=clang++ \
@@ -186,14 +159,14 @@ jobs:
         shell: bash
         run: |
           cmake --build _Build/macos \
-            --target launcher audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests \
+            --target launcher virtual_memory_allocation_tests \
             --parallel
 
       - name: Test
         shell: bash
         run: |
           ctest --test-dir _Build/macos --output-on-failure \
-            -R '^(audio_out2_port|ime_dialog|virtual_memory_allocation)$'
+            -R '^virtual_memory_allocation$'
 
       - name: Install
         shell: bash
@@ -208,71 +181,38 @@ jobs:
         run: |
           archive="$RUNNER_TEMP/MoltenVK-macos.tar"
           package="$RUNNER_TEMP/MoltenVK"
-          install_dir="_Build/macos/install"
-          app_dir="$install_dir/KytyPS5.app"
-          moltenvk="$install_dir/libMoltenVK.dylib"
           curl --fail --location --retry 3 \
             --output "$archive" \
             "https://github.com/KhronosGroup/MoltenVK/releases/download/$MOLTENVK_VERSION/MoltenVK-macos.tar"
           echo "$MOLTENVK_SHA256  $archive" | shasum -a 256 --check
           tar -xf "$archive" -C "$RUNNER_TEMP"
-          test -d "$app_dir"
           install -m 755 \
             "$package/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" \
-            "$moltenvk"
-          install -m 644 "$package/LICENSE" "$install_dir/LICENSE.MoltenVK"
-          codesign --force --sign - --timestamp=none "$moltenvk"
-          install -d -m 755 "$app_dir/Contents/Frameworks" "$app_dir/Contents/Resources"
-          install -m 755 "$moltenvk" "$app_dir/Contents/Frameworks/libMoltenVK.dylib"
-          install -m 644 "$package/LICENSE" "$app_dir/Contents/Resources/LICENSE.MoltenVK"
-          codesign --force --sign - --timestamp=none "$app_dir"
+            _Build/macos/install/libMoltenVK.dylib
+          install -m 644 "$package/LICENSE" _Build/macos/install/LICENSE.MoltenVK
+          codesign --force --sign - --timestamp=none _Build/macos/install/libMoltenVK.dylib
 
       - name: Verify artifacts
         shell: bash
         run: |
-          install_dir="_Build/macos/install"
-          app_dir="$install_dir/KytyPS5.app"
-          test -d "$app_dir"
-          for binary in \
-            "$install_dir/kyty_emulator" \
-            "$install_dir/libMoltenVK.dylib" \
-            "$app_dir/Contents/MacOS/KytyPS5" \
-            "$app_dir/Contents/MacOS/kyty_emulator" \
-            "$app_dir/Contents/Frameworks/libMoltenVK.dylib"; do
-            file "$binary"
-            lipo "$binary" -verify_arch x86_64
-          done
-          for binary in \
-            "$install_dir/kyty_emulator" \
-            "$install_dir/libMoltenVK.dylib" \
-            "$app_dir/Contents/MacOS/KytyPS5" \
-            "$app_dir/Contents/MacOS/kyty_emulator" \
-            "$app_dir/Contents/Frameworks/libMoltenVK.dylib"; do
-            codesign --verify --strict "$binary"
-          done
-          codesign --verify --deep --strict --verbose=2 "$app_dir"
-
-      - name: Package macOS artifacts
-        shell: bash
-        run: |
-          install_dir="_Build/macos/install"
-          archive="$RUNNER_TEMP/KytyPS5-macOS-x86_64.zip"
-          (
-            cd "$install_dir"
-            zip -qry "$archive" .
-          )
-          unzip -t "$archive"
+          file _Build/macos/install/launcher
+          file _Build/macos/install/kyty_emulator
+          file _Build/macos/install/libMoltenVK.dylib
+          lipo _Build/macos/install/launcher -verify_arch x86_64
+          lipo _Build/macos/install/kyty_emulator -verify_arch x86_64
+          lipo _Build/macos/install/libMoltenVK.dylib -verify_arch x86_64
+          codesign --verify --strict _Build/macos/install/kyty_emulator
+          codesign --verify --strict _Build/macos/install/libMoltenVK.dylib
 
       - name: Upload macOS artifacts
         uses: actions/upload-artifact@v4
         with:
           name: KytyPS5-macOS-x86_64
-          path: ${{ runner.temp }}/KytyPS5-macOS-x86_64.zip
+          path: _Build/macos/install/**
           if-no-files-found: error
 
   linux:
     name: Build KytyPS5 (Linux)
-    needs: metadata
     runs-on: ubuntu-24.04
 
     steps:
@@ -330,13 +270,9 @@ jobs:
         shell: bash
         run: |
           mkdir -p _Build
-          cmake -S . -B _Build/linux \
+          cmake -S src -B _Build/linux \
             -G Ninja \
             -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
-            -DKYTY_BUILD_ORIGIN="$KYTY_BUILD_ORIGIN" \
-            -DKYTY_BUILD_REPOSITORY="$KYTY_BUILD_REPOSITORY" \
-            -DKYTY_RELEASE_TAG="${{ needs.metadata.outputs.release_tag }}" \
             -DCMAKE_C_COMPILER=clang \
             -DCMAKE_CXX_COMPILER=clang++ \
             -DCMAKE_PREFIX_PATH="$Qt6_DIR" 2>&1 | tee _Build/configure.log
@@ -361,14 +297,14 @@ jobs:
         run: |
           cmake --build _Build/linux \
             --target launcher page_manager_tests memory_tracker_tests \
-              audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests \
+              virtual_memory_allocation_tests \
             --parallel
 
       - name: Test
         shell: bash
         run: |
           ctest --test-dir _Build/linux --output-on-failure \
-            -R '^(audio_out2_port|ime_dialog|page_manager|memory_tracker|virtual_memory_allocation)$'
+            -R '^(page_manager|memory_tracker|virtual_memory_allocation)$'
 
       - name: Install
         shell: bash
@@ -405,70 +341,46 @@ jobs:
 
   release:
     name: Release KytyPS5
-    if: >-
-      always() &&
-      github.event_name == 'push' &&
-      github.repository == 'KytyPS5/KytyPS5' &&
-      (needs.windows.result == 'success' ||
-       needs.macos.result == 'success' ||
-       needs.linux.result == 'success')
-    needs: [metadata, windows, macos, linux]
+    if: github.event_name == 'push' && github.repository == 'KytyPS5/KytyPS5'
+    needs: [windows, macos, linux]
     runs-on: ubuntu-latest
     permissions:
       contents: write
-    env:
-      RELEASE_NAME: ${{ needs.metadata.outputs.release_tag }}
 
     steps:
-      - name: Download Windows build
-        if: needs.windows.result == 'success'
+      - name: Download builds
         uses: actions/download-artifact@v4
         with:
-          name: KytyPS5-Windows-x64
-          path: artifacts/KytyPS5-Windows-x64
+          path: artifacts
 
-      - name: Download macOS build
-        if: needs.macos.result == 'success'
-        uses: actions/download-artifact@v4
-        with:
-          name: KytyPS5-macOS-x86_64
-          path: artifacts/KytyPS5-macOS-x86_64
+      - name: Set release name
+        shell: bash
+        run: |
+          echo "RELEASE_NAME=KytyPS5-$(date -u +'%Y-%m-%d')-${GITHUB_SHA::7}" >> "$GITHUB_ENV"
 
-      - name: Download Linux build
-        if: needs.linux.result == 'success'
-        uses: actions/download-artifact@v4
-        with:
-          name: KytyPS5-Linux-x86_64
-          path: artifacts/KytyPS5-Linux-x86_64
-
-      - name: Package Windows build
-        if: needs.windows.result == 'success'
+      - name: Package builds
         shell: bash
         run: |
           windows_dir="artifacts/KytyPS5-Windows-x64"
+          macos_dir="artifacts/KytyPS5-macOS-x86_64"
+          linux_dir="artifacts/KytyPS5-Linux-x86_64"
           test -d "$windows_dir"
+          test -d "$macos_dir"
+          test -d "$linux_dir"
+          chmod a+x \
+            "$macos_dir/launcher" \
+            "$macos_dir/kyty_emulator" \
+            "$macos_dir/libMoltenVK.dylib" \
+            "$linux_dir/launcher" \
+            "$linux_dir/kyty_emulator"
           (
             cd "$windows_dir"
             zip -r "$GITHUB_WORKSPACE/$RELEASE_NAME-Windows-x64.zip" .
           )
-
-      - name: Package macOS build
-        if: needs.macos.result == 'success'
-        shell: bash
-        run: |
-          macos_archive="artifacts/KytyPS5-macOS-x86_64/KytyPS5-macOS-x86_64.zip"
-          test -f "$macos_archive"
-          cp "$macos_archive" "$RELEASE_NAME-macOS-x86_64.zip"
-
-      - name: Package Linux build
-        if: needs.linux.result == 'success'
-        shell: bash
-        run: |
-          linux_dir="artifacts/KytyPS5-Linux-x86_64"
-          test -d "$linux_dir"
-          chmod a+x \
-            "$linux_dir/launcher" \
-            "$linux_dir/kyty_emulator"
+          (
+            cd "$macos_dir"
+            zip -r "$GITHUB_WORKSPACE/$RELEASE_NAME-macOS-x86_64.zip" .
+          )
           tar -C "$linux_dir" -czf \
             "$GITHUB_WORKSPACE/$RELEASE_NAME-Linux-x86_64.tar.gz" .
 
@@ -477,16 +389,11 @@ jobs:
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
-          assets=()
-          for artifact in \
-            "$RELEASE_NAME-Windows-x64.zip" \
-            "$RELEASE_NAME-macOS-x86_64.zip" \
-            "$RELEASE_NAME-Linux-x86_64.tar.gz"; do
-            if [[ -f "$artifact" ]]; then
-              assets+=("$artifact")
-            fi
-          done
-          test "${#assets[@]}" -gt 0
+          assets=(
+            "$RELEASE_NAME-Windows-x64.zip"
+            "$RELEASE_NAME-macOS-x86_64.zip"
+            "$RELEASE_NAME-Linux-x86_64.tar.gz"
+          )
           if gh release view "$RELEASE_NAME" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then
             gh release upload "$RELEASE_NAME" "${assets[@]}" \
               --clobber \

.gitignore

@@ -3,6 +3,4 @@
 .idea/
 build/
 _Build/vscode-clang/
-_Build/
-cmake-build-debug/
-_PipelineCache/
+_Build/

.gitmodules

@@ -39,6 +39,3 @@
 [submodule "3rdparty/nlohmann_json"]
 	path = 3rdparty/nlohmann_json
 	url = https://github.com/nlohmann/json.git
-[submodule "3rdparty/imgui"]
-	path = 3rdparty/imgui
-	url = https://github.com/ocornut/imgui.git

.vscode/launch.json

@@ -10,14 +10,7 @@
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}\\_Build\\vscode-clang\\launcher",
             "environment": [],
-            "externalConsole": false,
-            "linux": {
-                "type": "cppdbg",
-                "program": "${workspaceFolder}/_Build/vscode-clang/launcher/launcher",
-                "cwd": "${workspaceFolder}/_Build/vscode-clang/launcher",
-                "MIMode": "gdb",
-                "miDebuggerPath": "/usr/bin/gdb"
-            }
+            "externalConsole": false
         },
         {
             "name": "Debug kyty_emulator",
@@ -32,40 +25,13 @@
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}\\_Build\\vscode-clang",
             "environment": [],
-            "externalConsole": true,
-            "linux": {
-                "type": "cppdbg",
-                "program": "${workspaceFolder}/_Build/vscode-clang/kyty_emulator",
-                "cwd": "${workspaceFolder}/_Build/vscode-clang",
-                "externalConsole": false,
-                "MIMode": "gdb",
-                "miDebuggerPath": "/usr/bin/gdb",
-                "setupCommands": [
-                    {
-                        "description": "Pass Kyty's internal signals to its handlers",
-                        "text": "handle SIG37 SIGSEGV SIGBUS SIGILL nostop noprint pass",
-                        "ignoreFailures": false
-                    }
-                ]
-            }
+            "externalConsole": true
         },
         {
             "name": "Attach to running kyty_emulator",
             "type": "cppvsdbg",
             "request": "attach",
-            "processId": "${command:pickProcess}",
-            "linux": {
-                "type": "cppdbg",
-                "MIMode": "gdb",
-                "miDebuggerPath": "/usr/bin/gdb",
-                "setupCommands": [
-                    {
-                        "description": "Pass Kyty's internal signals to its handlers",
-                        "text": "handle SIG37 SIGSEGV SIGBUS SIGILL nostop noprint pass",
-                        "ignoreFailures": false
-                    }
-                ]
-            }
+            "processId": "${command:pickProcess}"
         }
     ]
 }

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-    "cmake.sourceDirectory": "${workspaceFolder}",
+    "cmake.sourceDirectory": "${workspaceFolder}/src",
     "cmake.buildDirectory": "${workspaceFolder}/_Build/vscode-clang",
     "cmake.generator": "Ninja",
     "cmake.environment": {

3rdparty/CMakeLists.txt

@@ -2,32 +2,6 @@ set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
 
 add_subdirectory(cpuinfo)
 
-# The Windows guest red-zone patcher needs a decoder/encoder and a small
-# trampoline assembler. Pin the same revisions used by shadPS4's implementation.
-include(FetchContent)
-
-set(XBYAK_BUILD_TESTS OFF CACHE BOOL "" FORCE)
-FetchContent_Declare(
-	xbyak
-	GIT_REPOSITORY https://github.com/herumi/xbyak.git
-	GIT_TAG 44a72f369268f7d552650891b296693e91db86bb
-	GIT_SHALLOW FALSE
-)
-
-set(ZYDIS_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
-set(ZYDIS_BUILD_TOOLS OFF CACHE BOOL "" FORCE)
-set(ZYDIS_BUILD_TESTS OFF CACHE BOOL "" FORCE)
-set(ZYDIS_BUILD_DOXYGEN OFF CACHE BOOL "" FORCE)
-FetchContent_Declare(
-	zydis
-	GIT_REPOSITORY https://github.com/zyantific/zydis.git
-	GIT_TAG 120e0e705f8e3b507dc49377ac2879979f0d545c
-	GIT_SUBMODULES_RECURSE TRUE
-	GIT_SHALLOW FALSE
-)
-
-FetchContent_MakeAvailable(xbyak zydis)
-
 set(SDL_SHARED OFF CACHE BOOL "" FORCE)
 add_subdirectory(SDL2)
 
@@ -37,25 +11,6 @@ target_include_directories(Vulkan-Headers INTERFACE
 	"${CMAKE_CURRENT_SOURCE_DIR}/Vulkan-Headers/include"
 )
 
-add_library(imgui STATIC
-	imgui/imgui.cpp
-	imgui/imgui_draw.cpp
-	imgui/imgui_tables.cpp
-	imgui/imgui_widgets.cpp
-	imgui/backends/imgui_impl_vulkan.cpp
-)
-target_include_directories(imgui PUBLIC
-	"${CMAKE_CURRENT_SOURCE_DIR}/imgui"
-	"${CMAKE_CURRENT_SOURCE_DIR}/imgui/backends"
-)
-target_compile_definitions(imgui PRIVATE IMGUI_IMPL_VULKAN_NO_PROTOTYPES)
-target_link_libraries(imgui PUBLIC Vulkan::Headers)
-if(MSVC)
-	target_compile_options(imgui PRIVATE /W0)
-else()
-	target_compile_options(imgui PRIVATE -w)
-endif()
-
 set(SPIRV_SKIP_TESTS ON CACHE BOOL "" FORCE)
 set(SPIRV_SKIP_EXECUTABLES ON CACHE BOOL "" FORCE)
 set(SKIP_SPIRV_TOOLS_INSTALL ON CACHE BOOL "" FORCE)

3rdparty/renderdoc/renderdoc_app.h

@@ -1,875 +0,0 @@
-/******************************************************************************
- * The MIT License (MIT)
- *
- * Copyright (c) 2015-2026 Baldur Karlsson
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- ******************************************************************************/
-
-#pragma once
-
-//////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// Documentation for the API is available at https://renderdoc.org/docs/in_application_api.html
-//
-
-#if !defined(RENDERDOC_NO_STDINT)
-#include <stdint.h>
-#endif
-
-#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
-#define RENDERDOC_CC __cdecl
-#elif defined(__linux__) || defined(__FreeBSD__) || defined(__sun__) || defined(__OpenBSD__)
-#define RENDERDOC_CC
-#elif defined(__APPLE__)
-#define RENDERDOC_CC
-#else
-#error "Unknown platform"
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// Constants not used directly in below API
-
-// This is a GUID/magic value used for when applications pass a path where shader debug
-// information can be found to match up with a stripped shader.
-// the define can be used like so: const GUID RENDERDOC_ShaderDebugMagicValue =
-// RENDERDOC_ShaderDebugMagicValue_value
-#define RENDERDOC_ShaderDebugMagicValue_struct                                \
-  {                                                                           \
-    0xeab25520, 0x6670, 0x4865, 0x84, 0x29, 0x6c, 0x8, 0x51, 0x54, 0x00, 0xff \
-  }
-
-// as an alternative when you want a byte array (assuming x86 endianness):
-#define RENDERDOC_ShaderDebugMagicValue_bytearray                                                 \
-  {                                                                                               \
-    0x20, 0x55, 0xb2, 0xea, 0x70, 0x66, 0x65, 0x48, 0x84, 0x29, 0x6c, 0x8, 0x51, 0x54, 0x00, 0xff \
-  }
-
-// truncated version when only a uint64_t is available (e.g. Vulkan tags):
-#define RENDERDOC_ShaderDebugMagicValue_truncated 0x48656670eab25520ULL
-
-// this is a magic value for vulkan user tags to indicate which dispatchable API objects are which
-// for object annotations
-#define RENDERDOC_APIObjectAnnotationHelper 0xfbb3b337b664d0adULL
-
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// RenderDoc capture options
-//
-
-typedef enum RENDERDOC_CaptureOption
-{
-  // Allow the application to enable vsync
-  //
-  // Default - enabled
-  //
-  // 1 - The application can enable or disable vsync at will
-  // 0 - vsync is force disabled
-  eRENDERDOC_Option_AllowVSync = 0,
-
-  // Allow the application to enable fullscreen
-  //
-  // Default - enabled
-  //
-  // 1 - The application can enable or disable fullscreen at will
-  // 0 - fullscreen is force disabled
-  eRENDERDOC_Option_AllowFullscreen = 1,
-
-  // Record API debugging events and messages
-  //
-  // Default - disabled
-  //
-  // 1 - Enable built-in API debugging features and records the results into
-  //     the capture, which is matched up with events on replay
-  // 0 - no API debugging is forcibly enabled
-  eRENDERDOC_Option_APIValidation = 2,
-  eRENDERDOC_Option_DebugDeviceMode = 2,    // deprecated name of this enum
-
-  // Capture CPU callstacks for API events
-  //
-  // Default - disabled
-  //
-  // 1 - Enables capturing of callstacks
-  // 0 - no callstacks are captured
-  eRENDERDOC_Option_CaptureCallstacks = 3,
-
-  // When capturing CPU callstacks, only capture them from actions.
-  // This option does nothing without the above option being enabled
-  //
-  // Default - disabled
-  //
-  // 1 - Only captures callstacks for actions.
-  //     Ignored if CaptureCallstacks is disabled
-  // 0 - Callstacks, if enabled, are captured for every event.
-  eRENDERDOC_Option_CaptureCallstacksOnlyDraws = 4,
-  eRENDERDOC_Option_CaptureCallstacksOnlyActions = 4,
-
-  // Specify a delay in seconds to wait for a debugger to attach, after
-  // creating or injecting into a process, before continuing to allow it to run.
-  //
-  // 0 indicates no delay, and the process will run immediately after injection
-  //
-  // Default - 0 seconds
-  //
-  eRENDERDOC_Option_DelayForDebugger = 5,
-
-  // Verify buffer access. This includes checking the memory returned by a Map() call to
-  // detect any out-of-bounds modification, as well as initialising buffers with undefined contents
-  // to a marker value to catch use of uninitialised memory.
-  //
-  // NOTE: This option is only valid for OpenGL and D3D11. Explicit APIs such as D3D12 and Vulkan do
-  // not do the same kind of interception & checking and undefined contents are really undefined.
-  //
-  // Default - disabled
-  //
-  // 1 - Verify buffer access
-  // 0 - No verification is performed, and overwriting bounds may cause crashes or corruption in
-  //     RenderDoc.
-  eRENDERDOC_Option_VerifyBufferAccess = 6,
-
-  // The old name for eRENDERDOC_Option_VerifyBufferAccess was eRENDERDOC_Option_VerifyMapWrites.
-  // This option now controls the filling of uninitialised buffers with 0xdddddddd which was
-  // previously always enabled
-  eRENDERDOC_Option_VerifyMapWrites = eRENDERDOC_Option_VerifyBufferAccess,
-
-  // Hooks any system API calls that create child processes, and injects
-  // RenderDoc into them recursively with the same options.
-  //
-  // Default - disabled
-  //
-  // 1 - Hooks into spawned child processes
-  // 0 - Child processes are not hooked by RenderDoc
-  eRENDERDOC_Option_HookIntoChildren = 7,
-
-  // By default RenderDoc only includes resources in the final capture necessary
-  // for that frame, this allows you to override that behaviour.
-  //
-  // Default - disabled
-  //
-  // 1 - all live resources at the time of capture are included in the capture
-  //     and available for inspection
-  // 0 - only the resources referenced by the captured frame are included
-  eRENDERDOC_Option_RefAllResources = 8,
-
-  // **NOTE**: As of RenderDoc v1.1 this option has been deprecated. Setting or
-  // getting it will be ignored, to allow compatibility with older versions.
-  // In v1.1 the option acts as if it's always enabled.
-  //
-  // By default RenderDoc skips saving initial states for resources where the
-  // previous contents don't appear to be used, assuming that writes before
-  // reads indicate previous contents aren't used.
-  //
-  // Default - disabled
-  //
-  // 1 - initial contents at the start of each captured frame are saved, even if
-  //     they are later overwritten or cleared before being used.
-  // 0 - unless a read is detected, initial contents will not be saved and will
-  //     appear as black or empty data.
-  eRENDERDOC_Option_SaveAllInitials = 9,
-
-  // In APIs that allow for the recording of command lists to be replayed later,
-  // RenderDoc may choose to not capture command lists before a frame capture is
-  // triggered, to reduce overheads. This means any command lists recorded once
-  // and replayed many times will not be available and may cause a failure to
-  // capture.
-  //
-  // NOTE: This is only true for APIs where multithreading is difficult or
-  // discouraged. Newer APIs like Vulkan and D3D12 will ignore this option
-  // and always capture all command lists since the API is heavily oriented
-  // around it and the overheads have been reduced by API design.
-  //
-  // 1 - All command lists are captured from the start of the application
-  // 0 - Command lists are only captured if their recording begins during
-  //     the period when a frame capture is in progress.
-  eRENDERDOC_Option_CaptureAllCmdLists = 10,
-
-  // Mute API debugging output when the API validation mode option is enabled
-  //
-  // Default - enabled
-  //
-  // 1 - Mute any API debug messages from being displayed or passed through
-  // 0 - API debugging is displayed as normal
-  eRENDERDOC_Option_DebugOutputMute = 11,
-
-  // Option to allow vendor extensions to be used even when they may be
-  // incompatible with RenderDoc and cause corrupted replays or crashes.
-  //
-  // Default - inactive
-  //
-  // No values are documented, this option should only be used when absolutely
-  // necessary as directed by a RenderDoc developer.
-  eRENDERDOC_Option_AllowUnsupportedVendorExtensions = 12,
-
-  // Define a soft memory limit which some APIs may aim to keep overhead under where
-  // possible. Anything above this limit will where possible be saved directly to disk during
-  // capture.
-  // This will cause increased disk space use (which may cause a capture to fail if disk space is
-  // exhausted) as well as slower capture times.
-  //
-  // Not all memory allocations may be deferred like this so it is not a guarantee of a memory
-  // limit.
-  //
-  // Units are in MBs, suggested values would range from 200MB to 1000MB.
-  //
-  // Default - 0 Megabytes
-  eRENDERDOC_Option_SoftMemoryLimit = 13,
-} RENDERDOC_CaptureOption;
-
-// Sets an option that controls how RenderDoc behaves on capture.
-//
-// Returns 1 if the option and value are valid
-// Returns 0 if either is invalid and the option is unchanged
-typedef int(RENDERDOC_CC *pRENDERDOC_SetCaptureOptionU32)(RENDERDOC_CaptureOption opt, uint32_t val);
-typedef int(RENDERDOC_CC *pRENDERDOC_SetCaptureOptionF32)(RENDERDOC_CaptureOption opt, float val);
-
-// Gets the current value of an option as a uint32_t
-//
-// If the option is invalid, 0xffffffff is returned
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetCaptureOptionU32)(RENDERDOC_CaptureOption opt);
-
-// Gets the current value of an option as a float
-//
-// If the option is invalid, -FLT_MAX is returned
-typedef float(RENDERDOC_CC *pRENDERDOC_GetCaptureOptionF32)(RENDERDOC_CaptureOption opt);
-
-typedef enum RENDERDOC_InputButton
-{
-  // '0' - '9' matches ASCII values
-  eRENDERDOC_Key_0 = 0x30,
-  eRENDERDOC_Key_1 = 0x31,
-  eRENDERDOC_Key_2 = 0x32,
-  eRENDERDOC_Key_3 = 0x33,
-  eRENDERDOC_Key_4 = 0x34,
-  eRENDERDOC_Key_5 = 0x35,
-  eRENDERDOC_Key_6 = 0x36,
-  eRENDERDOC_Key_7 = 0x37,
-  eRENDERDOC_Key_8 = 0x38,
-  eRENDERDOC_Key_9 = 0x39,
-
-  // 'A' - 'Z' matches ASCII values
-  eRENDERDOC_Key_A = 0x41,
-  eRENDERDOC_Key_B = 0x42,
-  eRENDERDOC_Key_C = 0x43,
-  eRENDERDOC_Key_D = 0x44,
-  eRENDERDOC_Key_E = 0x45,
-  eRENDERDOC_Key_F = 0x46,
-  eRENDERDOC_Key_G = 0x47,
-  eRENDERDOC_Key_H = 0x48,
-  eRENDERDOC_Key_I = 0x49,
-  eRENDERDOC_Key_J = 0x4A,
-  eRENDERDOC_Key_K = 0x4B,
-  eRENDERDOC_Key_L = 0x4C,
-  eRENDERDOC_Key_M = 0x4D,
-  eRENDERDOC_Key_N = 0x4E,
-  eRENDERDOC_Key_O = 0x4F,
-  eRENDERDOC_Key_P = 0x50,
-  eRENDERDOC_Key_Q = 0x51,
-  eRENDERDOC_Key_R = 0x52,
-  eRENDERDOC_Key_S = 0x53,
-  eRENDERDOC_Key_T = 0x54,
-  eRENDERDOC_Key_U = 0x55,
-  eRENDERDOC_Key_V = 0x56,
-  eRENDERDOC_Key_W = 0x57,
-  eRENDERDOC_Key_X = 0x58,
-  eRENDERDOC_Key_Y = 0x59,
-  eRENDERDOC_Key_Z = 0x5A,
-
-  // leave the rest of the ASCII range free
-  // in case we want to use it later
-  eRENDERDOC_Key_NonPrintable = 0x100,
-
-  eRENDERDOC_Key_Divide,
-  eRENDERDOC_Key_Multiply,
-  eRENDERDOC_Key_Subtract,
-  eRENDERDOC_Key_Plus,
-
-  eRENDERDOC_Key_F1,
-  eRENDERDOC_Key_F2,
-  eRENDERDOC_Key_F3,
-  eRENDERDOC_Key_F4,
-  eRENDERDOC_Key_F5,
-  eRENDERDOC_Key_F6,
-  eRENDERDOC_Key_F7,
-  eRENDERDOC_Key_F8,
-  eRENDERDOC_Key_F9,
-  eRENDERDOC_Key_F10,
-  eRENDERDOC_Key_F11,
-  eRENDERDOC_Key_F12,
-
-  eRENDERDOC_Key_Home,
-  eRENDERDOC_Key_End,
-  eRENDERDOC_Key_Insert,
-  eRENDERDOC_Key_Delete,
-  eRENDERDOC_Key_PageUp,
-  eRENDERDOC_Key_PageDn,
-
-  eRENDERDOC_Key_Backspace,
-  eRENDERDOC_Key_Tab,
-  eRENDERDOC_Key_PrtScrn,
-  eRENDERDOC_Key_Pause,
-
-  eRENDERDOC_Key_Max,
-} RENDERDOC_InputButton;
-
-// Sets which key or keys can be used to toggle focus between multiple windows
-//
-// If keys is NULL or num is 0, toggle keys will be disabled
-typedef void(RENDERDOC_CC *pRENDERDOC_SetFocusToggleKeys)(RENDERDOC_InputButton *keys, int num);
-
-// Sets which key or keys can be used to capture the next frame
-//
-// If keys is NULL or num is 0, captures keys will be disabled
-typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureKeys)(RENDERDOC_InputButton *keys, int num);
-
-typedef enum RENDERDOC_OverlayBits
-{
-  // This single bit controls whether the overlay is enabled or disabled globally
-  eRENDERDOC_Overlay_Enabled = 0x1,
-
-  // Show the average framerate over several seconds as well as min/max
-  eRENDERDOC_Overlay_FrameRate = 0x2,
-
-  // Show the current frame number
-  eRENDERDOC_Overlay_FrameNumber = 0x4,
-
-  // Show a list of recent captures, and how many captures have been made
-  eRENDERDOC_Overlay_CaptureList = 0x8,
-
-  // Default values for the overlay mask
-  eRENDERDOC_Overlay_Default = (eRENDERDOC_Overlay_Enabled | eRENDERDOC_Overlay_FrameRate |
-                                eRENDERDOC_Overlay_FrameNumber | eRENDERDOC_Overlay_CaptureList),
-
-  // Enable all bits
-  eRENDERDOC_Overlay_All = 0x7ffffff,
-
-  // Disable all bits
-  eRENDERDOC_Overlay_None = 0,
-} RENDERDOC_OverlayBits;
-
-// returns the overlay bits that have been set
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetOverlayBits)(void);
-// sets the overlay bits with an and & or mask
-typedef void(RENDERDOC_CC *pRENDERDOC_MaskOverlayBits)(uint32_t And, uint32_t Or);
-
-// this function will attempt to remove RenderDoc's hooks in the application.
-//
-// Note: that this can only work correctly if done immediately after
-// the module is loaded, before any API work happens. RenderDoc will remove its
-// injected hooks and shut down. Behaviour is undefined if this is called
-// after any API functions have been called, and there is still no guarantee of
-// success.
-typedef void(RENDERDOC_CC *pRENDERDOC_RemoveHooks)(void);
-
-// DEPRECATED: compatibility for code compiled against pre-1.4.1 headers.
-typedef pRENDERDOC_RemoveHooks pRENDERDOC_Shutdown;
-
-// This function will unload RenderDoc's crash handler.
-//
-// If you use your own crash handler and don't want RenderDoc's handler to
-// intercede, you can call this function to unload it and any unhandled
-// exceptions will pass to the next handler.
-typedef void(RENDERDOC_CC *pRENDERDOC_UnloadCrashHandler)(void);
-
-// Sets the capture file path template
-//
-// pathtemplate is a UTF-8 string that gives a template for how captures will be named
-// and where they will be saved.
-//
-// Any extension is stripped off the path, and captures are saved in the directory
-// specified, and named with the filename and the frame number appended. If the
-// directory does not exist it will be created, including any parent directories.
-//
-// If pathtemplate is NULL, the template will remain unchanged
-//
-// Example:
-//
-// SetCaptureFilePathTemplate("my_captures/example");
-//
-// Capture #1 -> my_captures/example_frame123.rdc
-// Capture #2 -> my_captures/example_frame456.rdc
-typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureFilePathTemplate)(const char *pathtemplate);
-
-// returns the current capture path template, see SetCaptureFileTemplate above, as a UTF-8 string
-typedef const char *(RENDERDOC_CC *pRENDERDOC_GetCaptureFilePathTemplate)(void);
-
-// DEPRECATED: compatibility for code compiled against pre-1.1.2 headers.
-typedef pRENDERDOC_SetCaptureFilePathTemplate pRENDERDOC_SetLogFilePathTemplate;
-typedef pRENDERDOC_GetCaptureFilePathTemplate pRENDERDOC_GetLogFilePathTemplate;
-
-// returns the number of captures that have been made
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetNumCaptures)(void);
-
-// This function returns the details of a capture, by index. New captures are added
-// to the end of the list.
-//
-// filename will be filled with the absolute path to the capture file, as a UTF-8 string
-// pathlength will be written with the length in bytes of the filename string
-// timestamp will be written with the time of the capture, in seconds since the Unix epoch
-//
-// Any of the parameters can be NULL and they'll be skipped.
-//
-// The function will return 1 if the capture index is valid, or 0 if the index is invalid
-// If the index is invalid, the values will be unchanged
-//
-// Note: when captures are deleted in the UI they will remain in this list, so the
-// capture path may not exist anymore.
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetCapture)(uint32_t idx, char *filename,
-                                                      uint32_t *pathlength, uint64_t *timestamp);
-
-// Sets the comments associated with a capture file. These comments are displayed in the
-// UI program when opening.
-//
-// filePath should be a path to the capture file to add comments to. If set to NULL or ""
-// the most recent capture file created made will be used instead.
-// comments should be a NULL-terminated UTF-8 string to add as comments.
-//
-// Any existing comments will be overwritten.
-typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureFileComments)(const char *filePath,
-                                                              const char *comments);
-
-// returns 1 if the RenderDoc UI is connected to this application, 0 otherwise
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_IsTargetControlConnected)(void);
-
-// DEPRECATED: compatibility for code compiled against pre-1.1.1 headers.
-// This was renamed to IsTargetControlConnected in API 1.1.1, the old typedef is kept here for
-// backwards compatibility with old code, it is castable either way since it's ABI compatible
-// as the same function pointer type.
-typedef pRENDERDOC_IsTargetControlConnected pRENDERDOC_IsRemoteAccessConnected;
-
-// This function will launch the Replay UI associated with the RenderDoc library injected
-// into the running application.
-//
-// if connectTargetControl is 1, the Replay UI will be launched with a command line parameter
-// to connect to this application
-// cmdline is the rest of the command line, as a UTF-8 string. E.g. a captures to open
-// if cmdline is NULL, the command line will be empty.
-//
-// returns the PID of the replay UI if successful, 0 if not successful.
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_LaunchReplayUI)(uint32_t connectTargetControl,
-                                                          const char *cmdline);
-
-// RenderDoc can return a higher version than requested if it's backwards compatible,
-// this function returns the actual version returned. If a parameter is NULL, it will be
-// ignored and the others will be filled out.
-typedef void(RENDERDOC_CC *pRENDERDOC_GetAPIVersion)(int *major, int *minor, int *patch);
-
-// Requests that the replay UI show itself (if hidden or not the current top window). This can be
-// used in conjunction with IsTargetControlConnected and LaunchReplayUI to intelligently handle
-// showing the UI after making a capture.
-//
-// This will return 1 if the request was successfully passed on, though it's not guaranteed that
-// the UI will be on top in all cases depending on OS rules. It will return 0 if there is no current
-// target control connection to make such a request, or if there was another error
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_ShowReplayUI)(void);
-
-//////////////////////////////////////////////////////////////////////////
-// Capturing functions
-//
-
-// A device pointer is a pointer to the API's root handle.
-//
-// This would be an ID3D11Device, HGLRC/GLXContext, ID3D12Device, etc
-typedef void *RENDERDOC_DevicePointer;
-
-// A window handle is the OS's native window handle
-//
-// This would be an HWND, GLXDrawable, etc
-typedef void *RENDERDOC_WindowHandle;
-
-// A helper macro for Vulkan, where the device handle cannot be used directly.
-//
-// Passing the VkInstance to this macro will return the RENDERDOC_DevicePointer to use.
-//
-// Specifically, the value needed is the dispatch table pointer, which sits as the first
-// pointer-sized object in the memory pointed to by the VkInstance. Thus we cast to a void** and
-// indirect once.
-#define RENDERDOC_DEVICEPOINTER_FROM_VKINSTANCE(inst) (*((void **)(inst)))
-
-// This sets the RenderDoc in-app overlay in the API/window pair as 'active' and it will
-// respond to keypresses. Neither parameter can be NULL
-typedef void(RENDERDOC_CC *pRENDERDOC_SetActiveWindow)(RENDERDOC_DevicePointer device,
-                                                       RENDERDOC_WindowHandle wndHandle);
-
-// capture the next frame on whichever window and API is currently considered active
-typedef void(RENDERDOC_CC *pRENDERDOC_TriggerCapture)(void);
-
-// capture the next N frames on whichever window and API is currently considered active
-typedef void(RENDERDOC_CC *pRENDERDOC_TriggerMultiFrameCapture)(uint32_t numFrames);
-
-// When choosing either a device pointer or a window handle to capture, you can pass NULL.
-// Passing NULL specifies a 'wildcard' match against anything. This allows you to specify
-// any API rendering to a specific window, or a specific API instance rendering to any window,
-// or in the simplest case of one window and one API, you can just pass NULL for both.
-//
-// In either case, if there are two or more possible matching (device,window) pairs it
-// is undefined which one will be captured.
-//
-// Note: for headless rendering you can pass NULL for the window handle and either specify
-// a device pointer or leave it NULL as above.
-
-// Immediately starts capturing API calls on the specified device pointer and window handle.
-//
-// If there is no matching thing to capture (e.g. no supported API has been initialised),
-// this will do nothing.
-//
-// The results are undefined (including crashes) if two captures are started overlapping,
-// even on separate devices and/oror windows.
-typedef void(RENDERDOC_CC *pRENDERDOC_StartFrameCapture)(RENDERDOC_DevicePointer device,
-                                                         RENDERDOC_WindowHandle wndHandle);
-
-// Returns whether or not a frame capture is currently ongoing anywhere.
-//
-// This will return 1 if a capture is ongoing, and 0 if there is no capture running
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_IsFrameCapturing)(void);
-
-// Ends capturing immediately.
-//
-// This will return 1 if the capture succeeded, and 0 if there was an error capturing.
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_EndFrameCapture)(RENDERDOC_DevicePointer device,
-                                                           RENDERDOC_WindowHandle wndHandle);
-
-// Ends capturing immediately and discard any data stored without saving to disk.
-//
-// This will return 1 if the capture was discarded, and 0 if there was an error or no capture
-// was in progress
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_DiscardFrameCapture)(RENDERDOC_DevicePointer device,
-                                                               RENDERDOC_WindowHandle wndHandle);
-
-// Only valid to be called between a call to StartFrameCapture and EndFrameCapture. Gives a custom
-// title to the capture produced which will be displayed in the UI.
-//
-// If multiple captures are ongoing, this title will be applied to the first capture to end after
-// this call. The second capture to end will have no title, unless this function is called again.
-//
-// Calling this function has no effect if no capture is currently running, and if it is called
-// multiple times only the last title will be used.
-typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureTitle)(const char *title);
-
-// Annotations API:
-//
-// These functions allow you to specify annotations either on a per-command level, or a per-object
-// level.
-//
-// Basic types of annotations are supported, as well as vector versions and references to API objects.
-//
-// The annotations are stored as keys, with the key being a dot-separated path allowing arbitrary
-// nesting and user organisation. The keys are sorted in human order so `foo.2.bar` will be displayed
-// before `foo.10.bar` to allow creation of arrays if desired.
-//
-// Deleting an annotation can be done by assigning an empty value to it.
-
-// the type of an annotation value, or Empty to delete an annotation
-typedef enum RENDERDOC_AnnotationType
-{
-  eRENDERDOC_Empty,
-  eRENDERDOC_Bool,
-  eRENDERDOC_Int32,
-  eRENDERDOC_UInt32,
-  eRENDERDOC_Int64,
-  eRENDERDOC_UInt64,
-  eRENDERDOC_Float,
-  eRENDERDOC_Double,
-  eRENDERDOC_String,
-  eRENDERDOC_APIObject,
-  eRENDERDOC_AnnotationMax = 0x7FFFFFFF,
-} RENDERDOC_AnnotationType;
-
-// a union with vector annotation value data
-typedef union RENDERDOC_AnnotationVectorValue
-{
-  bool boolean[4];
-  int32_t int32[4];
-  int64_t int64[4];
-  uint32_t uint32[4];
-  uint64_t uint64[4];
-  float float32[4];
-  double float64[4];
-} RENDERDOC_AnnotationVectorValue;
-
-// a union with scalar annotation value data
-typedef union RENDERDOC_AnnotationValue
-{
-  bool boolean;
-  int32_t int32;
-  int64_t int64;
-  uint32_t uint32;
-  uint64_t uint64;
-  float float32;
-  double float64;
-
-  RENDERDOC_AnnotationVectorValue vector;
-
-  const char *string;
-  void *apiObject;
-} RENDERDOC_AnnotationValue;
-
-// a struct for specifying a GL object, as we don't have pointers we can use so instead we specify a
-// pointer to this struct giving both the type and the name
-typedef struct RENDERDOC_GLResourceReference
-{
-  // this is the same GLenum identifier as passed to glObjectLabel
-  uint32_t identifier;
-  uint32_t name;
-} GLResourceReference;
-
-// simple C++ helpers to avoid the need for a temporary objects for value passing and GL object specification
-#ifdef __cplusplus
-struct RDGLObjectHelper
-{
-  RENDERDOC_GLResourceReference gl;
-
-  RDGLObjectHelper(uint32_t identifier, uint32_t name)
-  {
-    gl.identifier = identifier;
-    gl.name = name;
-  }
-
-  operator RENDERDOC_GLResourceReference *() { return &gl; }
-};
-
-struct RDAnnotationHelper
-{
-  RENDERDOC_AnnotationValue val;
-
-  RDAnnotationHelper(bool b) { val.boolean = b; }
-  RDAnnotationHelper(int32_t i) { val.int32 = i; }
-  RDAnnotationHelper(int64_t i) { val.int64 = i; }
-  RDAnnotationHelper(uint32_t i) { val.uint32 = i; }
-  RDAnnotationHelper(uint64_t i) { val.uint64 = i; }
-  RDAnnotationHelper(float f) { val.float32 = f; }
-  RDAnnotationHelper(double d) { val.float64 = d; }
-  RDAnnotationHelper(const char *s) { val.string = s; }
-
-  operator RENDERDOC_AnnotationValue *() { return &val; }
-};
-#endif
-
-// The device is specified in the same way as other API calls that take a RENDERDOC_DevicePointer
-// to specify the device.
-//
-// The object or queue/commandbuffer will depend on the graphics API in question.
-//
-// Return value:
-// 0 - The annotation was applied successfully.
-// 1 - The device is unknown/invalid
-// 2 - The device is valid but the annotation is not supported for API-specific reasons, such as an
-//     unrecognised or invalid object or queue/commandbuffer
-// 3 - The call is ill-formed or invalid e.g. empty is specified with a value pointer, or non-empty
-//     is specified with a NULL value pointer
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_SetObjectAnnotation)(RENDERDOC_DevicePointer device,
-                                                               void *object, const char *key,
-                                                               RENDERDOC_AnnotationType valueType,
-                                                               uint32_t valueVectorWidth,
-                                                               const RENDERDOC_AnnotationValue *value);
-
-typedef uint32_t(RENDERDOC_CC *pRENDERDOC_SetCommandAnnotation)(
-    RENDERDOC_DevicePointer device, void *queueOrCommandBuffer, const char *key,
-    RENDERDOC_AnnotationType valueType, uint32_t valueVectorWidth,
-    const RENDERDOC_AnnotationValue *value);
-
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// RenderDoc API versions
-//
-
-// RenderDoc uses semantic versioning (http://semver.org/).
-//
-// MAJOR version is incremented when incompatible API changes happen.
-// MINOR version is incremented when functionality is added in a backwards-compatible manner.
-// PATCH version is incremented when backwards-compatible bug fixes happen.
-//
-// Note that this means the API returned can be higher than the one you might have requested.
-// e.g. if you are running against a newer RenderDoc that supports 1.0.1, it will be returned
-// instead of 1.0.0. You can check this with the GetAPIVersion entry point
-typedef enum RENDERDOC_Version
-{
-  eRENDERDOC_API_Version_1_0_0 = 10000,    // RENDERDOC_API_1_0_0 = 1 00 00
-  eRENDERDOC_API_Version_1_0_1 = 10001,    // RENDERDOC_API_1_0_1 = 1 00 01
-  eRENDERDOC_API_Version_1_0_2 = 10002,    // RENDERDOC_API_1_0_2 = 1 00 02
-  eRENDERDOC_API_Version_1_1_0 = 10100,    // RENDERDOC_API_1_1_0 = 1 01 00
-  eRENDERDOC_API_Version_1_1_1 = 10101,    // RENDERDOC_API_1_1_1 = 1 01 01
-  eRENDERDOC_API_Version_1_1_2 = 10102,    // RENDERDOC_API_1_1_2 = 1 01 02
-  eRENDERDOC_API_Version_1_2_0 = 10200,    // RENDERDOC_API_1_2_0 = 1 02 00
-  eRENDERDOC_API_Version_1_3_0 = 10300,    // RENDERDOC_API_1_3_0 = 1 03 00
-  eRENDERDOC_API_Version_1_4_0 = 10400,    // RENDERDOC_API_1_4_0 = 1 04 00
-  eRENDERDOC_API_Version_1_4_1 = 10401,    // RENDERDOC_API_1_4_1 = 1 04 01
-  eRENDERDOC_API_Version_1_4_2 = 10402,    // RENDERDOC_API_1_4_2 = 1 04 02
-  eRENDERDOC_API_Version_1_5_0 = 10500,    // RENDERDOC_API_1_5_0 = 1 05 00
-  eRENDERDOC_API_Version_1_6_0 = 10600,    // RENDERDOC_API_1_6_0 = 1 06 00
-  eRENDERDOC_API_Version_1_7_0 = 10700,    // RENDERDOC_API_1_7_0 = 1 07 00
-} RENDERDOC_Version;
-
-// API version changelog:
-//
-// 1.0.0 - initial release
-// 1.0.1 - Bugfix: IsFrameCapturing() was returning false for captures that were triggered
-//         by keypress or TriggerCapture, instead of Start/EndFrameCapture.
-// 1.0.2 - Refactor: Renamed eRENDERDOC_Option_DebugDeviceMode to eRENDERDOC_Option_APIValidation
-// 1.1.0 - Add feature: TriggerMultiFrameCapture(). Backwards compatible with 1.0.x since the new
-//         function pointer is added to the end of the struct, the original layout is identical
-// 1.1.1 - Refactor: Renamed remote access to target control (to better disambiguate from remote
-//         replay/remote server concept in replay UI)
-// 1.1.2 - Refactor: Renamed "log file" in function names to just capture, to clarify that these
-//         are captures and not debug logging files. This is the first API version in the v1.0
-//         branch.
-// 1.2.0 - Added feature: SetCaptureFileComments() to add comments to a capture file that will be
-//         displayed in the UI program on load.
-// 1.3.0 - Added feature: New capture option eRENDERDOC_Option_AllowUnsupportedVendorExtensions
-//         which allows users to opt-in to allowing unsupported vendor extensions to function.
-//         Should be used at the user's own risk.
-//         Refactor: Renamed eRENDERDOC_Option_VerifyMapWrites to
-//         eRENDERDOC_Option_VerifyBufferAccess, which now also controls initialisation to
-//         0xdddddddd of uninitialised buffer contents.
-// 1.4.0 - Added feature: DiscardFrameCapture() to discard a frame capture in progress and stop
-//         capturing without saving anything to disk.
-// 1.4.1 - Refactor: Renamed Shutdown to RemoveHooks to better clarify what is happening
-// 1.4.2 - Refactor: Renamed 'draws' to 'actions' in callstack capture option.
-// 1.5.0 - Added feature: ShowReplayUI() to request that the replay UI show itself if connected
-// 1.6.0 - Added feature: SetCaptureTitle() which can be used to set a title for a
-//         capture made with StartFrameCapture() or EndFrameCapture()
-// 1.7.0 - Added feature: SetObjectAnnotation() / SetCommandAnnotation() for adding rich
-//         annotations to objects and command streams
-
-typedef struct RENDERDOC_API_1_7_0
-{
-  pRENDERDOC_GetAPIVersion GetAPIVersion;
-
-  pRENDERDOC_SetCaptureOptionU32 SetCaptureOptionU32;
-  pRENDERDOC_SetCaptureOptionF32 SetCaptureOptionF32;
-
-  pRENDERDOC_GetCaptureOptionU32 GetCaptureOptionU32;
-  pRENDERDOC_GetCaptureOptionF32 GetCaptureOptionF32;
-
-  pRENDERDOC_SetFocusToggleKeys SetFocusToggleKeys;
-  pRENDERDOC_SetCaptureKeys SetCaptureKeys;
-
-  pRENDERDOC_GetOverlayBits GetOverlayBits;
-  pRENDERDOC_MaskOverlayBits MaskOverlayBits;
-
-  // Shutdown was renamed to RemoveHooks in 1.4.1.
-  // These unions allow old code to continue compiling without changes
-  union
-  {
-    pRENDERDOC_Shutdown Shutdown;
-    pRENDERDOC_RemoveHooks RemoveHooks;
-  };
-  pRENDERDOC_UnloadCrashHandler UnloadCrashHandler;
-
-  // Get/SetLogFilePathTemplate was renamed to Get/SetCaptureFilePathTemplate in 1.1.2.
-  // These unions allow old code to continue compiling without changes
-  union
-  {
-    // deprecated name
-    pRENDERDOC_SetLogFilePathTemplate SetLogFilePathTemplate;
-    // current name
-    pRENDERDOC_SetCaptureFilePathTemplate SetCaptureFilePathTemplate;
-  };
-  union
-  {
-    // deprecated name
-    pRENDERDOC_GetLogFilePathTemplate GetLogFilePathTemplate;
-    // current name
-    pRENDERDOC_GetCaptureFilePathTemplate GetCaptureFilePathTemplate;
-  };
-
-  pRENDERDOC_GetNumCaptures GetNumCaptures;
-  pRENDERDOC_GetCapture GetCapture;
-
-  pRENDERDOC_TriggerCapture TriggerCapture;
-
-  // IsRemoteAccessConnected was renamed to IsTargetControlConnected in 1.1.1.
-  // This union allows old code to continue compiling without changes
-  union
-  {
-    // deprecated name
-    pRENDERDOC_IsRemoteAccessConnected IsRemoteAccessConnected;
-    // current name
-    pRENDERDOC_IsTargetControlConnected IsTargetControlConnected;
-  };
-  pRENDERDOC_LaunchReplayUI LaunchReplayUI;
-
-  pRENDERDOC_SetActiveWindow SetActiveWindow;
-
-  pRENDERDOC_StartFrameCapture StartFrameCapture;
-  pRENDERDOC_IsFrameCapturing IsFrameCapturing;
-  pRENDERDOC_EndFrameCapture EndFrameCapture;
-
-  // new function in 1.1.0
-  pRENDERDOC_TriggerMultiFrameCapture TriggerMultiFrameCapture;
-
-  // new function in 1.2.0
-  pRENDERDOC_SetCaptureFileComments SetCaptureFileComments;
-
-  // new function in 1.4.0
-  pRENDERDOC_DiscardFrameCapture DiscardFrameCapture;
-
-  // new function in 1.5.0
-  pRENDERDOC_ShowReplayUI ShowReplayUI;
-
-  // new function in 1.6.0
-  pRENDERDOC_SetCaptureTitle SetCaptureTitle;
-
-  // new functions in 1.7.0
-  pRENDERDOC_SetObjectAnnotation SetObjectAnnotation;
-  pRENDERDOC_SetCommandAnnotation SetCommandAnnotation;
-} RENDERDOC_API_1_7_0;
-
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_0_0;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_0_1;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_0_2;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_1_0;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_1_1;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_1_2;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_2_0;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_3_0;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_4_0;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_4_1;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_4_2;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_5_0;
-typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_6_0;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// RenderDoc API entry point
-//
-// This entry point can be obtained via GetProcAddress/dlsym if RenderDoc is available.
-//
-// The name is the same as the typedef - "RENDERDOC_GetAPI"
-//
-// This function is not thread safe, and should not be called on multiple threads at once.
-// Ideally, call this once as early as possible in your application's startup, before doing
-// any API work, since some configuration functionality etc has to be done also before
-// initialising any APIs.
-//
-// Parameters:
-//   version is a single value from the RENDERDOC_Version above.
-//
-//   outAPIPointers will be filled out with a pointer to the corresponding struct of function
-//   pointers.
-//
-// Returns:
-//   1 - if the outAPIPointers has been filled with a pointer to the API struct requested
-//   0 - if the requested version is not supported or the arguments are invalid.
-//
-typedef int(RENDERDOC_CC *pRENDERDOC_GetAPI)(RENDERDOC_Version version, void **outAPIPointers);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif

README.md

@@ -31,9 +31,6 @@ macOS support is experimental. The emulator is built for x86-64 and runs on Appl
 Rosetta 2, with Vulkan provided by MoltenVK. A small number of titles have been verified in-game
 on Apple Silicon hardware; see [Building on macOS](#building-on-macos).
 
-Community game test results are available in the
-[KytyPS5 Compatibility List](https://kytyps5.github.io/).
-
 ## Bugs and Issues
 
 The project is in an early stage, so please be mindful when opening new issues. Expect crashes,
@@ -55,7 +52,7 @@ graphical glitches, low compatibility, and poor performance.
   <tr>
     <td align="center">
       <strong>Neptunia ReVerse</strong><br>
-      <img src="docs/screenshots/ps5-04.png" width="300" alt="Neptunia ReVerse running in KytyPS5">
+      <img src="docs/screenshots/ps5-04.png" width="300" alt="Minecraft Legends running in KytyPS5">
     </td>
     <td align="center">
       <strong>SILENT HILL: The Short Message</strong><br>
@@ -65,11 +62,11 @@ graphical glitches, low compatibility, and poor performance.
   <tr>
     <td align="center">
       <strong>Hellboy</strong><br>
-      <img src="docs/screenshots/ps5-02.png" width="300" alt="Hellboy running in KytyPS5">
+      <img src="docs/screenshots/ps5-02.png" width="300" alt="Disgaea 6 running in KytyPS5">
     </td>
     <td align="center">
       <strong>Paleo Pines</strong><br>
-      <img src="docs/screenshots/ps5-06.png" width="300" alt="Paleo Pines running in KytyPS5">
+      <img src="docs/screenshots/ps5-06.png" width="300" alt="Dreaming Sarah running in KytyPS5">
     </td>
   </tr>
 </table>
@@ -144,7 +141,7 @@ git submodule update --init --recursive
 Configure the project. Replace the Qt path with the version installed on your system:
 
 ```powershell
-cmake -S . -B _Build/windows -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_PREFIX_PATH="C:/Qt/6.x.x/msvc2022_64"
+cmake -S src -B _Build/windows -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_PREFIX_PATH="C:/Qt/6.x.x/msvc2022_64"
 ```
 
 Build the launcher and stage a runnable installation:
@@ -177,7 +174,7 @@ Qt 6 (Concurrent, Network, Widgets) is also required — either the distribution
 ```bash
 git submodule update --init --recursive
 
-cmake -S . -B _Build/linux -G Ninja -DCMAKE_BUILD_TYPE=Release \
+cmake -S src -B _Build/linux -G Ninja -DCMAKE_BUILD_TYPE=Release \
   -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ \
   -DCMAKE_PREFIX_PATH="$Qt6_DIR"
 
@@ -191,7 +188,7 @@ The install step copies the Qt libraries and plugins next to the binaries, so
 As on Windows, the MSVC compiler is not used; Clang is required. `cl.exe` is rejected at configure
 time.
 
-The CMake source root is the repository root.
+Note that the CMake source root is `src`, not the repository root.
 
 ### Building on macOS
 
@@ -210,7 +207,7 @@ Requirements:
 ```bash
 git submodule update --init --recursive
 
-cmake -S . -B _Build/macos -G Ninja -DCMAKE_BUILD_TYPE=Release \
+cmake -S src -B _Build/macos -G Ninja -DCMAKE_BUILD_TYPE=Release \
   -DCMAKE_OSX_ARCHITECTURES=x86_64 \
   -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ \
   -DCMAKE_PREFIX_PATH="$Qt6_DIR"
@@ -220,34 +217,17 @@ cmake --install _Build/macos --prefix _Build/macos/install
 ```
 
 The build re-signs `kyty_emulator` with the JIT entitlements it needs to execute translated
-guest code; no manual signing step is required. When the launcher is built, the install
-also produces `_Build/macos/install/KytyPS5.app` — double-click to launch the GUI.
-A flat `kyty_emulator` is kept for CLI usage.
+guest code; no manual signing step is required.
 
 Vulkan comes from MoltenVK. Download `MoltenVK-macos.tar` from the
 [MoltenVK releases](https://github.com/KhronosGroup/MoltenVK/releases), then copy
-`MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib` next to the flat `kyty_emulator`
-(and, for the bundle, into `KytyPS5.app/Contents/Frameworks/`) and ad-hoc sign it:
+`MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib` next to `kyty_emulator` and ad-hoc sign it:
 
 ```bash
 codesign --force --sign - _Build/macos/install/libMoltenVK.dylib
-# For the bundle (if present):
-codesign --force --sign - _Build/macos/install/KytyPS5.app/Contents/Frameworks/libMoltenVK.dylib
-codesign --force --sign - _Build/macos/install/KytyPS5.app
 ```
 
-Release archives already include a signed `libMoltenVK.dylib` (both flat and inside the bundle).
-
-### Regression tests
-
-Build every regression executable and run the registered tests with:
-
-```powershell
-cmake --build _Build/windows --target kyty_tests
-ctest --test-dir _Build/windows --output-on-failure
-```
-
-Use `_Build/linux` instead of `_Build/windows` for a Linux build.
+Release archives already include a signed `libMoltenVK.dylib`.
 
 ### Visual Studio Code
 
@@ -280,10 +260,6 @@ To use the graphical launcher:
 ./_Build/linux/install/launcher
 ```
 
-```bash
-open _Build/macos/install/KytyPS5.app  # or double-click in Finder
-```
-
 On first launch, add one or more game folders in the global settings. The launcher searches those
 folders recursively for game directories containing `eboot.bin`. Select a detected game and run it
 from the game list.
@@ -298,17 +274,12 @@ The emulator can also be started directly with a legally obtained game directory
 ./_Build/linux/install/kyty_emulator --game "/games/ExampleGame"
 ```
 
-On macOS, the adjacent flat or app-bundled `libMoltenVK.dylib` is found automatically; no
-environment variable is required:
+On macOS, point SDL at the MoltenVK library explicitly; the hardened runtime prevents it from
+being picked up from the executable's directory:
 
 ```bash
-./_Build/macos/install/kyty_emulator --game "/games/ExampleGame"
-```
-
-To override the Vulkan loader, set `SDL_VULKAN_LIBRARY`:
-
-```bash
-SDL_VULKAN_LIBRARY=/path/to/libMoltenVK.dylib ./kyty_emulator --game "/games/ExampleGame"
+cd _Build/macos/install
+SDL_VULKAN_LIBRARY="$PWD/libMoltenVK.dylib" ./kyty_emulator --game "/games/ExampleGame"
 ```
 
 Run `kyty_emulator --help` to see the available graphics, logging, validation, profiling, and

src/CMakeLists.txt

@@ -4,18 +4,8 @@ if(CMAKE_VERSION VERSION_GREATER_EQUAL 4.0)
 	set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "Minimum policy version for bundled dependencies")
 endif()
 
-get_property(KYTY_GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if(NOT KYTY_GENERATOR_IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
-	set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build" FORCE)
-	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS Debug Release RelWithDebInfo MinSizeRel)
-endif()
-
 project(Kyty)
 
-set(KYTY_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
-set(KYTY_TESTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests")
-set(KYTY_THIRD_PARTY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty")
-
 if(CMAKE_SYSTEM_NAME MATCHES ".*Linux")
 	set(LINUX TRUE)
 endif()
@@ -29,33 +19,12 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
 
-include("${KYTY_SOURCE_DIR}/utils.cmake")
+include(utils.cmake)
 include(CTest)
 
 option(KYTY_ENABLE_CLANG_TIDY "Run clang-tidy checks during builds" OFF)
 
-set(KYTY_BUILD_ORIGIN "Source" CACHE STRING "Build provenance shown in diagnostics")
-set_property(CACHE KYTY_BUILD_ORIGIN PROPERTY STRINGS Source Official Fork)
-if(NOT KYTY_BUILD_ORIGIN STREQUAL "Source" AND NOT KYTY_BUILD_ORIGIN STREQUAL "Official" AND
-   NOT KYTY_BUILD_ORIGIN STREQUAL "Fork")
-	message(FATAL_ERROR "KYTY_BUILD_ORIGIN must be Source, Official, or Fork")
-endif()
-
-set(KYTY_RELEASE_TAG "" CACHE STRING "Release tag embedded in official builds")
-set(KYTY_BUILD_REPOSITORY "" CACHE STRING "GitHub repository embedded in fork builds")
-set(KYTY_OFFICIAL_BUILD OFF)
-set(KYTY_FORK_BUILD OFF)
-if(KYTY_BUILD_ORIGIN STREQUAL "Official")
-	if(KYTY_RELEASE_TAG STREQUAL "")
-		message(FATAL_ERROR "Official builds require KYTY_RELEASE_TAG")
-	endif()
-	set(KYTY_OFFICIAL_BUILD ON)
-elseif(KYTY_BUILD_ORIGIN STREQUAL "Fork")
-	if(KYTY_BUILD_REPOSITORY STREQUAL "")
-		message(FATAL_ERROR "Fork builds require KYTY_BUILD_REPOSITORY")
-	endif()
-	set(KYTY_FORK_BUILD ON)
-endif()
+set(KYTY_THIRD_PARTY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty")
 
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 
@@ -128,40 +97,36 @@ endif()
 
 project(Kyty${KYTY_PROJECT_NAME}${CMAKE_BUILD_TYPE}${KYTY_COMPILER} VERSION 0.2.2)
 
-include_directories(
+include_directories(	
 	${KYTY_THIRD_PARTY_DIR}/gtest/include
 	${KYTY_THIRD_PARTY_DIR}/gtest
 	${KYTY_THIRD_PARTY_DIR}/fmt/include
 	${KYTY_THIRD_PARTY_DIR}/magic_enum/include/magic_enum
 	${PROJECT_BINARY_DIR}
-	${KYTY_SOURCE_DIR}
+	${CMAKE_CURRENT_SOURCE_DIR}
 )
 
 set(KYTY_VERSION "${PROJECT_VERSION}")
 
 configure_file(
-  ${KYTY_SOURCE_DIR}/cmake_config.h.in
+  ${PROJECT_SOURCE_DIR}/cmake_config.h.in
   ${PROJECT_BINARY_DIR}/cmake_config.h
   )
 
 find_package(Git)
-
-add_custom_target(KytyGitVersion
-	COMMAND ${CMAKE_COMMAND}
-		-D INPUT_FILE=${KYTY_SOURCE_DIR}/kytyGitVersion.h.in
-		-D OUTPUT_FILE=${PROJECT_BINARY_DIR}/kytyGitVersion.h
-		-D GIT_EXECUTABLE=${GIT_EXECUTABLE}
-		-D GIT_WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}
-		-P ${KYTY_SOURCE_DIR}/generate_version.cmake
-	BYPRODUCTS ${PROJECT_BINARY_DIR}/kytyGitVersion.h
+  
+add_custom_target( KytyGitVersion
+    COMMAND ${CMAKE_COMMAND} 
+	-D INPUT_FILE=${CMAKE_CURRENT_SOURCE_DIR}/kytyGitVersion.h.in
+    -D OUTPUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/kytyGitVersion.h
+	-D GIT_EXECUTABLE=${GIT_EXECUTABLE}
+	-D GIT_WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}
+	-P ${CMAKE_CURRENT_SOURCE_DIR}/generate_version.cmake
 	COMMENT "Generate kytyGitVersion.h"
 )
 
-add_library(kyty_git_version INTERFACE)
-add_dependencies(kyty_git_version KytyGitVersion)
-
 if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0.0)
-	list(APPEND KYTY_IWYU
+	list(APPEND KYTY_IWYU 
 		kyty_emulator
 		common
 		#launcher
@@ -174,62 +139,55 @@ if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0.0)
 endif()
 
 option(KYTY_BUILD_LAUNCHER "Build Qt launcher" ON)
-
-config_compiler_and_linker()
-
+  
+config_compiler_and_linker()  
+  
 add_subdirectory("${KYTY_THIRD_PARTY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/3rdparty")
-add_subdirectory("${KYTY_SOURCE_DIR}/common" "${CMAKE_CURRENT_BINARY_DIR}/common")
+add_subdirectory(common)
 
 file(GLOB kyty_emulator_src CONFIGURE_DEPENDS
-	"${KYTY_SOURCE_DIR}/libs/*.cpp"
-	"${KYTY_SOURCE_DIR}/libs/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/command_processor/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/command_processor/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/cache/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/cache/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/image/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/image/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/pipeline/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/pipeline/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/cfg/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/cfg/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/decode/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/decode/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/translate/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/translate/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/backend/spirv/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/backend/spirv/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/opcodes/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/opcodes/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/opcodes/*.inc"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/presentation/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/presentation/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/presentation/window/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/presentation/window/*.h"
-	"${KYTY_SOURCE_DIR}/kernel/*.cpp"
-	"${KYTY_SOURCE_DIR}/kernel/*.h"
-	"${KYTY_SOURCE_DIR}/loader/*.cpp"
-	"${KYTY_SOURCE_DIR}/loader/*.h"
+	libs/*.cpp
+	libs/*.h
+	graphics/*.cpp
+	graphics/*.h
+	graphics/guest_gpu/*.cpp
+	graphics/guest_gpu/*.h
+	graphics/guest_gpu/command_processor/*.cpp
+	graphics/guest_gpu/command_processor/*.h
+	graphics/host_gpu/*.cpp
+	graphics/host_gpu/*.h
+	graphics/host_gpu/renderer/*.cpp
+	graphics/host_gpu/renderer/*.h
+	graphics/host_gpu/renderer/cache/*.cpp
+	graphics/host_gpu/renderer/cache/*.h
+	graphics/host_gpu/renderer/image/*.cpp
+	graphics/host_gpu/renderer/image/*.h
+	graphics/host_gpu/renderer/pipeline/*.cpp
+	graphics/host_gpu/renderer/pipeline/*.h
+	graphics/shader/*.cpp
+	graphics/shader/*.h
+	graphics/shader/recompiler/*.cpp
+	graphics/shader/recompiler/*.h
+	graphics/shader/recompiler/cfg/*.cpp
+	graphics/shader/recompiler/cfg/*.h
+	graphics/shader/recompiler/decompiler/*.cpp
+	graphics/shader/recompiler/decompiler/*.h
+	graphics/shader/recompiler/emitter/*.cpp
+	graphics/shader/recompiler/emitter/*.h
+	graphics/shader/recompiler/ir/*.cpp
+	graphics/shader/recompiler/ir/*.h
+	graphics/presentation/*.cpp
+	graphics/presentation/*.h
+	graphics/presentation/window/*.cpp
+	graphics/presentation/window/*.h
+	kernel/*.cpp
+	kernel/*.h
+	loader/*.cpp
+	loader/*.h
 )
 
 find_program(KYTY_GLSLANG_VALIDATOR glslangValidator REQUIRED)
-set(gpu_tiler_shader_dir "${KYTY_SOURCE_DIR}/graphics/host_gpu/shaders")
+set(gpu_tiler_shader_dir "${CMAKE_CURRENT_SOURCE_DIR}/graphics/host_gpu/shaders")
 set(gpu_tiler_generated_dir "${PROJECT_BINARY_DIR}/gpu_tiler_shaders")
 set(gpu_tiler_shader_names
 	standard256
@@ -254,31 +212,15 @@ foreach(shader_name IN LISTS gpu_tiler_shader_names)
 	add_custom_command(
 		OUTPUT "${shader_header}"
 		COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_tiler_generated_dir}"
-		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os
+		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.0 -Os
 		        "-I${gpu_tiler_shader_dir}" -o "${shader_spv}" "${shader_source}"
 		COMMAND ${CMAKE_COMMAND} -DINPUT=${shader_spv} -DOUTPUT=${shader_header}
-		        -DSYMBOL=${shader_symbol} -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+		        -DSYMBOL=${shader_symbol} -P "${CMAKE_CURRENT_SOURCE_DIR}/embed_spirv.cmake"
 		DEPENDS "${shader_source}" ${gpu_tiler_shader_includes}
 		VERBATIM
 	)
 	list(APPEND gpu_tiler_shader_headers "${shader_header}")
 endforeach()
-
-set(fault_buffer_shader_source "${gpu_tiler_shader_dir}/fault_buffer_process.comp")
-set(fault_buffer_shader_spv "${gpu_tiler_generated_dir}/fault_buffer_process.spv")
-set(fault_buffer_shader_header "${gpu_tiler_generated_dir}/fault_buffer_process_spv.h")
-add_custom_command(
-	OUTPUT "${fault_buffer_shader_header}"
-	COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_tiler_generated_dir}"
-	COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os
-	        -DCACHING_PAGEBITS=14 -DMAX_PAGE_FAULTS=1024
-	        -o "${fault_buffer_shader_spv}" "${fault_buffer_shader_source}"
-	COMMAND ${CMAKE_COMMAND} -DINPUT=${fault_buffer_shader_spv} -DOUTPUT=${fault_buffer_shader_header}
-	        -DSYMBOL=FAULT_BUFFER_PROCESS_SPV -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
-	DEPENDS "${fault_buffer_shader_source}"
-	VERBATIM
-)
-list(APPEND kyty_emulator_src "${fault_buffer_shader_header}")
 list(APPEND kyty_emulator_src ${gpu_tiler_shader_headers})
 
 set(gpu_blit_generated_dir "${PROJECT_BINARY_DIR}/gpu_blit_shaders")
@@ -294,10 +236,10 @@ foreach(shader_source IN LISTS gpu_blit_shader_sources)
 	add_custom_command(
 		OUTPUT "${shader_header}"
 		COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_blit_generated_dir}"
-		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os
+		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.0 -Os
 		        "-I${gpu_tiler_shader_dir}" -o "${shader_spv}" "${shader_source}"
 		COMMAND ${CMAKE_COMMAND} -DINPUT=${shader_spv} -DOUTPUT=${shader_header}
-		        -DSYMBOL=${shader_symbol} -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+		        -DSYMBOL=${shader_symbol} -P "${CMAKE_CURRENT_SOURCE_DIR}/embed_spirv.cmake"
 		DEPENDS "${shader_source}"
 		VERBATIM
 	)
@@ -306,8 +248,8 @@ endforeach()
 list(APPEND kyty_emulator_src ${gpu_blit_shader_headers})
 
 list(APPEND kyty_emulator_src
-	"${KYTY_SOURCE_DIR}/emulator.h"
-	"${KYTY_SOURCE_DIR}/emulator.cpp"
+	emulator.h
+	emulator.cpp
 )
 list(REMOVE_DUPLICATES kyty_emulator_src)
 
@@ -315,7 +257,7 @@ if (KYTY_CLANG_CL)
 	set_source_files_properties(${kyty_emulator_src} PROPERTIES COMPILE_FLAGS "-Wno-pragma-pack -Wno-deprecated-declarations -D_TIMESPEC_DEFINED")
 endif()
 
-set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL2-static imgui xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9 kyty_git_version Zydis::Zydis xbyak::xbyak)
+set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL2-static xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9)
 
 # Linux system libraries required by the static FFmpeg archive.
 if(LINUX)
@@ -338,26 +280,25 @@ if(LINUX)
 endif()
 
 set(inc_headers
-	${KYTY_SOURCE_DIR}
+	${CMAKE_CURRENT_SOURCE_DIR}
 	${KYTY_THIRD_PARTY_DIR}/SDL2/include
 	${KYTY_THIRD_PARTY_DIR}/VulkanMemoryAllocator/include
 	${KYTY_THIRD_PARTY_DIR}/SPIRV-Tools/include
 	${KYTY_THIRD_PARTY_DIR}/fmt/include
 	${KYTY_THIRD_PARTY_DIR}/xxhash
 	${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
-	${KYTY_THIRD_PARTY_DIR}/renderdoc
 	${KYTY_THIRD_PARTY_DIR}/stb
 )
 
 if (KYTY_CLANG_CL)
 	list(APPEND kyty_emulator_link_libraries winpthread)
-	list(APPEND inc_headers
+	list(APPEND inc_headers 
 		${KYTY_THIRD_PARTY_DIR}/winpthread/include
 	)
 endif()
 
 list(APPEND check_headers
-	${KYTY_SOURCE_DIR}
+	${CMAKE_CURRENT_SOURCE_DIR}
 )
 
 function(add_kyty_full_emulator_test target source)
@@ -379,115 +320,95 @@ endfunction()
 function(configure_macos_guest_address_space target)
 	if(APPLE AND (CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64" OR
 			(NOT CMAKE_OSX_ARCHITECTURES AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")))
-		target_sources(${target} PRIVATE "${KYTY_SOURCE_DIR}/kernel/macosGuestAddressSpace.cpp")
+		target_sources(${target} PRIVATE kernel/macosGuestAddressSpace.cpp)
 		target_compile_definitions(${target} PRIVATE KYTY_LINKED_GUEST_ADDRESS_SPACE=1)
 		target_link_options(${target} PRIVATE
 			-Wl,-ld_classic,-no_pie,-no_fixup_chains,-no_huge,-pagezero_size,0x40000,-segaddr,SYSTEM_MANAGED,0x40000,-segaddr,SYSTEM_RESERVED,0x7ffffc000,-segaddr,USER_AREA,0x7000000000,-image_base,0x700000000000)
 	endif()
 endfunction()
 
-add_kyty_full_emulator_test(shader_cfg_tests "${KYTY_TESTS_DIR}/shaderCfgTests.cpp")
+add_kyty_full_emulator_test(shader_cfg_tests ../tests/shaderCfgTests.cpp)
 
 add_executable(scalar_provenance_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ScalarProvenanceTests.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ReadLaneElimination.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/SrtWalker.cpp"
+	../tests/ScalarProvenanceTests.cpp
+	graphics/host_gpu/hostMemory.cpp
+	graphics/shader/recompiler/ir/ReadLaneElimination.cpp
+	graphics/shader/recompiler/ir/ScalarProvenance.cpp
+	graphics/shader/recompiler/ir/SrtWalker.cpp
 )
 target_link_libraries(scalar_provenance_tests fmt::fmt)
 target_include_directories(scalar_provenance_tests PRIVATE ${inc_headers})
 
 add_executable(page_manager_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/PageManagerTests.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/pageManager.cpp"
+	../tests/PageManagerTests.cpp
+	graphics/host_gpu/pageManager.cpp
 )
-target_link_libraries(page_manager_tests common)
 target_include_directories(page_manager_tests PRIVATE ${inc_headers})
 
-add_executable(bit_array_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/BitArrayTests.cpp"
-)
-target_include_directories(bit_array_tests PRIVATE ${inc_headers})
-
-add_executable(ime_dialog_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ImeDialogTests.cpp"
-	"${KYTY_SOURCE_DIR}/libs/imeCommon.cpp"
-	"${KYTY_SOURCE_DIR}/libs/imeDialog.cpp"
-)
-target_include_directories(ime_dialog_tests PRIVATE ${inc_headers})
-
 add_executable(memory_tracker_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/MemoryTrackerTests.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/pageManager.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/memoryTracker.cpp"
+	../tests/MemoryTrackerTests.cpp
+	graphics/host_gpu/pageManager.cpp
+	graphics/host_gpu/memoryTracker.cpp
 )
 target_link_libraries(memory_tracker_tests fmt::fmt common)
 target_include_directories(memory_tracker_tests PRIVATE ${inc_headers})
 
 add_executable(shader_vertex_metadata_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ShaderVertexMetadataTests.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/shaderVertexMetadata.cpp"
+	../tests/ShaderVertexMetadataTests.cpp
+	graphics/host_gpu/hostMemory.cpp
+	graphics/shader/shaderVertexMetadata.cpp
 )
 target_include_directories(shader_vertex_metadata_tests PRIVATE ${inc_headers})
 
-add_executable(resource_materialization_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ResourceMaterializationTests.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceMaterialization.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/SrtWalker.cpp"
+add_executable(shader_stage_runtime_tests EXCLUDE_FROM_ALL
+	../tests/ShaderStageRuntimeTests.cpp
+	graphics/guest_gpu/gpu_format.cpp
+	graphics/host_gpu/hostMemory.cpp
+	graphics/shader/shaderStageRuntime.cpp
+	graphics/shader/recompiler/ir/ResourceMaterialization.cpp
+	graphics/shader/recompiler/ir/ScalarProvenance.cpp
+	graphics/shader/recompiler/ir/SrtWalker.cpp
 )
-target_link_libraries(resource_materialization_tests fmt::fmt)
-target_include_directories(resource_materialization_tests PRIVATE ${inc_headers})
+target_link_libraries(shader_stage_runtime_tests fmt::fmt)
+target_include_directories(shader_stage_runtime_tests PRIVATE ${inc_headers})
 
 add_executable(resource_tracking_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ResourceTrackingTests.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/shaderPixelParameter.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/SrtWalker.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceTracking.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceMaterialization.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ShaderInfoCollection.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/BindingLayout.cpp"
+	../tests/ResourceTrackingTests.cpp
+	graphics/guest_gpu/gpu_format.cpp
+	graphics/host_gpu/hostMemory.cpp
+	graphics/shader/recompiler/ir/ScalarProvenance.cpp
+	graphics/shader/recompiler/ir/SrtWalker.cpp
+	graphics/shader/recompiler/ir/SrtPatcher.cpp
+	graphics/shader/recompiler/ir/ResourceTracking.cpp
+	graphics/shader/recompiler/ir/ResourceMaterialization.cpp
+	graphics/shader/recompiler/ir/ShaderInfoCollection.cpp
+	graphics/shader/recompiler/ir/BindingLayout.cpp
 )
 target_link_libraries(resource_tracking_tests fmt::fmt)
 target_include_directories(resource_tracking_tests PRIVATE ${inc_headers})
 
-add_executable(audio_out2_port_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/AudioOut2PortTests.cpp"
-	"${KYTY_SOURCE_DIR}/libs/libAudio2.cpp"
-	"${KYTY_SOURCE_DIR}/loader/timer.cpp"
+add_executable(resource_mutex_tests EXCLUDE_FROM_ALL
+	../tests/ResourceMutexTests.cpp
+	graphics/host_gpu/renderer/cache/resourceMutex.cpp
 )
-target_link_libraries(audio_out2_port_tests common fmt::fmt)
-target_include_directories(audio_out2_port_tests PRIVATE ${inc_headers})
+target_link_libraries(resource_mutex_tests common)
+target_include_directories(resource_mutex_tests PRIVATE ${inc_headers})
 
 add_executable(event_queue_lifetime_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/EventQueueLifetimeTests.cpp"
-	"${KYTY_SOURCE_DIR}/kernel/eventQueue.cpp"
-	"${KYTY_SOURCE_DIR}/loader/timer.cpp"
+	../tests/EventQueueLifetimeTests.cpp
+	kernel/eventQueue.cpp
+	loader/timer.cpp
 )
 target_link_libraries(event_queue_lifetime_tests common fmt::fmt)
 target_include_directories(event_queue_lifetime_tests PRIVATE ${inc_headers})
 
-add_kyty_full_emulator_test(kernel_file_system_tests
-	"${KYTY_TESTS_DIR}/KernelFileSystemTests.cpp")
-
-add_executable(sync_on_address_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/SyncOnAddressTests.cpp"
-	"${KYTY_SOURCE_DIR}/kernel/syncOnAddress.cpp"
-)
-target_link_libraries(sync_on_address_tests common)
-target_include_directories(sync_on_address_tests PRIVATE ${inc_headers})
-
 add_executable(image_page_table_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ImagePageTableTests.cpp"
+	../tests/ImagePageTableTests.cpp
 )
 target_link_libraries(image_page_table_tests common fmt::fmt)
 target_include_directories(image_page_table_tests PRIVATE ${inc_headers})
 
-add_kyty_full_emulator_test(shader_recompiler_compute_tests "${KYTY_TESTS_DIR}/ShaderRecompilerComputeTests.cpp")
+add_kyty_full_emulator_test(shader_recompiler_compute_tests ../tests/ShaderRecompilerComputeTests.cpp)
 
 set(gpu_test_generated_dir "${PROJECT_BINARY_DIR}/gpu_test_shaders")
 set(gpu_test_ms_depth_source
@@ -499,18 +420,18 @@ set(gpu_test_ms_depth_header
 add_custom_command(
 	OUTPUT "${gpu_test_ms_depth_header}"
 	COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_test_generated_dir}"
-	COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os
+	COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.0 -Os
 	        -o "${gpu_test_ms_depth_spv}" "${gpu_test_ms_depth_source}"
 	COMMAND ${CMAKE_COMMAND} -DINPUT=${gpu_test_ms_depth_spv}
 	        -DOUTPUT=${gpu_test_ms_depth_header} -DSYMBOL=GPU_TEST_MS_DEPTH_SPV
-	        -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+	        -P "${CMAKE_CURRENT_SOURCE_DIR}/embed_spirv.cmake"
 	DEPENDS "${gpu_test_ms_depth_source}"
 	VERBATIM
 )
 target_sources(shader_recompiler_compute_tests PRIVATE
 	"${gpu_test_ms_depth_header}")
 
-add_kyty_full_emulator_test(virtual_memory_allocation_tests "${KYTY_TESTS_DIR}/VirtualMemoryAllocationTests.cpp")
+add_kyty_full_emulator_test(virtual_memory_allocation_tests ../tests/VirtualMemoryAllocationTests.cpp)
 target_compile_definitions(virtual_memory_allocation_tests PRIVATE
 	KYTY_VIRTUAL_MEMORY_ALLOCATION_TESTS=1)
 
@@ -523,45 +444,21 @@ if(NOT KYTY_CLANG_CL)
 endif()
 
 if(BUILD_TESTING)
-	add_test(NAME emulator_user_name_cli
-	         COMMAND $<TARGET_FILE:kyty_emulator> --help --user-name 1234567890123456)
-	add_test(NAME emulator_user_name_too_long
-	         COMMAND $<TARGET_FILE:kyty_emulator> --help --user-name 12345678901234567)
-	set_tests_properties(emulator_user_name_too_long PROPERTIES WILL_FAIL TRUE)
-	add_test(NAME emulator_present_mode_cli
-	         COMMAND $<TARGET_FILE:kyty_emulator> --help --present-mode Immediate)
-	add_test(NAME emulator_present_mode_invalid
-	         COMMAND $<TARGET_FILE:kyty_emulator> --help --present-mode Invalid)
-	set_tests_properties(emulator_present_mode_invalid PROPERTIES WILL_FAIL TRUE)
-	add_test(NAME ime_dialog COMMAND $<TARGET_FILE:ime_dialog_tests>)
-	add_test(NAME shader_cfg COMMAND $<TARGET_FILE:shader_cfg_tests>)
 	add_test(NAME scalar_provenance COMMAND $<TARGET_FILE:scalar_provenance_tests>)
 	add_test(NAME image_page_table COMMAND $<TARGET_FILE:image_page_table_tests>)
 	add_test(NAME memory_tracker COMMAND $<TARGET_FILE:memory_tracker_tests>)
 	add_test(NAME page_manager COMMAND $<TARGET_FILE:page_manager_tests>)
-	add_test(NAME bit_array COMMAND $<TARGET_FILE:bit_array_tests>)
-	add_test(NAME shader_vertex_metadata COMMAND $<TARGET_FILE:shader_vertex_metadata_tests>)
-	add_test(NAME resource_materialization COMMAND $<TARGET_FILE:resource_materialization_tests>)
-	add_test(NAME resource_tracking COMMAND $<TARGET_FILE:resource_tracking_tests>)
+	add_test(NAME resource_mutex COMMAND $<TARGET_FILE:resource_mutex_tests>)
 	add_test(NAME event_queue_lifetime COMMAND $<TARGET_FILE:event_queue_lifetime_tests>)
-	add_test(NAME kernel_file_system COMMAND $<TARGET_FILE:kernel_file_system_tests>)
-	add_test(NAME sync_on_address COMMAND $<TARGET_FILE:sync_on_address_tests>)
-	add_test(NAME audio_out2_port COMMAND $<TARGET_FILE:audio_out2_port_tests>)
 	add_test(NAME shader_recompiler_compute COMMAND $<TARGET_FILE:shader_recompiler_compute_tests>)
-	add_test(NAME shader_recompiler_alignbyte
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --alignbyte-only)
 	add_test(NAME virtual_memory_allocation
 		COMMAND $<TARGET_FILE:virtual_memory_allocation_tests>)
-	add_test(NAME guest_red_zone_patcher
-		COMMAND $<TARGET_FILE:virtual_memory_allocation_tests> --red-zone-patcher-only)
 	add_test(NAME command_scheduler_timeline
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --scheduler-only)
 	add_test(NAME stream_buffer_ring
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --stream-buffer-only)
 	add_test(NAME gpu_command_lane
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --gpu-command-lane-only)
-	add_test(NAME pm4_context_state
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --context-state-only)
 	add_test(NAME gpu_tiler
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --gpu-tiler-only)
 
@@ -573,8 +470,6 @@ if(BUILD_TESTING)
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --storage-sampled-only)
 	add_test(NAME texture_cache_depth_readback
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --depth-readback-only)
-	add_test(NAME compute_meta_clear_classification
-		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --compute-meta-clear-only)
 	add_test(NAME buffer_cache_dirty_gc
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --buffer-cache-gc-only)
 
@@ -587,29 +482,10 @@ if(BUILD_TESTING)
 		add_test(NAME buffer_cache_ranges
 			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --buffer-cache-range-only)
 	endif()
-
-	add_custom_target(kyty_tests DEPENDS
-		ime_dialog_tests
-		shader_cfg_tests
-		scalar_provenance_tests
-		image_page_table_tests
-		memory_tracker_tests
-		page_manager_tests
-		bit_array_tests
-		shader_vertex_metadata_tests
-		resource_materialization_tests
-		resource_tracking_tests
-		event_queue_lifetime_tests
-		kernel_file_system_tests
-		sync_on_address_tests
-		shader_recompiler_compute_tests
-		virtual_memory_allocation_tests
-		audio_out2_port_tests
-	)
 endif()
 
 
-add_executable(kyty_emulator "${KYTY_SOURCE_DIR}/main.cpp" ${kyty_emulator_src})
+add_executable(kyty_emulator main.cpp ${kyty_emulator_src})
 configure_macos_guest_address_space(kyty_emulator)
 
 target_link_libraries(kyty_emulator ${kyty_emulator_link_libraries})
@@ -639,17 +515,14 @@ set(KYTY_EMULATOR_MAP_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/${KYTY_EMULATOR_MAP
 set(KYTY_EMULATOR_PDB_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/kyty_emulator.pdb")
 
 if(KYTY_CLANG_CL)
-	target_link_options(kyty_emulator PRIVATE
-		"/DYNAMICBASE:NO"
-		"/DEBUG:FULL"
-		"/PDB:${KYTY_EMULATOR_PDB_LINK_PATH}"
-		"/lldmap:${KYTY_EMULATOR_MAP_LINK_PATH}"
-	)
+	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "/DYNAMICBASE:NO /DEBUG:FULL /PDB:${KYTY_EMULATOR_PDB_LINK_PATH} /lldmap:${KYTY_EMULATOR_MAP_LINK_PATH}")
 	add_custom_command(TARGET kyty_emulator POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:kyty_emulator>/libwinpthread-1.dll)
 elseif(WIN32 OR LINUX)
 	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "${KYTY_LD_OPTIONS} -Wl,-Map=${KYTY_EMULATOR_MAP_LINK_PATH}")
 endif()
 
+add_dependencies(kyty_emulator KytyGitVersion)
+
 if(APPLE)
 	# The emulator writes x86-64 trampolines/PLT stubs into memory and executes them, and
 	# runs guest code under Rosetta. That requires the JIT / unsigned-executable-memory
@@ -657,14 +530,14 @@ if(APPLE)
 	# reverts to the hardened defaults and aborts when it first executes written code).
 	add_custom_command(TARGET kyty_emulator POST_BUILD
 		COMMAND codesign -s - --force --options runtime
-			--entitlements "${KYTY_SOURCE_DIR}/macos_jit.entitlements"
+			--entitlements "${CMAKE_CURRENT_SOURCE_DIR}/macos_jit.entitlements"
 			$<TARGET_FILE:kyty_emulator>
 		COMMENT "Codesign kyty_emulator with JIT entitlements (macOS)")
 endif()
 
 install(TARGETS kyty_emulator DESTINATION .)
 if(KYTY_BUILD_LAUNCHER)
-	add_subdirectory("${KYTY_SOURCE_DIR}/launcher" "${CMAKE_CURRENT_BINARY_DIR}/launcher")
+	add_subdirectory(launcher)
 endif()
 if(KYTY_CLANG_CL)
 	install(FILES "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" DESTINATION .)

src/cmake_config.h.in

@@ -1,8 +1,4 @@
 #define KYTY_VERSION "@KYTY_VERSION@"
-#define KYTY_BUILD_REPOSITORY "@KYTY_BUILD_REPOSITORY@"
-#define KYTY_RELEASE_TAG "@KYTY_RELEASE_TAG@"
-#cmakedefine KYTY_OFFICIAL_BUILD
-#cmakedefine KYTY_FORK_BUILD
 #define KYTY_ENDIAN @KYTY_ENDIAN@
 #define KYTY_PLATFORM @KYTY_PLATFORM@
 #define KYTY_COMPILER KYTY_COMPILER_@KYTY_COMPILER@

src/common/CMakeLists.txt

@@ -13,7 +13,7 @@ endif()
 add_library(common STATIC ${common_src} ${common_headers})
 
 target_include_directories(common
-	PUBLIC ${KYTY_SOURCE_DIR}
+	PUBLIC ${PROJECT_SOURCE_DIR}
 	PRIVATE
 		${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
 )
@@ -24,7 +24,6 @@ target_link_libraries(common
 		Tracy::TracyClient
 	PRIVATE
 		cpuinfo
-		kyty_git_version
 		spdlog::spdlog
 )
 

src/common/assert.cpp

@@ -3,7 +3,6 @@
 #include "common/debug.h"
 #include "common/logging/log.h"
 #include "common/subsystems.h"
-#include "kytyGitVersion.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -24,7 +23,7 @@ static std::string BuildFatalReport(const char* title, std::string_view text, co
 	DebugStack stack;
 	DebugStack::Trace(&stack);
 
-	std::string report = "--- Build ---\n" KYTY_BUILD_LABEL "\n--- Stack Trace ---\n";
+	std::string report = "--- Stack Trace ---\n";
 	for (int i = PRINT_STACK_FROM; i < stack.depth; i++) {
 		report += fmt::format("[{}] {:016x}\n", i - PRINT_STACK_FROM,
 		                      static_cast<uint64_t>(stack.GetAddr(i)));
@@ -35,7 +34,7 @@ static std::string BuildFatalReport(const char* title, std::string_view text, co
 
 static int DbgReport(const char* title, std::string_view text, const char* file, int line) {
 	Log::WriteFatal(BuildFatalReport(title, text, file, line));
-	Subsystems::EmergencyShutdownActive();
+	SubsystemsListSingleton::Instance()->ShutdownAll();
 	return 1;
 }
 

src/common/bitArray.h

@@ -1,260 +0,0 @@
-#ifndef EMULATOR_SRC_COMMON_BITARRAY_H_
-#define EMULATOR_SRC_COMMON_BITARRAY_H_
-
-#include <array>
-#include <bit>
-#include <cstddef>
-#include <cstdint>
-#include <iterator>
-#include <utility>
-
-namespace Common {
-
-template <size_t N>
-class BitArray final {
-	static_assert(N != 0, "BitArray size must be nonzero");
-	static_assert(N % 64 == 0, "BitArray size must be a multiple of 64 bits");
-
-	static constexpr size_t BITS_PER_WORD = 64;
-	static constexpr size_t WORD_COUNT    = N / BITS_PER_WORD;
-
-public:
-	using Range = std::pair<size_t, size_t>;
-
-	class Iterator final {
-	public:
-		using iterator_category = std::forward_iterator_tag;
-		using value_type        = Range;
-		using difference_type   = std::ptrdiff_t;
-		using pointer           = const Range*;
-		using reference         = const Range&;
-
-		Iterator(const BitArray& bits, size_t start)
-		    : m_bits(bits), m_range(bits.FirstRangeFrom(start)) {}
-
-		Iterator& operator++() {
-			m_range = m_bits.FirstRangeFrom(m_range.second);
-			return *this;
-		}
-
-		[[nodiscard]] bool operator==(const Iterator& other) const {
-			return &m_bits == &other.m_bits && m_range == other.m_range;
-		}
-
-		[[nodiscard]] bool operator!=(const Iterator& other) const { return !(*this == other); }
-
-		[[nodiscard]] reference operator*() const { return m_range; }
-		[[nodiscard]] pointer   operator->() const { return &m_range; }
-
-	private:
-		const BitArray& m_bits;
-		Range           m_range;
-	};
-
-	using const_iterator = Iterator;
-
-	constexpr BitArray() = default;
-
-	constexpr BitArray(const BitArray& other, size_t start, size_t end) {
-		if (start >= end || end > N) {
-			return;
-		}
-
-		const auto first_word = start / BITS_PER_WORD;
-		const auto last_word  = (end - 1) / BITS_PER_WORD;
-		const auto start_bit  = start % BITS_PER_WORD;
-		const auto end_bit    = (end - 1) % BITS_PER_WORD;
-		const auto start_mask = ~uint64_t {0} << start_bit;
-		const auto end_mask =
-		    end_bit == BITS_PER_WORD - 1 ? ~uint64_t {0} : (uint64_t {1} << (end_bit + 1)) - 1;
-
-		if (first_word == last_word) {
-			m_data[first_word] = other.m_data[first_word] & start_mask & end_mask;
-			return;
-		}
-
-		m_data[first_word] = other.m_data[first_word] & start_mask;
-		for (auto word = first_word + 1; word < last_word; word++) {
-			m_data[word] = other.m_data[word];
-		}
-		m_data[last_word] = other.m_data[last_word] & end_mask;
-	}
-
-	[[nodiscard]] constexpr bool Get(size_t index) const {
-		return (m_data[index / BITS_PER_WORD] & (uint64_t {1} << (index % BITS_PER_WORD))) != 0;
-	}
-
-	constexpr void Set(size_t index) {
-		m_data[index / BITS_PER_WORD] |= uint64_t {1} << (index % BITS_PER_WORD);
-	}
-
-	constexpr void Unset(size_t index) {
-		m_data[index / BITS_PER_WORD] &= ~(uint64_t {1} << (index % BITS_PER_WORD));
-	}
-
-	constexpr void SetRange(size_t start, size_t end) {
-		if (start >= end || end > N) {
-			return;
-		}
-
-		const auto first_word = start / BITS_PER_WORD;
-		const auto last_word  = (end - 1) / BITS_PER_WORD;
-		const auto start_bit  = start % BITS_PER_WORD;
-		const auto end_bit    = (end - 1) % BITS_PER_WORD;
-		const auto start_mask = ~uint64_t {0} << start_bit;
-		const auto end_mask =
-		    end_bit == BITS_PER_WORD - 1 ? ~uint64_t {0} : (uint64_t {1} << (end_bit + 1)) - 1;
-
-		if (first_word == last_word) {
-			m_data[first_word] |= start_mask & end_mask;
-			return;
-		}
-
-		m_data[first_word] |= start_mask;
-		for (auto word = first_word + 1; word < last_word; word++) {
-			m_data[word] = ~uint64_t {0};
-		}
-		m_data[last_word] |= end_mask;
-	}
-
-	constexpr void UnsetRange(size_t start, size_t end) {
-		if (start >= end || end > N) {
-			return;
-		}
-
-		const auto first_word = start / BITS_PER_WORD;
-		const auto last_word  = (end - 1) / BITS_PER_WORD;
-		const auto start_bit  = start % BITS_PER_WORD;
-		const auto end_bit    = (end - 1) % BITS_PER_WORD;
-		const auto start_mask = (uint64_t {1} << start_bit) - 1;
-		const auto end_mask =
-		    end_bit == BITS_PER_WORD - 1 ? uint64_t {0} : ~((uint64_t {1} << (end_bit + 1)) - 1);
-
-		if (first_word == last_word) {
-			m_data[first_word] &= start_mask | end_mask;
-			return;
-		}
-
-		m_data[first_word] &= start_mask;
-		for (auto word = first_word + 1; word < last_word; word++) {
-			m_data[word] = 0;
-		}
-		m_data[last_word] &= end_mask;
-	}
-
-	constexpr void Clear() { m_data.fill(0); }
-	constexpr void Fill() { m_data.fill(~uint64_t {0}); }
-
-	[[nodiscard]] constexpr bool None() const {
-		uint64_t combined = 0;
-		for (const auto word: m_data) {
-			combined |= word;
-		}
-		return combined == 0;
-	}
-
-	[[nodiscard]] constexpr bool Any() const { return !None(); }
-
-	[[nodiscard]] constexpr Range FirstRangeFrom(size_t start) const {
-		if (start >= N) {
-			return {N, N};
-		}
-
-		auto word_index = start / BITS_PER_WORD;
-		auto word       = m_data[word_index] & (~uint64_t {0} << (start % BITS_PER_WORD));
-		while (word == 0) {
-			word_index++;
-			if (word_index == WORD_COUNT) {
-				return {N, N};
-			}
-			word = m_data[word_index];
-		}
-
-		const auto first     = word_index * BITS_PER_WORD + std::countr_zero(word);
-		const auto first_bit = first % BITS_PER_WORD;
-		const auto first_ones =
-		    static_cast<size_t>(std::countr_one(m_data[word_index] >> first_bit));
-		if (first_bit + first_ones < BITS_PER_WORD) {
-			return {first, first + first_ones};
-		}
-
-		for (word_index++; word_index < WORD_COUNT; word_index++) {
-			word = m_data[word_index];
-			if (word != ~uint64_t {0}) {
-				return {first, word_index * BITS_PER_WORD + std::countr_one(word)};
-			}
-		}
-		return {first, N};
-	}
-
-	[[nodiscard]] constexpr Range FirstRange() const { return FirstRangeFrom(0); }
-
-	[[nodiscard]] constexpr Range LastRangeFrom(size_t end) const {
-		if (end == 0) {
-			return {0, 0};
-		}
-		if (end > N) {
-			end = N;
-		}
-
-		auto       word_index = (end - 1) / BITS_PER_WORD;
-		const auto end_bit    = (end - 1) % BITS_PER_WORD;
-		const auto end_mask =
-		    end_bit == BITS_PER_WORD - 1 ? ~uint64_t {0} : (uint64_t {1} << (end_bit + 1)) - 1;
-		auto word = m_data[word_index] & end_mask;
-		while (word == 0) {
-			if (word_index == 0) {
-				return {0, 0};
-			}
-			word = m_data[--word_index];
-		}
-
-		const auto empty_bits = static_cast<size_t>(std::countl_zero(word));
-		const auto ones       = static_cast<size_t>(std::countl_one(word << empty_bits));
-		const auto last       = (word_index + 1) * BITS_PER_WORD - empty_bits;
-		if (empty_bits + ones < BITS_PER_WORD) {
-			return {last - ones, last};
-		}
-
-		while (word_index != 0) {
-			word = m_data[--word_index];
-			if (word != ~uint64_t {0}) {
-				return {(word_index + 1) * BITS_PER_WORD - std::countl_one(word), last};
-			}
-		}
-		return {0, last};
-	}
-
-	[[nodiscard]] constexpr Range LastRange() const { return LastRangeFrom(N); }
-
-	[[nodiscard]] const_iterator begin() const { return Iterator(*this, 0); }
-	[[nodiscard]] const_iterator end() const { return Iterator(*this, N); }
-
-	constexpr BitArray& operator^=(const BitArray& other) {
-		for (size_t word = 0; word < WORD_COUNT; word++) {
-			m_data[word] ^= other.m_data[word];
-		}
-		return *this;
-	}
-
-	[[nodiscard]] constexpr BitArray operator^(const BitArray& other) const {
-		auto result = *this;
-		result ^= other;
-		return result;
-	}
-
-	[[nodiscard]] constexpr BitArray operator~() const {
-		auto result = *this;
-		for (auto& word: result.m_data) {
-			word = ~word;
-		}
-		return result;
-	}
-
-private:
-	std::array<uint64_t, WORD_COUNT> m_data {};
-};
-
-} // namespace Common
-
-#endif // EMULATOR_SRC_COMMON_BITARRAY_H_

src/common/commonSubsystem.cpp

@@ -0,0 +1,21 @@
+#include "common/commonSubsystem.h"
+
+#include "common/byteBuffer.h" // IWYU pragma: associated
+#include "common/common.h"     // IWYU pragma: associated
+#include "common/debug.h"      // IWYU pragma: associated
+#include "common/hash.h"       // IWYU pragma: associated
+#include "common/magicEnum.h"  // IWYU pragma: associated
+#include "common/singleton.h"  // IWYU pragma: associated
+#include "common/virtualMemory.h"
+
+namespace Common {
+
+KYTY_SUBSYSTEM_INIT(Common) {
+	VirtualMemory::Init();
+}
+
+KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Common) {}
+
+KYTY_SUBSYSTEM_DESTROY(Common) {}
+
+} // namespace Common

src/common/commonSubsystem.h

@@ -0,0 +1,12 @@
+#ifndef KYTY_COMMON_COMMON_SUBSYSTEM_H_
+#define KYTY_COMMON_COMMON_SUBSYSTEM_H_
+
+#include "common/subsystems.h"
+
+namespace Common {
+
+KYTY_SUBSYSTEM_DEFINE(Common);
+
+} // namespace Common
+
+#endif /* KYTY_COMMON_COMMON_SUBSYSTEM_H_ */

src/common/emulatorConfig.cpp

@@ -9,20 +9,18 @@ namespace Config {
 
 static std::unique_ptr<ConfigOptions> g_config;
 
-void Initialize() {
+KYTY_SUBSYSTEM_INIT(Config) {
 	EXIT_IF(g_config != nullptr);
 
 	g_config = std::make_unique<ConfigOptions>();
 }
 
-void Shutdown() {
-	g_config.reset();
-}
+KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Config) {}
+
+KYTY_SUBSYSTEM_DESTROY(Config) {}
 
 void Load(const ConfigOptions& cfg) {
 	EXIT_IF(g_config == nullptr);
-	EXIT_IF(cfg.user_name.empty() || cfg.user_name.size() > MAX_USER_NAME_LENGTH);
-	EXIT_IF(!IsConfiguredUserIdValid(cfg.user_id));
 
 	*g_config = cfg;
 }
@@ -35,34 +33,10 @@ uint32_t GetScreenHeight() {
 	return g_config->screen_height;
 }
 
-const std::string& GetUserName() {
-	return g_config->user_name;
-}
-
-int32_t GetUserId() {
-	return g_config->user_id;
-}
-
-PresentMode GetPresentMode() {
-	return g_config->present_mode;
-}
-
-int32_t GetGpuIndex() {
-	return g_config->gpu_index;
-}
-
-bool FullscreenEnabled() {
-	return g_config->fullscreen_enabled;
-}
-
 uint32_t GetVblankFrequency() {
 	return std::clamp(g_config->vblank_frequency, 30u, 360u);
 }
 
-uint32_t GetConsoleLanguage() {
-	return g_config->console_language;
-}
-
 bool VulkanValidationEnabled() {
 	return g_config->vulkan_validation_enabled;
 }
@@ -111,30 +85,16 @@ bool SpirvDebugPrintfEnabled() {
 	return g_config->spirv_debug_printf_enabled;
 }
 
-bool GpuAssistedValidationEnabled() {
-	return g_config->gpu_assisted_validation_enabled && g_config->vulkan_validation_enabled;
-}
-
 bool RenderDocEnabled() {
 	return g_config->renderdoc_enabled;
 }
 
+bool NggRectlistDrawEnabled() {
+	return g_config->ngg_rectlist_draw_enabled;
+}
+
 bool ReadbackLinearImagesEnabled() {
 	return g_config->readback_linear_images;
 }
 
-bool PlayGoHackEnabled() {
-	return g_config->playgo_hack_enabled;
-}
-
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-bool RedZoneProtectionEnabled() {
-	return g_config->red_zone_protection_enabled;
-}
-#endif
-
-const Keymap& GetKeymap() {
-	return g_config->keymap;
-}
-
 } // namespace Config

src/common/emulatorConfig.h

@@ -2,22 +2,13 @@
 #define KYTY_COMMON_EMULATOR_CONFIG_H_
 
 #include "common/common.h"
+#include "common/subsystems.h"
 
-#include <cstddef>
 #include <filesystem>
-#include <string>
-#include <vector>
 
 namespace Config {
 
-void Initialize();
-void Shutdown();
-
-struct Lifecycle {
-	static constexpr const char* name       = "Config";
-	static constexpr auto        initialize = Config::Initialize;
-	static constexpr auto        shutdown   = Config::Shutdown;
-};
+KYTY_SUBSYSTEM_DEFINE(Config);
 
 enum class ShaderOptimizationType { None, Size, Performance };
 
@@ -27,31 +18,10 @@ enum class ProfilerDirection { None, Network };
 
 enum class OutputDirection { Silent, Console, File };
 
-enum class PresentMode { Fifo, Mailbox, Immediate };
-
-using Keymap = std::vector<std::string>;
-
-constexpr uint32_t DEFAULT_CONSOLE_LANGUAGE = 1;
-constexpr uint32_t MAX_CONSOLE_LANGUAGE     = 29;
-constexpr std::size_t MAX_USER_NAME_LENGTH = 16;
-constexpr int32_t DEFAULT_USER_ID           = 1000;
-
-constexpr bool IsConfiguredUserIdValid(int32_t user_id) {
-	constexpr int32_t USER_ID_EVERYONE = 0xfe;
-	constexpr int32_t USER_ID_SYSTEM   = 0xff;
-	return user_id >= 0 && user_id != USER_ID_EVERYONE && user_id != USER_ID_SYSTEM;
-}
-
 struct ConfigOptions {
 	uint32_t               screen_width                = 1280;
 	uint32_t               screen_height               = 720;
-	std::string            user_name                   = "Kyty";
-	int32_t                user_id                     = DEFAULT_USER_ID;
-	PresentMode            present_mode                = PresentMode::Fifo;
-	int32_t                gpu_index                   = -1;
-	bool                   fullscreen_enabled          = false;
 	uint32_t               vblank_frequency            = 60;
-	uint32_t               console_language            = DEFAULT_CONSOLE_LANGUAGE;
 	bool                   vulkan_validation_enabled   = false;
 	bool                   shader_validation_enabled   = false;
 	ShaderOptimizationType shader_optimization_type    = ShaderOptimizationType::None;
@@ -60,31 +30,20 @@ struct ConfigOptions {
 	bool                   command_buffer_dump_enabled = false;
 	std::filesystem::path  command_buffer_dump_folder  = "_Buffers";
 	bool                   graphics_debug_dump_enabled = false;
-	OutputDirection        printf_direction            = OutputDirection::Silent;
+	OutputDirection        printf_direction            = OutputDirection::Console;
 	std::filesystem::path  printf_output_file          = "_kyty.txt";
 	ProfilerDirection      profiler_direction          = ProfilerDirection::None;
 	bool                   spirv_debug_printf_enabled  = false;
-	bool                   gpu_assisted_validation_enabled = false;
 	bool                   renderdoc_enabled           = false;
+	bool                   ngg_rectlist_draw_enabled   = true;
 	bool                   readback_linear_images      = false;
-	bool                   playgo_hack_enabled         = false;
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-	bool red_zone_protection_enabled = false;
-#endif
-	Keymap keymap;
 };
 
 void Load(const ConfigOptions& cfg);
 
 uint32_t GetScreenWidth();
 uint32_t GetScreenHeight();
-const std::string& GetUserName();
-int32_t  GetUserId();
-PresentMode GetPresentMode();
-int32_t GetGpuIndex();
-bool     FullscreenEnabled();
 uint32_t GetVblankFrequency();
-uint32_t GetConsoleLanguage();
 bool     VulkanValidationEnabled();
 
 bool                   ShaderValidationEnabled();
@@ -104,16 +63,9 @@ ProfilerDirection GetProfilerDirection();
 
 bool SpirvDebugPrintfEnabled();
 
-bool GpuAssistedValidationEnabled();
-
 bool RenderDocEnabled();
+bool NggRectlistDrawEnabled();
 bool ReadbackLinearImagesEnabled();
-bool PlayGoHackEnabled();
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-bool RedZoneProtectionEnabled();
-#endif
-
-const Keymap& GetKeymap();
 
 } // namespace Config
 

src/common/file.cpp

@@ -25,6 +25,9 @@
 #ifdef CopyFile
 #undef CopyFile
 #endif
+#ifdef MoveFile
+#undef MoveFile
+#endif
 #endif
 
 namespace Common {
@@ -541,14 +544,14 @@ bool File::CopyFile(const std::filesystem::path& src,
 	return SysFileCopyFile(src, dst);
 }
 
-bool File::RenameFile(const std::filesystem::path& src,
-                      const std::filesystem::path& dst) // @suppress("Member declaration not found")
+bool File::MoveFile(const std::filesystem::path& src,
+                    const std::filesystem::path& dst) // @suppress("Member declaration not found")
 {
 	if (IsFileExisting(dst)) {
 		DeleteFile(dst); // @suppress("Invalid arguments")
 	}
 
-	return SysFileRenameFile(src, dst);
+	return SysFileMoveFile(src, dst);
 }
 
 void File::RemoveReadonly(const std::filesystem::path& name) {

src/common/file.h

@@ -20,6 +20,9 @@
 #ifdef CopyFile
 #undef CopyFile
 #endif
+#ifdef MoveFile
+#undef MoveFile
+#endif
 #endif
 
 namespace Common {
@@ -104,7 +107,7 @@ public:
 	static std::vector<FindInfo> FindFiles(const std::filesystem::path& path);
 	static std::vector<DirEntry> GetDirEntries(const std::filesystem::path& path);
 	static bool CopyFile(const std::filesystem::path& src, const std::filesystem::path& dst);
-	static bool RenameFile(const std::filesystem::path& src, const std::filesystem::path& dst);
+	static bool MoveFile(const std::filesystem::path& src, const std::filesystem::path& dst);
 	static void RemoveReadonly(const std::filesystem::path& name);
 
 	KYTY_CLASS_NO_COPY(File);

src/common/hostException.cpp

@@ -2,6 +2,7 @@
 
 #include <atomic>
 #include <cstdio>
+#include <cstdlib>
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 #include <windows.h> // IWYU pragma: keep
@@ -27,14 +28,54 @@ namespace Common::HostException {
 
 static std::atomic<Handler> g_handler {nullptr};
 static std::atomic_uint32_t g_install_state {0};
+static thread_local bool    g_in_exception_filter = false;
 
 static_assert(decltype(g_handler)::is_always_lock_free);
 static_assert(decltype(g_install_state)::is_always_lock_free);
+
+[[noreturn]] static void FailFast(const char* reason) noexcept {
+	std::fputs("HostException fail-fast: ", stderr);
+	std::fputs(reason != nullptr ? reason : "unspecified", stderr);
+	std::fputc('\n', stderr);
+	std::fflush(stderr);
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	TerminateProcess(GetCurrentProcess(), static_cast<UINT>(EXCEPTION_NONCONTINUABLE_EXCEPTION));
+#endif
+	std::_Exit(321);
+}
+
+class FilterScope final {
+public:
+	FilterScope() noexcept {
+		if (g_in_exception_filter) {
+			FailFast("nested exception while resolving a host fault");
+		}
+		g_in_exception_filter = true;
+	}
+
+	~FilterScope() { g_in_exception_filter = false; }
+
+	KYTY_CLASS_NO_COPY(FilterScope);
+};
+
+static Handler LoadInstalledHandler() noexcept {
+	if (g_install_state.load(std::memory_order_acquire) == 0) {
+		FailFast("host exception handler is not installed");
+	}
+
+	const auto handler = g_handler.load(std::memory_order_acquire);
+	if (handler == nullptr) {
+		FailFast("host exception callback is null");
+	}
+	return handler;
+}
 #endif
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 
-static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) noexcept {
+static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) {
+	FilterScope filter_scope;
+
 	auto* exception_record = exception->ExceptionRecord;
 
 	if (exception_record->ExceptionCode == DBG_PRINTEXCEPTION_C ||
@@ -64,6 +105,12 @@ static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) noexcept {
 	} else if (exception_record->ExceptionCode == EXCEPTION_ILLEGAL_INSTRUCTION) {
 		info.type = ExceptionType::IllegalInstruction;
 	} else {
+		printf("Unhandled win exception: code=0x%08" PRIx32 ", addr=0x%016" PRIx64
+		       ", rip=0x%016" PRIx64 ", rsp=0x%016" PRIx64 ", rbp=0x%016" PRIx64 "\n",
+		       static_cast<uint32_t>(exception_record->ExceptionCode),
+		       reinterpret_cast<uint64_t>(exception_record->ExceptionAddress),
+		       exception->ContextRecord->Rip, exception->ContextRecord->Rsp,
+		       exception->ContextRecord->Rbp);
 		return EXCEPTION_CONTINUE_SEARCH;
 	}
 
@@ -84,21 +131,28 @@ static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) noexcept {
 	info.r14 = exception->ContextRecord->R14;
 	info.r15 = exception->ContextRecord->R15;
 
-	const auto handler = g_handler.load(std::memory_order_acquire);
-	if (handler != nullptr && handler(info)) {
-		return EXCEPTION_CONTINUE_EXECUTION;
-	}
-	return EXCEPTION_CONTINUE_SEARCH;
+	const auto handler = LoadInstalledHandler();
+
+	return handler(info) ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_CONTINUE_SEARCH;
 }
 
 #elif defined(__APPLE__)
 
 static std::atomic<Handler> g_handler {nullptr};
 static std::atomic_uint32_t g_install_state {0};
+static thread_local bool    g_in_exception_filter = false;
 
 static_assert(decltype(g_handler)::is_always_lock_free);
 static_assert(decltype(g_install_state)::is_always_lock_free);
 
+[[noreturn]] static void FailFast(const char* reason) noexcept {
+	std::fputs("HostException fail-fast: ", stderr);
+	std::fputs(reason != nullptr ? reason : "unspecified", stderr);
+	std::fputc('\n', stderr);
+	std::fflush(stderr);
+	std::_Exit(321);
+}
+
 // Translate the x86-64 page-fault error code (mcontext __es.__err) into an access type.
 // bit 1 (0x2) = write, bit 4 (0x10) = instruction fetch, otherwise a read.
 static AccessViolationType DecodeAccess(uint64_t err) {
@@ -116,6 +170,11 @@ static AccessViolationType DecodeAccess(uint64_t err) {
 // re-executing the faulting instruction against the now-fixed protection. An unresolved
 // fault restores the default disposition so the retry terminates the process.
 static void SignalHandler(int sig, siginfo_t* si, void* uctx) {
+	if (g_in_exception_filter) {
+		FailFast("nested exception while resolving a host fault");
+	}
+	g_in_exception_filter = true;
+
 	auto*       uc = static_cast<ucontext_t*>(uctx);
 	const auto* mc = uc->uc_mcontext;
 	const auto& ss = mc->__ss;
@@ -151,7 +210,14 @@ static void SignalHandler(int sig, siginfo_t* si, void* uctx) {
 	info.r15 = ss.__r15;
 
 	const auto handler = g_handler.load(std::memory_order_acquire);
-	if (handler != nullptr && handler(info)) {
+	if (handler == nullptr) {
+		FailFast("host exception callback is null");
+	}
+
+	const bool resolved   = handler(info);
+	g_in_exception_filter = false;
+
+	if (resolved) {
 		return; // retry the faulting instruction against the fixed mapping
 	}
 
@@ -178,6 +244,8 @@ static void ChainToDefault(int signal_number) noexcept {
 }
 
 static void SignalHandler(int signal_number, siginfo_t* signal_info, void* native_context) {
+	FilterScope filter_scope;
+
 	auto* context = static_cast<ucontext_t*>(native_context);
 	auto* gregs   = context->uc_mcontext.gregs;
 
@@ -221,8 +289,9 @@ static void SignalHandler(int signal_number, siginfo_t* signal_info, void* nativ
 	info.r14 = static_cast<uint64_t>(gregs[REG_R14]);
 	info.r15 = static_cast<uint64_t>(gregs[REG_R15]);
 
-	const auto handler = g_handler.load(std::memory_order_acquire);
-	if (handler != nullptr && handler(info)) {
+	const auto handler = LoadInstalledHandler();
+
+	if (handler(info)) {
 		return;
 	}
 
@@ -244,7 +313,7 @@ bool InstallHandler(Handler handler) {
 	g_handler.store(handler, std::memory_order_release);
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-	if (AddVectoredExceptionHandler(0, ExceptionFilter) == nullptr) {
+	if (AddVectoredExceptionHandler(1, ExceptionFilter) == nullptr) {
 		g_handler.store(nullptr, std::memory_order_release);
 		g_install_state.store(0, std::memory_order_release);
 		printf("AddVectoredExceptionHandler() failed\n");

src/common/logging/log.cpp

@@ -149,7 +149,7 @@ void WriteFatal(fmt::text_style style, std::string_view text) {
 	Flush();
 }
 
-void Initialize() {
+KYTY_SUBSYSTEM_INIT(Log) {
 	g_initialized = true;
 	switch (Config::GetPrintfDirection()) {
 		case Config::OutputDirection::Silent: g_direction = Direction::Silent; break;
@@ -161,7 +161,13 @@ void Initialize() {
 	SetupLogger();
 }
 
-void Shutdown() {
+KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Log) {
+	Flush();
+	std::lock_guard lock(g_logger_mutex);
+	g_logger.reset();
+}
+
+KYTY_SUBSYSTEM_DESTROY(Log) {
 	Flush();
 	std::lock_guard lock(g_logger_mutex);
 	g_logger.reset();

src/common/logging/log.h

@@ -2,6 +2,7 @@
 #define KYTY_COMMON_LOGGING_LOG_H_
 
 #include "common/common.h"
+#include "common/subsystems.h"
 
 #include <fmt/color.h>
 #include <fmt/printf.h>
@@ -9,15 +10,7 @@
 
 namespace Log {
 
-void Initialize();
-void Shutdown();
-
-struct Lifecycle {
-	static constexpr const char* name               = "Log";
-	static constexpr auto        initialize         = Log::Initialize;
-	static constexpr auto        shutdown           = Log::Shutdown;
-	static constexpr auto        emergency_shutdown = Log::Shutdown;
-};
+KYTY_SUBSYSTEM_DEFINE(Log);
 
 enum class Direction { Silent, Console, File };
 

src/common/platform/sysFileIO.h

@@ -80,7 +80,7 @@ void SysFileFindFiles(const std::filesystem::path& path, std::vector<sys_file_fi
 // NOLINTNEXTLINE(google-runtime-references)
 void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entry_t>& out);
 bool SysFileCopyFile(const std::filesystem::path& src, const std::filesystem::path& dst);
-bool SysFileRenameFile(const std::filesystem::path& src, const std::filesystem::path& dst);
+bool SysFileMoveFile(const std::filesystem::path& src, const std::filesystem::path& dst);
 void SysFileRemoveReadonly(const std::filesystem::path& name);
 
 #endif /* KYTY_COMMON_PLATFORM_SYSFILEIO_H_ */

src/common/platform/sysLinuxFileIO.cpp

@@ -693,7 +693,7 @@ bool SysFileCopyFile(const std::filesystem::path& src, const std::filesystem::pa
 	       !error;
 }
 
-bool SysFileRenameFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
+bool SysFileMoveFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
 	auto real_src = get_internal_name(src);
 	auto real_dst = get_internal_name(dst);
 

src/common/platform/sysWindowsDbg.cpp

@@ -15,8 +15,56 @@
 #include "common/assert.h"
 #include "common/platform/sysDbg.h"
 
+struct FrameS {
+	struct FrameS* next;
+	void*          ret_addr;
+};
+
+int WalkStack(int z_stack_depth, void** z_stack_trace) {
+	CONTEXT context;
+	//	KNONVOLATILE_CONTEXT_POINTERS NvContext;
+	PRUNTIME_FUNCTION runtime_function  = nullptr;
+	PVOID             handler_data      = nullptr;
+	ULONG64           establisher_frame = 0;
+	ULONG64           image_base        = 0;
+
+	RtlCaptureContext(&context);
+
+	int frame = 0;
+
+	while (true) {
+		if (frame >= z_stack_depth) {
+			break;
+		}
+
+		z_stack_trace[frame] = reinterpret_cast<void*>(context.Rip);
+
+		frame++;
+
+		runtime_function = RtlLookupFunctionEntry(context.Rip, &image_base, nullptr);
+
+		if (runtime_function == nullptr) {
+			break;
+		}
+
+		// RtlZeroMemory(&NvContext, sizeof(KNONVOLATILE_CONTEXT_POINTERS));
+		RtlVirtualUnwind(0, image_base, context.Rip, runtime_function, &context, &handler_data,
+		                 &establisher_frame, nullptr /*&NvContext*/);
+
+		if (context.Rip == 0u) {
+			break;
+		}
+	}
+
+	return frame;
+}
+
 void SysStackWalk(void** stack, int* depth) {
-	*depth = static_cast<int>(CaptureStackBackTrace(0, static_cast<DWORD>(*depth), stack, nullptr));
+	int n  = WalkStack(*depth, stack);
+	*depth = n;
+	//	unwind_info_t info = {stack, 0, *depth};
+	//	 _Unwind_Backtrace(&trace_fcn, &info);
+	//	 *depth = info.depth;
 }
 
 void SysStackUsagePrint(sys_dbg_stack_info_t& stack) {

src/common/platform/sysWindowsFileIO.cpp

@@ -565,7 +565,7 @@ bool SysFileCopyFile(const std::filesystem::path& src, const std::filesystem::pa
 	return CopyFileW(src_wide.c_str(), dst_wide.c_str(), FALSE) != 0;
 }
 
-bool SysFileRenameFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
+bool SysFileMoveFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
 	auto src_wide = src.wstring();
 	auto dst_wide = dst.wstring();
 	return MoveFileW(src_wide.c_str(), dst_wide.c_str()) != 0;

src/common/profiler.cpp

@@ -1,6 +1,7 @@
 #include "common/profiler.h"
 
 #include "common/emulatorConfig.h"
+#include "common/subsystems.h"
 
 #include <algorithm>
 #include <common/TracyProtocol.hpp>
@@ -54,7 +55,13 @@ void SetThreadName(const char* name) {
 	}
 }
 
-void Initialize() {
+void Close() {
+	if (tracy::ProfilerAvailable()) {
+		tracy::ShutdownProfiler();
+	}
+}
+
+KYTY_SUBSYSTEM_INIT(Profiler) {
 	switch (Config::GetProfilerDirection()) {
 		case Config::ProfilerDirection::Network:
 			if (!tracy::ProfilerAvailable()) {
@@ -71,10 +78,12 @@ void Initialize() {
 	}
 }
 
-void Shutdown() {
-	if (tracy::ProfilerAvailable()) {
-		tracy::ShutdownProfiler();
-	}
+KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Profiler) {
+	Close();
+}
+
+KYTY_SUBSYSTEM_DESTROY(Profiler) {
+	Close();
 }
 
 } // namespace Profiler

src/common/profiler.h

@@ -2,6 +2,7 @@
 #define KYTY_COMMON_PROFILER_H_
 
 #include "common/common.h"
+#include "common/subsystems.h"
 
 #include <cstdint>
 #include <optional>
@@ -41,15 +42,7 @@ private:
 void EndBlock();
 void SetThreadName(const char* name);
 
-void Initialize();
-void Shutdown();
-
-struct Lifecycle {
-	static constexpr const char* name               = "Profiler";
-	static constexpr auto        initialize         = Profiler::Initialize;
-	static constexpr auto        shutdown           = Profiler::Shutdown;
-	static constexpr auto        emergency_shutdown = Profiler::Shutdown;
-};
+KYTY_SUBSYSTEM_DEFINE(Profiler);
 
 } // namespace Profiler
 

src/common/slotVector.h

@@ -1,132 +0,0 @@
-#ifndef EMULATOR_SRC_COMMON_SLOTVECTOR_H_
-#define EMULATOR_SRC_COMMON_SLOTVECTOR_H_
-
-#include "common/assert.h"
-#include "common/abi.h"
-
-#include <compare>
-#include <cstdint>
-#include <deque>
-#include <functional>
-#include <limits>
-#include <optional>
-#include <utility>
-#include <vector>
-
-namespace Common {
-
-struct SlotId {
-	static constexpr uint32_t INVALID_INDEX = std::numeric_limits<uint32_t>::max();
-
-	constexpr SlotId() noexcept = default;
-	constexpr SlotId(uint32_t value) noexcept: index(value), generation(1) {}
-	constexpr SlotId(uint32_t value, uint32_t slot_generation) noexcept
-	    : index(value), generation(slot_generation) {}
-
-	[[nodiscard]] constexpr explicit operator bool() const noexcept { return index != INVALID_INDEX; }
-	constexpr auto operator<=>(const SlotId&) const noexcept = default;
-
-	uint32_t index = INVALID_INDEX;
-	uint32_t generation = 0;
-};
-
-// Stable-address slot storage for cache resources that are intentionally non-movable.
-template <typename T>
-class SlotVector {
-public:
-	SlotVector() = default;
-	KYTY_CLASS_NO_COPY(SlotVector);
-
-	[[nodiscard]] T& operator[](SlotId id) noexcept {
-		EXIT_IF(!is_allocated(id));
-		return *m_values[id.index].value;
-	}
-
-	[[nodiscard]] const T& operator[](SlotId id) const noexcept {
-		EXIT_IF(!is_allocated(id));
-		return *m_values[id.index].value;
-	}
-
-	[[nodiscard]] T* try_get(SlotId id) noexcept {
-		return is_allocated(id) ? &*m_values[id.index].value : nullptr;
-	}
-
-	[[nodiscard]] const T* try_get(SlotId id) const noexcept {
-		return is_allocated(id) ? &*m_values[id.index].value : nullptr;
-	}
-
-	[[nodiscard]] bool is_allocated(SlotId id) const noexcept {
-		return id && id.index < m_values.size() &&
-		       m_values[id.index].generation == id.generation && m_values[id.index].value.has_value();
-	}
-
-	template <typename... Args>
-	[[nodiscard]] SlotId insert(Args&&... args) {
-		uint32_t index = 0;
-		if (m_free_list.empty()) {
-			index = static_cast<uint32_t>(m_values.size());
-			m_values.emplace_back();
-			m_values.back().value.emplace(std::forward<Args>(args)...);
-		} else {
-			index = m_free_list.back();
-			m_free_list.pop_back();
-			EXIT_IF(m_values[index].value.has_value());
-			m_values[index].value.emplace(std::forward<Args>(args)...);
-		}
-		++m_size;
-		return SlotId {index, m_values[index].generation};
-	}
-
-	void erase(SlotId id) noexcept {
-		EXIT_IF(!is_allocated(id));
-		auto& slot = m_values[id.index];
-		slot.value.reset();
-		if (++slot.generation == 0) {
-			slot.generation = 1;
-		}
-		m_free_list.push_back(id.index);
-		--m_size;
-	}
-
-	[[nodiscard]] size_t size() const noexcept { return m_size; }
-	[[nodiscard]] size_t capacity() const noexcept { return m_values.size(); }
-
-	template <typename F>
-	void ForEach(F&& fn) {
-		for (uint32_t index = 0; index < m_values.size(); ++index) {
-			if (m_values[index].value) {
-				fn(SlotId {index, m_values[index].generation}, *m_values[index].value);
-			}
-		}
-	}
-
-	template <typename F>
-	void ForEach(F&& fn) const {
-		for (uint32_t index = 0; index < m_values.size(); ++index) {
-			if (m_values[index].value) {
-				fn(SlotId {index, m_values[index].generation}, *m_values[index].value);
-			}
-		}
-	}
-
-private:
-	struct Slot {
-		std::optional<T> value;
-		uint32_t         generation = 1;
-	};
-
-	std::deque<Slot>             m_values;
-	std::vector<uint32_t>        m_free_list;
-	size_t                       m_size = 0;
-};
-
-} // namespace Common
-
-template <>
-struct std::hash<Common::SlotId> {
-	[[nodiscard]] size_t operator()(Common::SlotId id) const noexcept {
-		return std::hash<uint64_t> {}((static_cast<uint64_t>(id.generation) << 32u) | id.index);
-	}
-};
-
-#endif // EMULATOR_SRC_COMMON_SLOTVECTOR_H_

src/common/subsystems.cpp

@@ -1,43 +1,232 @@
 #include "common/subsystems.h"
 
+#include "common/assert.h"
+
+#include <cstdarg>
+#include <cstdio>
+#include <cstring>
+#include <memory>
+#include <string>
+
 namespace Common {
 
-static Subsystems* g_active_subsystems = nullptr;
+class SubsystemPrivate {
+public:
+	SubsystemPrivate()          = default;
+	virtual ~SubsystemPrivate() = default;
 
-Subsystems::Subsystems(bool print): m_print(print) {
-	m_active.reserve(16);
-	g_active_subsystems = this;
-}
+	KYTY_CLASS_NO_COPY(SubsystemPrivate);
 
-Subsystems::~Subsystems() {
-	Destroy();
-	if (g_active_subsystems == this) {
-		g_active_subsystems = nullptr;
+	bool        failed {false};
+	std::string fail_msg;
+};
+
+class SubsystemsListPrivate {
+public:
+	explicit SubsystemsListPrivate(SubsystemsList& p): parent(p) {}
+
+	virtual ~SubsystemsListPrivate() = default;
+
+	void SetArgs(int argc, char** argv) {
+		this->m_argc = argc;
+		this->m_argv = argv;
 	}
-}
 
-void Subsystems::Destroy() {
-	for (auto it = m_active.rbegin(); it != m_active.rend(); ++it) {
-		if (it->shutdown != nullptr) {
-			it->shutdown();
+	void Add(Subsystem* s, std::initializer_list<Subsystem*> deps) {
+		EXIT_IF(!s);
+
+		const char* name = s->Id();
+
+		EXIT_IF(FindByName(name) != nullptr);
+
+		auto nl = std::make_unique<SubsListStruct>();
+
+		nl->s         = s;
+		nl->name      = name;
+		nl->deps      = nullptr;
+		nl->next      = std::move(list);
+		nl->prev_init = nullptr;
+
+		auto* node = nl.get();
+		list       = std::move(nl);
+
+		for (auto* dep: deps) {
+			const char* str = dep->Id();
+
+			auto l      = std::make_unique<DepsListStruct>();
+			l->dep_name = str;
+			l->next     = std::move(node->deps);
+
+			node->deps = std::move(l);
 		}
-	}
-	m_active.clear();
-}
 
-void Subsystems::EmergencyShutdown() {
-	for (auto it = m_active.rbegin(); it != m_active.rend(); ++it) {
-		if (it->emergency_shutdown != nullptr) {
-			it->emergency_shutdown();
+		node->initialized = false;
+	}
+
+	bool InitAll(bool print_msg) {
+		while (SubsListStruct* n = FindNextToInitialize()) {
+			n->s->Init(&parent);
+
+			if (n->s->m_p->failed) {
+				fail_msg  = n->s->m_p->fail_msg.c_str();
+				fail_name = n->name;
+				return false;
+			}
+
+			if (print_msg) {
+				printf("Initialized: %s\n", n->name);
+			}
+
+			n->initialized = true;
+
+			SubsListStruct* last = last_init;
+			last_init            = n;
+			n->prev_init         = last;
 		}
+
+		return true;
 	}
-	m_active.clear();
+
+	void DestroyAll(bool print_msg) {
+		for (SubsListStruct* n = last_init; n != nullptr; n = n->prev_init) {
+			n->s->Destroy(&parent);
+			n->initialized = false;
+
+			if (print_msg) {
+				printf("Destroyed: %s\n", n->name);
+			}
+		}
+
+		last_init = nullptr;
+	}
+
+	void ShutdownAll() {
+		for (SubsListStruct* n = last_init; n != nullptr; n = n->prev_init) {
+			n->s->UnexpectedShutdown(&parent);
+			n->initialized = false;
+		}
+
+		last_init = nullptr;
+	}
+
+	struct DepsListStruct {
+		const char*                     dep_name;
+		std::unique_ptr<DepsListStruct> next;
+	};
+
+	struct SubsListStruct {
+		Subsystem*                      s;
+		const char*                     name;
+		std::unique_ptr<DepsListStruct> deps;
+		std::unique_ptr<SubsListStruct> next;
+		SubsListStruct*                 prev_init;
+		bool                            initialized;
+	};
+
+	[[nodiscard]] SubsListStruct* FindByName(const char* name) const {
+		for (SubsListStruct* n = list.get(); n != nullptr; n = n->next.get()) {
+			if (std::strcmp(n->name, name) == 0) {
+				return n;
+			}
+		}
+
+		return nullptr;
+	}
+
+	[[nodiscard]] SubsListStruct* FindNextToInitialize() const {
+		for (SubsListStruct* n = list.get(); n != nullptr; n = n->next.get()) {
+			if (n->initialized) {
+				continue;
+			}
+
+			DepsListStruct* d = n->deps.get();
+			for (; d != nullptr; d = d->next.get()) {
+				SubsListStruct* s = FindByName(d->dep_name);
+				if ((s == nullptr) || !s->initialized) {
+					break;
+				}
+			}
+
+			if (d == nullptr) {
+				return n;
+			}
+		}
+
+		return nullptr;
+	}
+
+	KYTY_CLASS_NO_COPY(SubsystemsListPrivate);
+
+	std::unique_ptr<SubsListStruct> list;
+	SubsListStruct*                 last_init = nullptr;
+	int                             m_argc    = 0;
+	char**                          m_argv    = nullptr;
+	const char*                     fail_msg  = nullptr;
+	const char*                     fail_name = nullptr;
+	SubsystemsList&                 parent;
+};
+
+SubsystemsList::SubsystemsList(): m_p(std::make_unique<SubsystemsListPrivate>(*this)) {}
+
+SubsystemsList::~SubsystemsList() = default;
+
+void SubsystemsList::Add(Subsystem* s, std::initializer_list<Subsystem*> deps) {
+	m_p->Add(s, deps);
 }
 
-void Subsystems::EmergencyShutdownActive() {
-	if (g_active_subsystems != nullptr) {
-		g_active_subsystems->EmergencyShutdown();
+bool SubsystemsList::InitAll(bool print_msg) {
+	return m_p->InitAll(print_msg);
+}
+
+void SubsystemsList::DestroyAll(bool print_msg) {
+	m_p->DestroyAll(print_msg);
+}
+
+int* SubsystemsList::GetArgc() {
+	return &m_p->m_argc;
+}
+
+char** SubsystemsList::GetArgv() {
+	return m_p->m_argv;
+}
+
+Subsystem::Subsystem(): m_p(std::make_unique<SubsystemPrivate>()) {}
+
+Subsystem::~Subsystem() = default;
+
+void Subsystem::Fail(const char* format, ...) {
+	va_list args {};
+	va_start(args, format);
+
+	va_list args_copy {};
+	va_copy(args_copy, args);
+	int len = std::vsnprintf(nullptr, 0, format, args_copy);
+	va_end(args_copy);
+
+	if (len > 0) {
+		std::string msg(static_cast<size_t>(len) + 1, '\0');
+		std::vsnprintf(msg.data(), msg.size(), format, args);
+		m_p->fail_msg = msg.c_str();
+		m_p->failed   = true;
 	}
+
+	va_end(args);
+}
+
+const char* SubsystemsList::GetFailName() const {
+	return m_p->fail_name;
+}
+
+const char* SubsystemsList::GetFailMsg() const {
+	return m_p->fail_msg;
+}
+
+void SubsystemsList::SetArgs(int argc, char* argv[]) {
+	m_p->SetArgs(argc, argv);
+}
+
+void SubsystemsList::ShutdownAll() {
+	m_p->ShutdownAll();
 }
 
 } // namespace Common

src/common/subsystems.h

@@ -2,61 +2,90 @@
 #define KYTY_COMMON_SUBSYSTEMS_H_
 
 #include "common/common.h"
+#include "common/singleton.h"
 
-#include <cstdio>
-#include <vector>
+#include <initializer_list>
+#include <memory>
 
 namespace Common {
 
-class Subsystems {
+class Subsystem;
+class SubsystemsListPrivate;
+class SubsystemPrivate;
+
+class SubsystemsList {
 public:
-	using Callback = void (*)();
+	SubsystemsList();
+	virtual ~SubsystemsList();
+	void SetArgs(int argc, char* argv[]);
 
-	explicit Subsystems(bool print = false);
-	~Subsystems();
+	// void Add(Subsystem* s, const char* name, ...);
+	void Add(Subsystem* s, std::initializer_list<Subsystem*> deps);
 
-	template <typename Lifecycle>
-	void Initialize() {
-		Lifecycle::initialize();
-		m_active.push_back({ShutdownCallback<Lifecycle>(), EmergencyCallback<Lifecycle>()});
-		if (m_print) {
-			std::printf("Initialized: %s\n", Lifecycle::name);
-		}
-	}
+	bool InitAll(bool print_msg = false);
+	void DestroyAll(bool print_msg = false);
 
-	void Destroy();
-	void EmergencyShutdown();
+	int*   GetArgc();
+	char** GetArgv();
 
-	static void EmergencyShutdownActive();
+	[[nodiscard]] const char* GetFailName() const;
+	[[nodiscard]] const char* GetFailMsg() const;
 
-	KYTY_CLASS_NO_COPY(Subsystems);
+	void ShutdownAll();
+
+	static SubsystemsList* Instance() { return Common::Singleton<SubsystemsList>::Instance(); }
+
+	KYTY_CLASS_NO_COPY(SubsystemsList);
 
 private:
-	template <typename Lifecycle>
-	static consteval Callback ShutdownCallback() {
-		if constexpr (requires { Lifecycle::shutdown; }) {
-			return Lifecycle::shutdown;
-		}
-		return nullptr;
-	}
-
-	template <typename Lifecycle>
-	static consteval Callback EmergencyCallback() {
-		if constexpr (requires { Lifecycle::emergency_shutdown; }) {
-			return Lifecycle::emergency_shutdown;
-		}
-		return nullptr;
-	}
-
-	struct Entry {
-		Callback shutdown;
-		Callback emergency_shutdown;
-	};
-
-	std::vector<Entry> m_active;
-	bool               m_print;
+	std::unique_ptr<SubsystemsListPrivate> m_p;
 };
 
+using SubsystemsListSingleton = Common::Singleton<SubsystemsList>;
+
+class Subsystem {
+public:
+	Subsystem();
+	virtual ~Subsystem();
+
+	virtual const char* Id()                                       = 0;
+	virtual void        Init(SubsystemsList* parent)               = 0;
+	virtual void        Destroy(SubsystemsList* parent)            = 0;
+	virtual void        UnexpectedShutdown(SubsystemsList* parent) = 0;
+
+	friend class SubsystemsListPrivate;
+
+	KYTY_CLASS_NO_COPY(Subsystem);
+
+protected:
+	void Fail(const char* format, ...) KYTY_FORMAT_PRINTF(2, 3);
+
+private:
+	std::unique_ptr<SubsystemPrivate> m_p;
+};
+
+#define KYTY_SUBSYSTEM_DEFINE(s)                                                                   \
+	class s##Subsystem: public Common::Subsystem {                                                 \
+	public:                                                                                        \
+		static Subsystem* Instance() { return Common::Singleton<s##Subsystem>::Instance(); }       \
+		const char*       Id() { return #s; }                                                      \
+		void              Init(Common::SubsystemsList* parent);                                    \
+		void              Destroy(Common::SubsystemsList* parent);                                 \
+		void              UnexpectedShutdown(Common::SubsystemsList* parent);                      \
+	};                                                                                             \
+	typedef Common::Singleton<s##Subsystem> s##SubsystemSingleton;
+
+#define KYTY_SUBSYSTEM_INIT(s)                                                                     \
+	void s##Subsystem::Init([[maybe_unused]] Common::SubsystemsList* parent)
+#define KYTY_SUBSYSTEM_DESTROY(s)                                                                  \
+	void s##Subsystem::Destroy([[maybe_unused]] Common::SubsystemsList* parent)
+#define KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(s)                                                      \
+	void s##Subsystem::UnexpectedShutdown([[maybe_unused]] Common::SubsystemsList* parent)
+
+// #define KYTY_SUBSYSTEM_ADD(list, s, ...) list.push_back(s##SubsystemSingleton::Instance(), #s,
+// __VA_ARGS__); #define KYTY_SUBSYSTEM_ADD2(list, ...) list.Add2(s##SubsystemSingleton::Instance(),
+// __VA_ARGS__);
+
 } // namespace Common
 
 #endif /* KYTY_COMMON_SUBSYSTEMS_H_ */

src/common/threads.cpp

@@ -28,8 +28,7 @@
 #ifdef KYTY_WIN_CS
 #include <windows.h> // IWYU pragma: keep
 // IWYU pragma: no_include <winbase.h>
-constexpr DWORD    KYTY_CS_SPIN_COUNT          = 4000;
-constexpr uint64_t KYTY_SLEEP_SPIN_LIMIT_100NS = 500; // 50 us
+constexpr DWORD KYTY_CS_SPIN_COUNT = 4000;
 
 #ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION
 #define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x00000002
@@ -40,10 +39,7 @@ static void SleepHighResolution100ns(uint64_t units_100ns) {
 		return;
 	}
 
-	// Keep spinning only where a kernel transition is
-	// likely to cost more than the requested delay; ordinary millisecond sleeps use the
-	// per-thread high-resolution waitable timer below.
-	if (units_100ns <= KYTY_SLEEP_SPIN_LIMIT_100NS) {
+	if (units_100ns <= 10000) {
 		LARGE_INTEGER frequency {};
 		LARGE_INTEGER start {};
 		if (QueryPerformanceFrequency(&frequency) != 0 && QueryPerformanceCounter(&start) != 0 &&
@@ -252,11 +248,15 @@ static thread_id_t      g_main_thread;
 static int              g_main_thread_int;
 static std::atomic<int> g_thread_counter = 0;
 
-void InitializeThreads() {
+KYTY_SUBSYSTEM_INIT(Threads) {
 	g_main_thread     = std::this_thread::get_id();
 	g_main_thread_int = Thread::GetThreadIdUnique();
 }
 
+KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Threads) {}
+
+KYTY_SUBSYSTEM_DESTROY(Threads) {}
+
 Thread::Thread(thread_func_t func, void* arg)
     : m_thread(std::make_unique<ThreadPrivate>(func, arg)) {
 	while (!m_thread->started) {

src/common/threads.h

@@ -2,13 +2,14 @@
 #define KYTY_COMMON_THREADS_H_
 
 #include "common/common.h"
+#include "common/subsystems.h"
 
 #include <memory>
 #include <string>
 
 namespace Common {
 
-void InitializeThreads();
+KYTY_SUBSYSTEM_DEFINE(Threads);
 
 using thread_func_t    = void (*)(void*);
 using wait_poll_func_t = void (*)();

src/emulator.cpp

@@ -2,6 +2,7 @@
 
 #include "common/abi.h"
 #include "common/assert.h"
+#include "common/commonSubsystem.h"
 #include "common/emulatorConfig.h"
 #include "common/file.h"
 #include "common/logging/log.h"
@@ -15,7 +16,6 @@
 #include "kernel/fileSystem.h"
 #include "kernel/memory.h"
 #include "kernel/pthread.h"
-#include "kytyGitVersion.h"
 #include "libs/agc.h"
 #include "libs/audio.h"
 #include "libs/controller.h"
@@ -27,31 +27,13 @@
 
 #include <cstdlib>
 #include <filesystem>
-#include <thread>
 
 namespace Emulator {
 
 static void PrintSystemInfo() {
-	const Common::SystemInfo info = Common::GetSystemInfo();
+	Common::SystemInfo info = Common::GetSystemInfo();
 
-#if defined(__APPLE__)
-	static constexpr auto platform_name = "macOS";
-#elif KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-	static constexpr auto platform_name = "Windows";
-#elif KYTY_PLATFORM == KYTY_PLATFORM_LINUX
-	static constexpr auto platform_name = "Linux";
-#else
-	static constexpr auto platform_name = "Unknown";
-#endif
-
-	LOGF("Build\n"
-	     "  version: %s\n\n"
-	     "Host\n"
-	     "  os:      %s\n"
-	     "  cpu:     %s\n"
-	     "  threads: %u\n\n",
-	     KYTY_BUILD_LABEL, platform_name, info.ProcessorName.c_str(),
-	     std::thread::hardware_concurrency());
+	LOGF("ProcessorName = %s\n", info.ProcessorName.c_str());
 }
 
 static void KytyClose() {
@@ -61,7 +43,7 @@ static void KytyClose() {
 
 	LOGF("done!\n");
 
-	Common::Subsystems::EmergencyShutdownActive();
+	Common::SubsystemsListSingleton::Instance()->ShutdownAll();
 }
 
 static void MountOrCreateDir(const std::filesystem::path& dir, const std::string& point) {
@@ -123,13 +105,30 @@ static void ClearDebugTextureFolder() {
 	}
 }
 
-static void Init(const Config::ConfigOptions& cfg, const std::filesystem::path& param_json,
-                 Common::Subsystems& subsystems) {
+static void Init(const Config::ConfigOptions& cfg, const std::filesystem::path& param_json) {
 	EXIT_IF(!Common::Thread::IsMainThread());
 
-	subsystems.Initialize<Config::Lifecycle>();
+	auto* slist = Common::SubsystemsList::Instance();
+
+	auto* audio       = Libs::Audio::AudioSubsystem::Instance();
+	auto* config      = Config::ConfigSubsystem::Instance();
+	auto* controller  = Libs::Controller::ControllerSubsystem::Instance();
+	auto* core        = Common::CommonSubsystem::Instance();
+	auto* file_system = Libs::LibKernel::FileSystem::FileSystemSubsystem::Instance();
+	auto* graphics    = Libs::Graphics::GraphicsSubsystem::Instance();
+	auto* log         = Log::LogSubsystem::Instance();
+	auto* memory      = Libs::LibKernel::Memory::MemorySubsystem::Instance();
+	auto* network     = Libs::Network::NetworkSubsystem::Instance();
+	auto* profiler    = Profiler::ProfilerSubsystem::Instance();
+	auto* pthread     = Libs::LibKernel::PthreadSubsystem::Instance();
+	auto* timer       = Loader::Timer::TimerSubsystem::Instance();
+
+	slist->Add(config, {core});
+	slist->InitAll(true);
+
 	Config::Load(cfg);
-	subsystems.Initialize<Log::Lifecycle>();
+	slist->Add(log, {core, config});
+	slist->InitAll(true);
 
 	if (Common::File::IsFileExisting(param_json)) {
 		Loader::SystemContentLoadParamSfo(param_json);
@@ -139,16 +138,17 @@ static void Init(const Config::ConfigOptions& cfg, const std::filesystem::path&
 		}
 	}
 
-	// Initialization order is explicit; destruction is automatic and reversed.
-	subsystems.Initialize<Loader::Timer::Lifecycle>();
-	subsystems.Initialize<Libs::LibKernel::PthreadLifecycle>();
-	subsystems.Initialize<Profiler::Lifecycle>();
-	subsystems.Initialize<Libs::Network::Lifecycle>();
-	subsystems.Initialize<Libs::LibKernel::Memory::Lifecycle>();
-	subsystems.Initialize<Libs::LibKernel::FileSystem::Lifecycle>();
-	subsystems.Initialize<Libs::Controller::Lifecycle>();
-	subsystems.Initialize<Libs::Audio::Lifecycle>();
-	subsystems.Initialize<Libs::Graphics::Lifecycle>();
+	slist->Add(audio, {core, log, pthread, memory});
+	slist->Add(controller, {core, log, config});
+	slist->Add(file_system, {core, log, pthread});
+	slist->Add(graphics, {core, log, pthread, memory, config, profiler, controller});
+	slist->Add(memory, {core, log});
+	slist->Add(network, {core, log, pthread});
+	slist->Add(profiler, {core, config});
+	slist->Add(pthread, {core, log, timer});
+	slist->Add(timer, {core, log});
+
+	slist->InitAll(true);
 }
 
 static void LoadElf(const std::filesystem::path& elf, bool dbg_print_reloc = false,
@@ -189,9 +189,8 @@ void Run(const RunOptions& options) {
 		EXIT("ELF is required\n");
 	}
 
-	const auto         param_json = options.app0_dir / "sce_sys" / "param.json";
-	Common::Subsystems subsystems(true);
-	Init(options.config, param_json, subsystems);
+	const auto param_json = options.app0_dir / "sce_sys" / "param.json";
+	Init(options.config, param_json);
 
 	ClearDebugTextureFolder();
 
@@ -200,10 +199,6 @@ void Run(const RunOptions& options) {
 	int ok = atexit(KytyClose);
 	EXIT_NOT_IMPLEMENTED(ok != 0);
 
-	// Guest threads are still running, so skip KytyClose() and only flush emergency state.
-	ok = at_quick_exit(Common::Subsystems::EmergencyShutdownActive);
-	EXIT_NOT_IMPLEMENTED(ok != 0);
-
 	Libs::LibKernel::FileSystem::Mount(options.app0_dir, "/app0");
 	Libs::LibKernel::FileSystem::Mount(options.app0_dir, "/hostapp");
 

src/generate_version.cmake

@@ -1,9 +1,7 @@
 set(KYTY_GIT_VERSION "unknown")
-set(KYTY_GIT_HASH "unknown")
-set(KYTY_GIT_REVISION "unknown")
 if(GIT_EXECUTABLE)
 	execute_process(
-		COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty
+		COMMAND "${GIT_EXECUTABLE}" describe --tags --always
 		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
 		OUTPUT_VARIABLE KYTY_GIT_VERSION
 		OUTPUT_STRIP_TRAILING_WHITESPACE
@@ -13,29 +11,5 @@ if(GIT_EXECUTABLE)
 	if(NOT GIT_RESULT EQUAL 0)
 		set(KYTY_GIT_VERSION "unknown")
 	endif()
-
-	execute_process(
-		COMMAND "${GIT_EXECUTABLE}" rev-parse HEAD
-		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
-		OUTPUT_VARIABLE KYTY_GIT_REVISION
-		OUTPUT_STRIP_TRAILING_WHITESPACE
-		RESULT_VARIABLE GIT_HASH_RESULT
-		ERROR_QUIET
-	)
-	if(NOT GIT_HASH_RESULT EQUAL 0)
-		set(KYTY_GIT_HASH "unknown")
-		set(KYTY_GIT_REVISION "unknown")
-	else()
-		string(SUBSTRING "${KYTY_GIT_REVISION}" 0 7 KYTY_GIT_HASH)
-		execute_process(
-			COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
-			WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
-			RESULT_VARIABLE GIT_DIRTY_RESULT
-			ERROR_QUIET
-		)
-		if(NOT GIT_DIRTY_RESULT EQUAL 0)
-			string(APPEND KYTY_GIT_HASH "-dirty")
-		endif()
-	endif()
 endif()
 configure_file("${INPUT_FILE}" "${OUTPUT_FILE}")

src/graphics/guest_gpu/command_processor/commandProcessor.h

@@ -7,7 +7,6 @@
 #include "graphics/host_gpu/renderer/renderContext.h"
 
 #include <cstdint>
-#include <span>
 #include <vector>
 
 namespace Libs::Graphics {
@@ -16,13 +15,6 @@ bool TestWaitRegMemValue(uint64_t value, uint64_t ref, uint64_t mask, uint32_t f
 
 enum class Pm4ProcessResult { Complete, Blocked };
 
-enum class ContextStateOperation : uint32_t {
-	Clear     = 0,
-	Push      = 1,
-	Pop       = 2,
-	PushClear = 3,
-};
-
 class Pm4Execution {
 public:
 	[[nodiscard]] bool MadeProgress() const noexcept { return m_made_progress; }
@@ -31,9 +23,10 @@ private:
 	friend class CommandProcessor;
 
 	struct BufferCursor {
-		std::span<const uint32_t> commands;
-		uint32_t                  offset_dw           = 0;
-		uint32_t                  deferred_advance_dw = 0;
+		uint32_t* next_packet         = nullptr;
+		uint32_t  remaining_dw        = 0;
+		uint32_t  total_dw            = 0;
+		uint32_t  deferred_advance_dw = 0;
 	};
 
 	std::vector<BufferCursor> m_buffer_stack;
@@ -50,19 +43,30 @@ public:
 		int64_t flip_arg  = 0;
 	};
 
-	CommandProcessor(RenderContext& renderer, int interrupt_event_id)
-	    : m_renderer(renderer), m_interrupt_event_id(interrupt_event_id) {}
+	explicit CommandProcessor(RenderContext& renderer): m_renderer(renderer) {}
 	~CommandProcessor() = default;
 
 	KYTY_CLASS_NO_COPY(CommandProcessor);
 
 	void Reset();
-	void ApplyContextStateOperation(ContextStateOperation operation);
 
-	void            BufferInit();
-	void            BufferFlush();
-	void            BufferFlushAndWait();
-	void            BufferWait();
+	void BufferInit();
+	void BufferFlush();
+	void BufferFlushAndWait();
+	void BufferWait();
+	void BeginReadbackTransaction() {
+		if (m_readback_active) {
+			EXIT("nested command-processor readback transaction\n");
+		}
+		m_readback_active = true;
+	}
+	void EndReadbackTransaction() {
+		if (!m_readback_active) {
+			EXIT("command-processor readback transaction is not active\n");
+		}
+		m_readback_active = false;
+	}
+
 	HW::Context&    GetCtx() { return m_ctx; }
 	HW::UserConfig& GetUcfg() { return m_ucfg; }
 	HW::Shader&     GetShCtx() { return m_sh_ctx; }
@@ -79,7 +83,8 @@ public:
 	               uint32_t first_instance = 0);
 	void DrawIndexOffset(uint32_t index_offset, uint32_t index_count, uint32_t flags);
 	void DrawIndexAuto(uint32_t index_count, uint32_t flags,
-	                   uint32_t render_target_slice_offset = 0);
+	                   uint32_t render_target_slice_offset = 0, uint32_t instance_count = 1,
+	                   uint32_t first_vertex = 0, uint32_t first_instance = 0);
 	void DrawIndirect(uint32_t data_offset, uint32_t draw_initiator, bool indexed);
 	void DrawIndirectMulti(uint32_t data_offset, uint32_t max_count_or_count,
 	                       const volatile uint32_t* count_addr, uint32_t stride_in_bytes,
@@ -104,7 +109,7 @@ public:
 	                    uint32_t mode);
 	void DispatchIndirect(uint32_t data_offset, uint32_t mode);
 	void WaitFlipDone(uint32_t video_out_handle, uint32_t display_buffer_index);
-	void TriggerEvent(uint32_t event_type, uint32_t event_index, uint64_t event_address = 0);
+	void TriggerEvent(uint32_t event_type, uint32_t event_index);
 
 	void SetUserDataMarker(HW::UserSgprType type) { m_user_data_marker = type; }
 	[[nodiscard]] HW::UserSgprType GetUserDataMarker() const { return m_user_data_marker; }
@@ -113,7 +118,6 @@ public:
 	void SetCeComplete(bool complete) { m_ce_complete = complete; }
 	void WaitCe();
 	void WaitDeDiff(uint32_t diff);
-	void WaitForRewind(bool valid);
 	void IncrementDe();
 	void IncrementCe();
 
@@ -132,14 +136,13 @@ public:
 	                    const volatile void* address, uint32_t count_in_dwords);
 	[[nodiscard]] bool ShouldSkipPredicatedPackets() const { return m_predicate_skip; }
 
-	Pm4ProcessResult Process(Pm4Execution& execution, std::span<const uint32_t> commands);
-	void             ProcessIndirectBuffer(std::span<const uint32_t> commands);
+	Pm4ProcessResult Process(Pm4Execution& execution, uint32_t* buffer, uint32_t size_dw);
+	void             ProcessIndirectBuffer(uint32_t* buffer, uint32_t size_dw);
 
 	void SetFlip(const FlipInfo& flip) { m_flip = flip; }
 
 	[[nodiscard]] uint64_t GetSubmitId() const { return m_submit_id; }
 	void                   SetSubmitId(uint64_t submit_id) { m_submit_id = submit_id; }
-	[[nodiscard]] bool     IsAsyncComputeQueue() const { return m_interrupt_event_id >= 0x20; }
 
 private:
 	template <typename T>
@@ -149,19 +152,14 @@ private:
 	                      uint32_t interrupt_context_id);
 	void ProcessPm4(Pm4Execution& execution, size_t stop_depth);
 	void SuspendPm4();
-	void SubmitNonIndexedDraw(uint32_t vertex_count, uint32_t flags,
-	                          uint32_t render_target_slice_offset, uint32_t first_vertex,
-	                          uint32_t first_instance);
 
-	CommandScheduler&   GetScheduler() const { return m_renderer.GetCommandScheduler(); }
-	CommandBuffer&      CurrentBuffer() { return GetScheduler().Current(); }
-	void                CheckBuffer() const { GetScheduler().CheckActive(); }
-	GpuResourceManager& GetGpuResources() const { return m_renderer.GetGpuResources(); }
+	CommandScheduler&    GetScheduler() const { return m_renderer.GetCommandScheduler(); }
+	RenderCommandBuffer& CurrentBuffer() { return GetScheduler().Current(); }
+	void                 CheckBuffer() const { GetScheduler().CheckActive(); }
+	GpuResourceManager&  GetGpuResources() const { return m_renderer.GetGpuResources(); }
 
 	RenderContext&   m_renderer;
 	HW::Context      m_ctx;
-	HW::Context      m_saved_ctx;
-	bool             m_context_state_pushed = false;
 	HW::UserConfig   m_ucfg;
 	HW::Shader       m_sh_ctx;
 	HW::UserSgprType m_user_data_marker                 = HW::UserSgprType::Unknown;
@@ -170,20 +168,18 @@ private:
 	uint64_t         m_index_base_addr                  = 0;
 	uint64_t         m_draw_indirect_args_base_addr     = 0;
 	uint64_t         m_dispatch_indirect_args_base_addr = 0;
-	// Persistent draw state: indirect draws update it for subsequent draws.
-	uint32_t m_num_instances = 1;
+	uint32_t         m_num_instances                    = 1;
 
-	uint32_t m_de_count    = 0;
-	uint32_t m_ce_count    = 0;
-	bool     m_ce_complete = false;
+	uint32_t m_de_count        = 0;
+	uint32_t m_ce_count        = 0;
+	bool     m_ce_complete     = false;
+	bool     m_readback_active = false;
 
 	uint32_t m_const_ram[0x3000] = {0};
 
-	FlipInfo  m_flip;
-	const int m_interrupt_event_id;
-	uint64_t  m_submit_id                   = 0;
-	uint64_t  m_synthetic_occlusion_counter = 0;
-	bool      m_predicate_skip              = false;
+	FlipInfo m_flip;
+	uint64_t m_submit_id      = 0;
+	bool     m_predicate_skip = false;
 };
 
 } // namespace Libs::Graphics

src/graphics/guest_gpu/command_processor/pm4Dispatch.cpp

@@ -23,8 +23,9 @@ constexpr auto MakeContextDispatchTable() {
 	g_hw_ctx_func[Pm4::DB_STENCIL_CLEAR]             = HwCtxSetStencilClear;
 	g_hw_ctx_func[Pm4::DB_DEPTH_CLEAR]               = HwCtxSetDepthClear;
 	g_hw_ctx_func[Pm4::PA_SC_SCREEN_SCISSOR_TL]      = HwCtxSetScreenScissor;
+	g_hw_ctx_func[Pm4::DB_Z_INFO]                    = HwCtxSetDepthRenderTarget;
 	g_hw_ctx_func[Pm4::DB_STENCIL_INFO]              = HwCtxSetStencilInfo;
-	g_hw_ctx_func[Pm4::DB_SHADING_RATE_ENCODING]     = HwCtxSetDepthShadingRateEncoding;
+	g_hw_ctx_func[Pm4::DB_HTILE_SURFACE]             = HwCtxSetDepthHtileSurface;
 	g_hw_ctx_func[Pm4::PA_SU_HARDWARE_SCREEN_OFFSET] = HwCtxSetHardwareScreenOffset;
 	g_hw_ctx_func[Pm4::PA_SC_WINDOW_OFFSET]          = HwCtxSetWindowOffset;
 	g_hw_ctx_func[Pm4::PA_SC_WINDOW_SCISSOR_TL]      = HwCtxSetWindowScissor;
@@ -34,6 +35,7 @@ constexpr auto MakeContextDispatchTable() {
 	}
 	g_hw_ctx_func[Pm4::CB_TARGET_MASK]                 = HwCtxSetRenderTargetMask;
 	g_hw_ctx_func[Pm4::PA_SC_GENERIC_SCISSOR_TL]       = HwCtxSetGenericScissor;
+	g_hw_ctx_func[Pm4::CB_BLEND_RED]                   = HwCtxSetBlendColor;
 	g_hw_ctx_func[Pm4::CB_DCC_CONTROL]                 = HwCtxSetCbDccControl;
 	g_hw_ctx_func[Pm4::DB_STENCIL_CONTROL]             = HwCtxSetStencilControl;
 	g_hw_ctx_func[Pm4::DB_STENCILREFMASK]              = HwCtxSetStencilMask;
@@ -74,13 +76,16 @@ constexpr auto MakeContextDispatchTable() {
 	g_hw_ctx_func[Pm4::PA_SC_BINNER_CNTL_0]                   = HwCtxSetPaScExtendedControl;
 	g_hw_ctx_func[Pm4::PA_SC_BINNER_CNTL_1]                   = HwCtxSetPaScExtendedControl;
 	g_hw_ctx_func[Pm4::PA_SC_CONSERVATIVE_RASTERIZATION_CNTL] = HwCtxSetPaScExtendedControl;
+	g_hw_ctx_func[Pm4::PA_SC_NGG_MODE_CNTL]                   = HwCtxSetPaScExtendedControl;
 	g_hw_ctx_func[Pm4::DB_ALPHA_TO_MASK]                      = HwCtxSetAlphaToMask;
 	g_hw_ctx_func[Pm4::VGT_DRAW_PAYLOAD_CNTL]                 = HwCtxSetDrawPayloadControl;
 	g_hw_ctx_func[Pm4::VGT_PRIMITIVEID_RESET]                 = HwCtxSetPrimitiveIdReset;
 	g_hw_ctx_func[Pm4::PA_CL_OBJPRIM_ID_CNTL]                 = HwCtxSetObjprimIdControl;
 	g_hw_ctx_func[Pm4::VGT_SHADER_STAGES_EN]                  = HwCtxSetShaderStages;
+	g_hw_ctx_func[Pm4::PA_CL_GB_VERT_CLIP_ADJ]                = HwCtxSetGuardBands;
 
 	for (uint32_t slot = 0; slot < 8; slot++) {
+		g_hw_ctx_func[Pm4::CB_COLOR0_BASE + slot * 15] = HwCtxSetRenderTarget;
 		g_hw_ctx_func[Pm4::CB_COLOR0_INFO + slot * 15] = HwCtxSetColorInfo;
 
 		g_hw_ctx_func[Pm4::CB_BLEND0_CONTROL + slot * 1] = HwCtxSetBlendControl;
@@ -113,21 +118,25 @@ constexpr auto MakeShaderDispatchTable() {
 	}
 
 	for (uint32_t slot = 0; slot < 4; slot++) {
-		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_PS_0 + slot] = HwShIgnoreUserAccumulator;
+		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_PS_0 + slot] = HwShSetPsUserAccumSgpr;
 	}
 
 	for (uint32_t slot = 0; slot < 4; slot++) {
-		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_ESGS_0 + slot] = HwShIgnoreUserAccumulator;
+		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_ESGS_0 + slot] = HwShSetGsUserAccumSgpr;
 	}
 	for (uint32_t slot = 0; slot < 4; slot++) {
-		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_LSHS_0 + slot] = HwShIgnoreUserAccumulator;
+		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_LSHS_0 + slot] = HwShSetHsUserAccumSgpr;
 	}
 
-	for (uint32_t slot = 0; slot < 4; slot++) {
-		g_hw_sh_func[Pm4::COMPUTE_USER_ACCUM_0 + slot] = HwShIgnoreUserAccumulator;
+	for (uint32_t slot = 0; Pm4::COMPUTE_USER_ACCUM_0 + slot < Pm4::COMPUTE_USER_DATA_0; slot++) {
+		g_hw_sh_func[Pm4::COMPUTE_USER_ACCUM_0 + slot] = HwShSetCsUserAccumSgpr;
 	}
 	g_hw_sh_func[Pm4::COMPUTE_PGM_LO]                  = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_PGM_HI]                  = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_TBA_LO]                  = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_TBA_HI]                  = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_TMA_LO]                  = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_TMA_HI]                  = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_PGM_RSRC1]               = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_PGM_RSRC2]               = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_START_X]                 = HwShSetCsRegisters;
@@ -137,16 +146,30 @@ constexpr auto MakeShaderDispatchTable() {
 	g_hw_sh_func[Pm4::COMPUTE_NUM_THREAD_Y]            = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_NUM_THREAD_Z]            = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_RESOURCE_LIMITS]         = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_DESTINATION_EN_SE0]      = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_DESTINATION_EN_SE1]      = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_TMPRING_SIZE]            = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_DESTINATION_EN_SE2]      = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_DESTINATION_EN_SE3]      = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_PGM_RSRC3]               = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_PACE_ID]                 = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::SPI_GRAPHICS_SHADER_CONTROL_PS]  = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_GRAPHICS_SHADER_CONTROL_GS]  = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_SHADER_CHKSUM]           = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_DISPATCH_TUNNEL]         = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_TBA_LO_PS]            = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC3_PS]         = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC4_PS]         = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_TMA_LO_PS]            = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_TMA_HI_PS]            = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_REQ_CTRL_PS]          = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC3_GS]         = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC4_GS]         = HwShIgnoreRegisters;
 	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_LO_GS] = HwShIgnoreRegisters;
 	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_HI_GS] = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_GRAPHICS_SHADER_CONTROL_HS]  = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_REQ_CTRL_ESGS]        = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC3_HS]         = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC4_HS]         = HwShIgnoreRegisters;
 	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_LO_HS] = HwShIgnoreRegisters;
 	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_HI_HS] = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_REQ_CTRL_LSHS]        = HwShIgnoreRegisters;
 
 	return g_hw_sh_func;
 }
@@ -158,7 +181,6 @@ constexpr auto MakeUconfigDispatchTable() {
 	g_hw_uc_func[Pm4::VGT_INDEX_TYPE]            = HwUcSetIndexType;
 	g_hw_uc_func[Pm4::VGT_OBJECT_ID]             = HwUcSetObjectId;
 	g_hw_uc_func[Pm4::TEXTURE_GRADIENT_FACTORS]  = HwUcSetTextureGradientFactors;
-	g_hw_uc_func[Pm4::TEXTURE_GRADIENT_CONTROL]  = HwUcSetTextureGradientFactors;
 	g_hw_uc_func[Pm4::IA_MULTI_VGT_PARAM]        = HwUcSetIaMultiVgtParam;
 	g_hw_uc_func[Pm4::GE_MULTI_PRIM_IB_RESET_EN] = HwUcSetMultiPrimIbReset;
 	g_hw_uc_func[Pm4::TA_CS_BC_BASE_ADDR]        = HwUcSetBorderColorTableAddr;
@@ -195,7 +217,6 @@ constexpr auto MakeOpcodeDispatchTable() {
 	g_cp_op_func[Pm4::IT_COND_EXEC]                 = CpOpCondExec;
 	g_cp_op_func[Pm4::IT_SET_PREDICATION]           = CpOpSetPredication;
 	g_cp_op_func[Pm4::IT_WRITE_DATA]                = CpOpWriteData;
-	g_cp_op_func[Pm4::IT_WAIT_REG_MEM]              = CpOpWaitRegMem32;
 	g_cp_op_func[Pm4::IT_INDIRECT_BUFFER]           = CpOpIndirectBuffer;
 	g_cp_op_func[Pm4::IT_COPY_DATA]                 = CpOpCopyData;
 	g_cp_op_func[Pm4::IT_EVENT_WRITE]               = CpOpEventWrite;
@@ -203,7 +224,6 @@ constexpr auto MakeOpcodeDispatchTable() {
 	g_cp_op_func[Pm4::IT_EVENT_WRITE_EOS]           = CpOpEventWriteEos;
 	g_cp_op_func[Pm4::IT_DMA_DATA]                  = CpOpDmaData;
 	g_cp_op_func[Pm4::IT_ACQUIRE_MEM]               = CpOpAcquireMem;
-	g_cp_op_func[Pm4::IT_REWIND]                    = CpOpRewind;
 	g_cp_op_func[Pm4::IT_SET_CONTEXT_REG]           = CpOpSetContextReg;
 	g_cp_op_func[Pm4::IT_SET_SH_REG]                = CpOpSetShaderReg;
 	g_cp_op_func[Pm4::IT_SET_UCONFIG_REG]           = CpOpSetUconfigReg;
@@ -218,7 +238,6 @@ constexpr auto MakeOpcodeDispatchTable() {
 	g_cp_op_func[Pm4::IT_WAIT_ON_CE_COUNTER]        = CpOpWaitOnCeCounter;
 	g_cp_op_func[Pm4::IT_WAIT_ON_DE_COUNTER_DIFF]   = CpOpWaitOnDeCounterDiff;
 	g_cp_op_func[Pm4::IT_GET_LOD_STATS]             = CpOpGetLodStats;
-	g_cp_op_func[Pm4::IT_WAIT_REG_MEM_64]           = CpOpWaitRegMem64;
 
 	return g_cp_op_func;
 }
@@ -227,13 +246,14 @@ constexpr auto MakeCustomOpcodeDispatchTable() {
 	std::array<cp_op_parser_func_t, Pm4::R_NUM> g_cp_op_custom_func {};
 
 	g_cp_op_custom_func[Pm4::R_DISPATCH_RESET] = CpOpDispatchReset;
+	g_cp_op_custom_func[Pm4::R_WAIT_MEM_32]    = CpOpWaitRegMem32;
 	g_cp_op_custom_func[Pm4::R_WAIT_FLIP_DONE] = CpOpWaitFlipDone;
 	g_cp_op_custom_func[Pm4::R_PUSH_MARKER]    = CpOpPushMarker;
 	g_cp_op_custom_func[Pm4::R_POP_MARKER]     = CpOpPopMarker;
 	g_cp_op_custom_func[Pm4::R_ACQUIRE_MEM]    = CpOpAcquireMem;
+	g_cp_op_custom_func[Pm4::R_WAIT_MEM_64]    = CpOpWaitRegMem64;
 	g_cp_op_custom_func[Pm4::R_FLIP]           = CpOpFlip;
 	g_cp_op_custom_func[Pm4::R_RELEASE_MEM]    = CpOpReleaseMem;
-	g_cp_op_custom_func[Pm4::R_CONTEXT_STATE]  = CpOpContextState;
 
 	return g_cp_op_custom_func;
 }

src/graphics/guest_gpu/command_processor/pm4Dispatch.h

@@ -44,9 +44,11 @@ uint32_t HwCtxSetBorderColorTableAddr(CommandProcessor&, uint32_t, uint32_t, con
 uint32_t HwCtxSetStencilClear(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetDepthClear(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetScreenScissor(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
+uint32_t HwCtxSetDepthRenderTarget(CommandProcessor&, uint32_t, uint32_t, const uint32_t*,
+                                   uint32_t);
 uint32_t HwCtxSetStencilInfo(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwCtxSetDepthShadingRateEncoding(CommandProcessor&, uint32_t, uint32_t,
-                                          const uint32_t*, uint32_t);
+uint32_t HwCtxSetDepthHtileSurface(CommandProcessor&, uint32_t, uint32_t, const uint32_t*,
+                                   uint32_t);
 uint32_t HwCtxSetHardwareScreenOffset(CommandProcessor&, uint32_t, uint32_t, const uint32_t*,
                                       uint32_t);
 uint32_t HwCtxSetWindowOffset(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
@@ -54,6 +56,7 @@ uint32_t HwCtxSetWindowScissor(CommandProcessor&, uint32_t, uint32_t, const uint
 uint32_t HwCtxSetClipRect(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetRenderTargetMask(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetGenericScissor(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
+uint32_t HwCtxSetBlendColor(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetCbDccControl(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetStencilControl(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetStencilMask(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
@@ -87,6 +90,8 @@ uint32_t HwCtxSetDrawPayloadControl(CommandProcessor&, uint32_t, uint32_t, const
 uint32_t HwCtxSetPrimitiveIdReset(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetObjprimIdControl(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetShaderStages(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
+uint32_t HwCtxSetGuardBands(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
+uint32_t HwCtxSetRenderTarget(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetColorInfo(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetBlendControl(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetViewportScissor(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
@@ -97,8 +102,10 @@ uint32_t HwShSetPsUserSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t
 uint32_t HwShSetGsUserSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwShSetHsUserSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwShSetCsUserSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwShIgnoreUserAccumulator(CommandProcessor&, uint32_t, uint32_t, const uint32_t*,
-                                   uint32_t);
+uint32_t HwShSetPsUserAccumSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
+uint32_t HwShSetGsUserAccumSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
+uint32_t HwShSetHsUserAccumSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
+uint32_t HwShSetCsUserAccumSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwShSetCsRegisters(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwShIgnoreRegisters(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwUcSetPrimitiveType(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
@@ -114,7 +121,6 @@ uint32_t HwUcSetGeIndexOffset(CommandProcessor&, uint32_t, uint32_t, const uint3
 uint32_t HwUcSetGdsOaRegisters(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 
 uint32_t CpOpNop(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
-uint32_t CpOpContextState(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpSetBase(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpClearState(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpIndexBase(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
@@ -126,7 +132,6 @@ uint32_t CpOpDrawIndirectMulti(CommandProcessor&, uint32_t, const uint32_t*, uin
 uint32_t CpOpDrawIndex(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpDrawIndexOffset(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpPfpSyncMe(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
-uint32_t CpOpRewind(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpIndexType(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpNumInstances(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpDrawIndexAuto(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);

src/graphics/guest_gpu/gpu_defs.h

@@ -3,8 +3,15 @@
 
 #include "common/common.h"
 
+#include <type_traits>
+
 namespace Libs::Graphics::Prospero {
 
+template <typename T>
+constexpr auto GpuEnumValue(T value) {
+	return static_cast<std::underlying_type_t<T>>(value);
+}
+
 enum class PrimitiveType : uint32_t {
 	kNone               = 0,
 	kPointList          = 1,
@@ -53,34 +60,24 @@ enum class GsOutputPrimitiveType : uint32_t {
 };
 
 enum class ChannelLayout : uint32_t {
-	kInvalid         = 0,
-	k8               = 1,
-	k16              = 2,
-	k8_8             = 3,
-	k32              = 4,
-	k16_16           = 5,
-	k11_11_10        = 6,
-	k10_11_11        = 7,
-	k2_10_10_10      = 8,
-	k10_10_10_2      = 9,
-	k8_8_8_8         = 10,
-	k32_32           = 11,
-	k16_16_16_16     = 12,
-	k32_32_32        = 13,
-	k32_32_32_32     = 14,
-	k5_6_5           = 16,
-	k5_5_5_1         = 17,
-	k1_5_5_5         = 18,
-	k4_4_4_4         = 19,
-	k10_10_10_2Float = 31,
-	k9_9_9_5         = 34,
-	kBc1             = 35,
-	kBc2             = 36,
-	kBc3             = 37,
-	kBc4             = 38,
-	kBc5             = 39,
-	kBc6             = 40,
-	kBc7             = 41,
+	kInvalid     = 0,
+	k8           = 1,
+	k16          = 2,
+	k8_8         = 3,
+	k32          = 4,
+	k16_16       = 5,
+	k11_11_10    = 6,
+	k10_10_10_2  = 9,
+	k8_8_8_8     = 10,
+	k32_32       = 11,
+	k16_16_16_16 = 12,
+	k32_32_32_32 = 14,
+	k5_6_5       = 16,
+	k5_5_5_1     = 17,
+	k4_4_4_4     = 19,
+	kBc1         = 35,
+	kBc2         = 36,
+	kBc3         = 37,
 };
 
 enum class ChannelType : uint32_t {
@@ -108,52 +105,32 @@ enum class ChannelOrder : uint32_t {
 	kAltReversed = 3,
 };
 
-// Selects the logical shader component written to each physical color-attachment component.
-// Two bits per component keep this cheap to carry in shader and pipeline keys.
+// Maps a shader's logical RGBA export to the host color-attachment components. Two bits per
+// component keep this cheap to carry in shader and pipeline keys.
 struct ColorComponentMapping {
-	static constexpr uint8_t kIdentity = 0xe4u;
-
-	uint8_t packed = kIdentity;
+	uint8_t packed = 0xe4u; // RGBA: 0, 1, 2, 3
 
 	[[nodiscard]] constexpr uint32_t Map(uint32_t component) const {
 		return component < 4u ? (packed >> (component * 2u)) & 0x3u : component;
 	}
 
-	[[nodiscard]] constexpr uint32_t ApplyMask(uint32_t logical_mask) const {
+	[[nodiscard]] constexpr uint32_t ApplyMask(uint32_t mask) const {
 		uint32_t mapped = 0;
-		for (uint32_t physical_component = 0; physical_component < 4u; physical_component++) {
-			mapped |= ((logical_mask >> Map(physical_component)) & 1u) << physical_component;
+		for (uint32_t component = 0; component < 4u; component++) {
+			mapped |= ((mask >> component) & 1u) << Map(component);
 		}
 		return mapped;
 	}
 
-	// This mapping selects an intermediate component; next selects the final logical component.
-	[[nodiscard]] constexpr ColorComponentMapping Then(ColorComponentMapping next) const {
-		ColorComponentMapping result {0u};
-		for (uint32_t physical_component = 0; physical_component < 4u; physical_component++) {
-			result.packed |= static_cast<uint8_t>(next.Map(Map(physical_component))
-			                                      << (physical_component * 2u));
-		}
-		return result;
-	}
-
-	[[nodiscard]] constexpr bool IsIdentity() const { return packed == kIdentity; }
+	[[nodiscard]] constexpr bool IsIdentity() const { return packed == 0xe4u; }
 
 	bool operator==(const ColorComponentMapping&) const = default;
 };
 
 static_assert(sizeof(ColorComponentMapping) == sizeof(uint8_t));
 
-inline constexpr ColorComponentMapping ColorMappingRgba {ColorComponentMapping::kIdentity};
-inline constexpr ColorComponentMapping ColorMappingGr {0xe1u};   // 1, 0, 2, 3
-inline constexpr ColorComponentMapping ColorMappingRabg {0x6cu}; // 0, 3, 2, 1
-inline constexpr ColorComponentMapping ColorMappingRgab {0xb4u}; // 0, 1, 3, 2
-inline constexpr ColorComponentMapping ColorMappingBgra {0xc6u}; // 2, 1, 0, 3
 inline constexpr ColorComponentMapping ColorMappingAbgr {0x1bu}; // 3, 2, 1, 0
-inline constexpr ColorComponentMapping ColorMappingAgba {0x27u}; // 3, 1, 2, 0
-inline constexpr ColorComponentMapping ColorMappingArbg {0x63u}; // 3, 0, 2, 1
-inline constexpr ColorComponentMapping ColorMappingAgbr {0x87u}; // 3, 1, 0, 2
-inline constexpr ColorComponentMapping ColorMappingArgb {0x93u}; // 3, 0, 1, 2
+inline constexpr ColorComponentMapping ColorMappingBgra {0xc6u}; // 2, 1, 0, 3
 
 enum class DepthFormat : uint32_t {
 	kInvalid = 0,
@@ -401,25 +378,11 @@ enum class BufferFormat : uint32_t {
 	k8Srgb              = 128,
 	k8_8Srgb            = 129,
 	k8_8_8_8Srgb        = 130,
-	k10_10_10_2Float    = 131,
 	k9_9_9_5Float       = 132,
 	k5_6_5UNorm         = 133,
 	k5_5_5_1UNorm       = 134,
-	k1_5_5_5UNorm       = 135,
 	k4_4_4_4UNorm       = 136,
-	kFmask8_S2_F1       = 156,
-	kFmask8_S4_F1       = 157,
-	kFmask8_S8_F1       = 158,
-	kFmask8_S2_F2       = 159,
-	kFmask8_S4_F2       = 160,
 	kFmask8_S4_F4       = 161,
-	kFmask16_S16_F1     = 162,
-	kFmask16_S8_F2      = 163,
-	kFmask32_S16_F2     = 164,
-	kFmask32_S8_F4      = 165,
-	kFmask32_S8_F8      = 166,
-	kFmask64_S16_F4     = 167,
-	kFmask64_S16_F8     = 168,
 	kBc1UNorm           = 169,
 	kBc1Srgb            = 170,
 	kBc2UNorm           = 171,

src/graphics/guest_gpu/gpu_format.cpp

@@ -3,235 +3,129 @@
 #include "graphics/guest_gpu/gpu_defs.h"
 
 #include <array>
-#include <bit>
 
 namespace Libs::Graphics::Prospero {
 namespace {
 
 struct FormatInfo {
-	BufferFormat       format;
-	uint32_t           bytes_per_element;
-	uint32_t           block_compressed_bytes_per_block;
-	uint32_t           render_target_bytes_per_element;
-	bool               sampled_texture;
-	bool               uint_texture;
-	bool               sint_texture = false;
+	uint32_t format;
+	uint32_t bytes_per_element;
+	uint32_t block_compressed_bytes_per_block;
+	uint32_t render_target_bytes_per_element;
+	bool     supported_sampled_texture_format;
+	bool     unsigned_integer_texture_format;
 };
 
 constexpr FormatInfo kFormatInfo[] = {
-	{BufferFormat::k8UNorm, 1, 0, 1, true, false},
-	{BufferFormat::k8SNorm, 0, 0, 1, false, false},
-	{BufferFormat::k8UInt, 1, 0, 1, true, true},
-	{BufferFormat::k16UNorm, 2, 0, 2, true, false},
-	{BufferFormat::k16SNorm, 2, 0, 2, true, false},
-	{BufferFormat::k16UInt, 2, 0, 2, true, true},
-	{BufferFormat::k16SInt, 2, 0, 2, true, false, true},
-	{BufferFormat::k16Float, 2, 0, 2, true, false},
-	{BufferFormat::k8_8UNorm, 2, 0, 2, true, false},
-	{BufferFormat::k8_8SNorm, 2, 0, 2, true, false},
-	{BufferFormat::k8_8UInt, 2, 0, 2, true, true},
-	{BufferFormat::k8_8SInt, 2, 0, 2, true, false, true},
-	{BufferFormat::k32UInt, 4, 0, 4, true, true},
-	{BufferFormat::k32SInt, 4, 0, 4, true, false, true},
-	{BufferFormat::k32Float, 4, 0, 4, true, false},
-	{BufferFormat::k16_16UNorm, 4, 0, 4, true, false},
-	{BufferFormat::k16_16SNorm, 4, 0, 4, true, false},
-	{BufferFormat::k16_16UInt, 4, 0, 4, true, true},
-	{BufferFormat::k16_16SInt, 4, 0, 4, true, false, true},
-	{BufferFormat::k16_16Float, 4, 0, 4, true, false},
-	{BufferFormat::k11_11_10UInt, 4, 0, 4, true, true},
-	{BufferFormat::k11_11_10Float, 4, 0, 4, true, false},
-	{BufferFormat::k10_10_10_2UNorm, 4, 0, 4, true, false},
-	{BufferFormat::k10_10_10_2UInt, 4, 0, 4, true, true},
-	{BufferFormat::k8_8_8_8UNorm, 4, 0, 4, true, false},
-	{BufferFormat::k8_8_8_8SNorm, 4, 0, 4, true, false},
-	{BufferFormat::k8_8_8_8UInt, 4, 0, 4, true, true},
-	{BufferFormat::k8_8_8_8SInt, 4, 0, 4, true, false, true},
-	{BufferFormat::k32_32UInt, 8, 0, 8, true, true},
-	{BufferFormat::k32_32SInt, 8, 0, 8, true, false, true},
-	{BufferFormat::k32_32Float, 8, 0, 8, true, false},
-	{BufferFormat::k16_16_16_16UNorm, 8, 0, 8, true, false},
-	{BufferFormat::k16_16_16_16SNorm, 8, 0, 8, true, false},
-	{BufferFormat::k16_16_16_16UInt, 8, 0, 8, true, true},
-	{BufferFormat::k16_16_16_16SInt, 8, 0, 8, true, false, true},
-	{BufferFormat::k16_16_16_16Float, 8, 0, 8, true, false},
-	{BufferFormat::k32_32_32UInt, 12, 0, 12, true, true},
-	{BufferFormat::k32_32_32SInt, 12, 0, 12, true, false, true},
-	{BufferFormat::k32_32_32Float, 12, 0, 12, true, false},
-	{BufferFormat::k32_32_32_32UInt, 16, 0, 16, true, true},
-	{BufferFormat::k32_32_32_32SInt, 16, 0, 16, true, false, true},
-	{BufferFormat::k32_32_32_32Float, 16, 0, 16, true, false},
-	{BufferFormat::k8Srgb, 1, 0, 0, true, false},
-	{BufferFormat::k8_8Srgb, 2, 0, 0, true, false},
-	{BufferFormat::k8_8_8_8Srgb, 4, 0, 4, true, false},
-	{BufferFormat::k9_9_9_5Float, 4, 0, 0, true, false},
-	{BufferFormat::k5_6_5UNorm, 2, 0, 2, true, false},
-	{BufferFormat::k5_5_5_1UNorm, 2, 0, 2, true, false},
-	{BufferFormat::k1_5_5_5UNorm, 0, 0, 2, false, false},
-	{BufferFormat::k4_4_4_4UNorm, 2, 0, 2, true, false},
-	{BufferFormat::kFmask8_S2_F1, 1, 0, 1, true, false},
-	{BufferFormat::kFmask8_S4_F1, 1, 0, 1, true, false},
-	{BufferFormat::kFmask8_S8_F1, 1, 0, 1, true, false},
-	{BufferFormat::kFmask8_S2_F2, 1, 0, 1, true, false},
-	{BufferFormat::kFmask8_S4_F2, 1, 0, 1, true, false},
-	{BufferFormat::kFmask8_S4_F4, 1, 0, 1, true, false},
-	{BufferFormat::kFmask16_S16_F1, 2, 0, 2, true, false},
-	{BufferFormat::kFmask16_S8_F2, 2, 0, 2, true, false},
-	{BufferFormat::kFmask32_S16_F2, 4, 0, 4, true, false},
-	{BufferFormat::kFmask32_S8_F4, 4, 0, 4, true, false},
-	{BufferFormat::kFmask32_S8_F8, 4, 0, 4, true, false},
-	{BufferFormat::kFmask64_S16_F4, 8, 0, 8, true, false},
-	{BufferFormat::kFmask64_S16_F8, 8, 0, 8, true, false},
-	{BufferFormat::kBc1UNorm, 0, 8, 0, true, false},
-	{BufferFormat::kBc1Srgb, 0, 8, 0, true, false},
-	{BufferFormat::kBc2UNorm, 0, 16, 0, true, false},
-	{BufferFormat::kBc2Srgb, 0, 16, 0, true, false},
-	{BufferFormat::kBc3UNorm, 0, 16, 0, true, false},
-	{BufferFormat::kBc3Srgb, 0, 16, 0, true, false},
-	{BufferFormat::kBc4UNorm, 0, 8, 0, true, false},
-	{BufferFormat::kBc4SNorm, 0, 8, 0, true, false},
-	{BufferFormat::kBc5UNorm, 0, 16, 0, true, false},
-	{BufferFormat::kBc5SNorm, 0, 16, 0, true, false},
-	{BufferFormat::kBc6UFloat, 0, 16, 0, true, false},
-	{BufferFormat::kBc6SFloat, 0, 16, 0, true, false},
-	{BufferFormat::kBc7UNorm, 0, 16, 0, true, false},
-	{BufferFormat::kBc7Srgb, 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::k8UNorm), 1, 0, 1, true, false},
+    {GpuEnumValue(BufferFormat::k8SNorm), 0, 0, 1, false, false},
+    {GpuEnumValue(BufferFormat::k8UInt), 1, 0, 1, true, true},
+    {GpuEnumValue(BufferFormat::k16UNorm), 2, 0, 2, true, false},
+    {GpuEnumValue(BufferFormat::k16SNorm), 2, 0, 2, true, false},
+    {GpuEnumValue(BufferFormat::k16UInt), 2, 0, 2, true, true},
+    {GpuEnumValue(BufferFormat::k16SInt), 2, 0, 2, false, false},
+    {GpuEnumValue(BufferFormat::k16Float), 2, 0, 2, true, false},
+    {GpuEnumValue(BufferFormat::k8_8UNorm), 2, 0, 2, true, false},
+    {GpuEnumValue(BufferFormat::k8_8SNorm), 2, 0, 2, true, false},
+    {GpuEnumValue(BufferFormat::k8_8UInt), 2, 0, 2, true, true},
+    {GpuEnumValue(BufferFormat::k8_8SInt), 2, 0, 2, false, false},
+    {GpuEnumValue(BufferFormat::k32UInt), 4, 0, 4, true, true},
+    {GpuEnumValue(BufferFormat::k32SInt), 4, 0, 4, false, false},
+    {GpuEnumValue(BufferFormat::k32Float), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k16_16UNorm), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k16_16SNorm), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k16_16UInt), 4, 0, 4, true, true},
+    {GpuEnumValue(BufferFormat::k16_16SInt), 4, 0, 4, false, false},
+    {GpuEnumValue(BufferFormat::k16_16Float), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k11_11_10Float), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k10_10_10_2UNorm), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k10_10_10_2UInt), 4, 0, 4, true, true},
+    {GpuEnumValue(BufferFormat::k8_8_8_8UNorm), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k8_8_8_8SNorm), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k8_8_8_8UInt), 4, 0, 4, true, true},
+    {GpuEnumValue(BufferFormat::k8_8_8_8SInt), 4, 0, 4, false, false},
+    {GpuEnumValue(BufferFormat::k32_32UInt), 8, 0, 8, true, true},
+    {GpuEnumValue(BufferFormat::k32_32SInt), 8, 0, 8, false, false},
+    {GpuEnumValue(BufferFormat::k32_32Float), 8, 0, 8, true, false},
+    {GpuEnumValue(BufferFormat::k16_16_16_16UNorm), 8, 0, 8, true, false},
+    {GpuEnumValue(BufferFormat::k16_16_16_16SNorm), 8, 0, 8, true, false},
+    {GpuEnumValue(BufferFormat::k16_16_16_16UInt), 8, 0, 8, true, true},
+    {GpuEnumValue(BufferFormat::k16_16_16_16SInt), 8, 0, 8, false, false},
+    {GpuEnumValue(BufferFormat::k16_16_16_16Float), 8, 0, 8, true, false},
+    {GpuEnumValue(BufferFormat::k32_32_32UInt), 12, 0, 12, true, true},
+    {GpuEnumValue(BufferFormat::k32_32_32SInt), 12, 0, 12, false, false},
+    {GpuEnumValue(BufferFormat::k32_32_32Float), 12, 0, 12, true, false},
+    {GpuEnumValue(BufferFormat::k32_32_32_32UInt), 16, 0, 16, true, true},
+    {GpuEnumValue(BufferFormat::k32_32_32_32SInt), 16, 0, 16, false, false},
+    {GpuEnumValue(BufferFormat::k32_32_32_32Float), 16, 0, 16, true, false},
+    {GpuEnumValue(BufferFormat::k8Srgb), 1, 0, 0, true, false},
+    {GpuEnumValue(BufferFormat::k8_8Srgb), 2, 0, 0, true, false},
+    {GpuEnumValue(BufferFormat::k8_8_8_8Srgb), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k9_9_9_5Float), 4, 0, 0, true, false},
+    {GpuEnumValue(BufferFormat::k5_6_5UNorm), 2, 0, 2, true, false},
+    {GpuEnumValue(BufferFormat::k5_5_5_1UNorm), 2, 0, 2, true, false},
+    {GpuEnumValue(BufferFormat::k4_4_4_4UNorm), 2, 0, 2, true, false},
+    {GpuEnumValue(BufferFormat::kFmask8_S4_F4), 1, 0, 1, true, false},
+    {GpuEnumValue(BufferFormat::kBc1UNorm), 0, 8, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc1Srgb), 0, 8, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc2UNorm), 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc2Srgb), 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc3UNorm), 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc3Srgb), 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc4UNorm), 0, 8, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc4SNorm), 0, 8, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc5UNorm), 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc5SNorm), 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc6UFloat), 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc6SFloat), 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc7UNorm), 0, 16, 0, true, false},
+    {GpuEnumValue(BufferFormat::kBc7Srgb), 0, 16, 0, true, false},
 };
 
-constexpr uint8_t RenderTargetTypeBit(ChannelType type) {
-	return static_cast<uint8_t>(1u << static_cast<uint32_t>(type));
-}
-
-constexpr auto kUNormType = RenderTargetTypeBit(ChannelType::kUNorm);
-constexpr auto kIntegerTypes =
-    RenderTargetTypeBit(ChannelType::kUInt) | RenderTargetTypeBit(ChannelType::kSInt);
-constexpr auto kNormalizedIntegerTypes =
-    kUNormType | RenderTargetTypeBit(ChannelType::kSNorm) | kIntegerTypes;
-
-struct RenderTargetLayoutInfo {
-	ChannelLayout       layout;
-	BufferFormat        first_linear_format;
-	uint8_t             linear_type_mask;
-	uint8_t             components;
-	BufferFormat        extra_format  = BufferFormat::kInvalid;
-	ChannelType         extra_type    = ChannelType::kUNorm;
-	ChannelOrderSupport order_support = ChannelOrderSupport::kAll;
-};
-
-constexpr RenderTargetLayoutInfo kRenderTargetLayouts[] = {
-    {ChannelLayout::k8, BufferFormat::k8UNorm, kNormalizedIntegerTypes, 1, BufferFormat::k8Srgb,
-     ChannelType::kSrgb},
-    {ChannelLayout::k16, BufferFormat::k16UNorm, kNormalizedIntegerTypes, 1, BufferFormat::k16Float,
-     ChannelType::kFloat},
-    {ChannelLayout::k8_8, BufferFormat::k8_8UNorm, kNormalizedIntegerTypes, 2,
-     BufferFormat::k8_8Srgb, ChannelType::kSrgb},
-    {ChannelLayout::k32, BufferFormat::k32UInt, kIntegerTypes, 1, BufferFormat::k32Float,
-     ChannelType::kFloat},
-    {ChannelLayout::k16_16, BufferFormat::k16_16UNorm, kNormalizedIntegerTypes, 2,
-     BufferFormat::k16_16Float, ChannelType::kFloat},
-    {ChannelLayout::k11_11_10, BufferFormat::k11_11_10UNorm, kNormalizedIntegerTypes, 3,
-     BufferFormat::k11_11_10Float, ChannelType::kFloat},
-    {ChannelLayout::k10_11_11, BufferFormat::k10_11_11UNorm, kNormalizedIntegerTypes, 3,
-     BufferFormat::k10_11_11Float, ChannelType::kFloat},
-    {ChannelLayout::k2_10_10_10, BufferFormat::k2_10_10_10UNorm, kNormalizedIntegerTypes, 4},
-    {ChannelLayout::k10_10_10_2, BufferFormat::k10_10_10_2UNorm, kNormalizedIntegerTypes, 4},
-    {ChannelLayout::k8_8_8_8, BufferFormat::k8_8_8_8UNorm, kNormalizedIntegerTypes, 4,
-     BufferFormat::k8_8_8_8Srgb, ChannelType::kSrgb},
-    {ChannelLayout::k32_32, BufferFormat::k32_32UInt, kIntegerTypes, 2, BufferFormat::k32_32Float,
-     ChannelType::kFloat},
-    {ChannelLayout::k16_16_16_16, BufferFormat::k16_16_16_16UNorm, kNormalizedIntegerTypes, 4,
-     BufferFormat::k16_16_16_16Float, ChannelType::kFloat},
-    {ChannelLayout::k32_32_32_32, BufferFormat::k32_32_32_32UInt, kIntegerTypes, 4,
-     BufferFormat::k32_32_32_32Float, ChannelType::kFloat},
-    {ChannelLayout::k5_6_5, BufferFormat::k5_6_5UNorm, kUNormType, 3},
-    {ChannelLayout::k5_5_5_1, BufferFormat::k5_5_5_1UNorm, kUNormType, 4},
-    {ChannelLayout::k1_5_5_5, BufferFormat::k1_5_5_5UNorm, kUNormType, 4},
-    {ChannelLayout::k4_4_4_4, BufferFormat::k4_4_4_4UNorm, kUNormType, 4},
-    {ChannelLayout::k10_10_10_2Float, BufferFormat::kInvalid, 0, 4, BufferFormat::k10_10_10_2Float,
-     ChannelType::kFloat, ChannelOrderSupport::kStandardOnly},
-};
-
-const RenderTargetLayoutInfo* FindRenderTargetLayout(ChannelLayout layout) {
-	for (const auto& info: kRenderTargetLayouts) {
-		if (info.layout == layout) {
-			return &info;
-		}
-	}
-	return nullptr;
-}
-
 constexpr auto MakeFormatInfoLookup() {
-	constexpr size_t kMaxFormat = static_cast<size_t>(BufferFormat::kBc7Srgb);
+	constexpr uint32_t                            kMaxFormat = GpuEnumValue(BufferFormat::kBc7Srgb);
 	std::array<const FormatInfo*, kMaxFormat + 1> lookup {};
 	for (const auto& info: kFormatInfo) {
-		lookup[static_cast<size_t>(info.format)] = &info;
+		lookup[info.format] = &info;
 	}
 	return lookup;
 }
 
 constexpr auto kFormatInfoLookup = MakeFormatInfoLookup();
 
-const FormatInfo* FindFormatInfo(BufferFormat format) {
-	const auto index = static_cast<size_t>(format);
-	return index < kFormatInfoLookup.size() ? kFormatInfoLookup[index] : nullptr;
+const FormatInfo* FindFormatInfo(uint32_t format) {
+	return format < kFormatInfoLookup.size() ? kFormatInfoLookup[format] : nullptr;
 }
 
 } // namespace
 
-RenderTargetFormatEncoding ResolveRenderTargetFormat(ChannelLayout layout, ChannelType type) {
-	const auto* layout_info = FindRenderTargetLayout(layout);
-	const auto  raw_type    = static_cast<uint32_t>(type);
-	if (layout_info == nullptr || raw_type >= 8u) {
-		return {};
-	}
-
-	auto format = BufferFormat::kInvalid;
-	if (layout_info->extra_format != BufferFormat::kInvalid && type == layout_info->extra_type) {
-		format = layout_info->extra_format;
-	} else if ((layout_info->linear_type_mask & (1u << raw_type)) != 0) {
-		const auto first_type =
-		    std::countr_zero(static_cast<uint32_t>(layout_info->linear_type_mask));
-		format = static_cast<BufferFormat>(static_cast<uint32_t>(layout_info->first_linear_format) +
-		                                   raw_type - first_type);
-	}
-	if (format == BufferFormat::kInvalid) {
-		return {};
-	}
-	return {format, layout_info->components, layout_info->order_support};
-}
-
-uint32_t NumBytesPerElement(BufferFormat format) {
+uint32_t NumBytesPerElement(uint32_t format) {
 	const auto* info = FindFormatInfo(format);
 	return info != nullptr ? info->bytes_per_element : 0;
 }
 
-uint32_t BlockCompressedBytesPerBlock(BufferFormat format) {
+uint32_t BlockCompressedBytesPerBlock(uint32_t format) {
 	const auto* info = FindFormatInfo(format);
 	return info != nullptr ? info->block_compressed_bytes_per_block : 0;
 }
 
-uint32_t RenderTargetBytesPerElement(BufferFormat format) {
+uint32_t RenderTargetBytesPerElement(uint32_t format) {
 	const auto* info = FindFormatInfo(format);
 	return info != nullptr ? info->render_target_bytes_per_element : 0;
 }
 
-bool IsFmaskTextureFormat(BufferFormat format) {
-	return format >= BufferFormat::kFmask8_S2_F1 && format <= BufferFormat::kFmask64_S16_F8;
-}
-
-TextureNumericClass SampledTextureNumericClass(BufferFormat format) {
+bool IsSupportedTextureFormat(uint32_t format) {
 	const auto* info = FindFormatInfo(format);
-	if (info == nullptr || !info->sampled_texture) {
-		return TextureNumericClass::Unsupported;
-	}
-	if (info->sint_texture) {
-		return TextureNumericClass::Sint;
-	}
-	return info->uint_texture ? TextureNumericClass::Uint : TextureNumericClass::Float;
+	return info != nullptr && info->supported_sampled_texture_format;
 }
 
-BufferFormat RemapTextureFormat(BufferFormat format) {
-	return format == BufferFormat::k11_11_10UInt ? BufferFormat::k32UInt : format;
+bool IsUintTextureFormat(uint32_t format) {
+	const auto* info = FindFormatInfo(format);
+	return info != nullptr && info->unsigned_integer_texture_format;
+}
+
+bool IsFmaskTextureFormat(uint32_t format) {
+	return format == GpuEnumValue(BufferFormat::kFmask8_S4_F4);
 }
 
 } // namespace Libs::Graphics::Prospero

src/graphics/guest_gpu/gpu_format.h

@@ -1,51 +1,16 @@
 #ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_GUEST_GPU_GPU_FORMAT_H_
 #define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_GUEST_GPU_GPU_FORMAT_H_
 
-#include "graphics/guest_gpu/gpu_defs.h"
+#include "common/common.h"
 
 namespace Libs::Graphics::Prospero {
 
-enum class ChannelOrderSupport : uint8_t {
-	kNone,
-	kStandardOnly,
-	kAll,
-};
-
-struct RenderTargetFormatEncoding {
-	BufferFormat        buffer_format = BufferFormat::kInvalid;
-	uint8_t             components    = 0;
-	ChannelOrderSupport order_support = ChannelOrderSupport::kNone;
-
-	[[nodiscard]] constexpr bool IsValid() const {
-		return buffer_format != BufferFormat::kInvalid && components >= 1u && components <= 4u &&
-		       order_support != ChannelOrderSupport::kNone;
-	}
-
-	[[nodiscard]] constexpr bool SupportsOrder(ChannelOrder order) const {
-		switch (order_support) {
-			case ChannelOrderSupport::kStandardOnly: return order == ChannelOrder::kStandard;
-			case ChannelOrderSupport::kAll:
-				switch (order) {
-					case ChannelOrder::kStandard:
-					case ChannelOrder::kAlt:
-					case ChannelOrder::kReversed:
-					case ChannelOrder::kAltReversed: return true;
-				}
-				return false;
-			default: return false;
-		}
-	}
-};
-
-enum class TextureNumericClass { Unsupported, Float, Uint, Sint };
-
-RenderTargetFormatEncoding ResolveRenderTargetFormat(ChannelLayout layout, ChannelType type);
-uint32_t                   NumBytesPerElement(BufferFormat format);
-uint32_t                   BlockCompressedBytesPerBlock(BufferFormat format);
-uint32_t                   RenderTargetBytesPerElement(BufferFormat format);
-bool                       IsFmaskTextureFormat(BufferFormat format);
-TextureNumericClass        SampledTextureNumericClass(BufferFormat format);
-BufferFormat               RemapTextureFormat(BufferFormat format);
+uint32_t NumBytesPerElement(uint32_t format);
+uint32_t BlockCompressedBytesPerBlock(uint32_t format);
+uint32_t RenderTargetBytesPerElement(uint32_t format);
+bool     IsSupportedTextureFormat(uint32_t format);
+bool     IsUintTextureFormat(uint32_t format);
+bool     IsFmaskTextureFormat(uint32_t format);
 
 } // namespace Libs::Graphics::Prospero
 

src/graphics/guest_gpu/graphicsRun.h

@@ -3,100 +3,58 @@
 
 #include "common/abi.h"
 #include "common/common.h"
-#include "common/threads.h"
 #include "common/uniqueFunction.h"
-#include "graphics/guest_gpu/command_processor/commandProcessor.h"
 
-#include <array>
-#include <atomic>
-#include <cstdint>
-#include <deque>
 #include <memory>
-#include <mutex>
-#include <span>
-#include <thread>
 
 namespace Libs::Graphics {
 
+class CommandProcessor;
+class GpuState;
 class RenderContext;
 
-class GuestGpu final {
+class Gpu final {
 public:
-	explicit GuestGpu(RenderContext& renderer);
-	~GuestGpu();
-	KYTY_CLASS_NO_COPY(GuestGpu);
+	explicit Gpu(RenderContext& renderer);
+	~Gpu();
+	KYTY_CLASS_NO_COPY(Gpu);
 
 	void               Shutdown();
 	[[nodiscard]] bool IsStopping();
 	void               SendCommand(Common::UniqueFunction<void>&& command);
 	void               SendCommandSync(Common::UniqueFunction<void>&& command);
+	void SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command);
 
-	// Submitted command memory is borrowed and must remain valid until GPU execution completes.
-	void              Submit(std::span<const uint32_t> draw_commands,
-	                         std::span<const uint32_t> constant_commands);
-	void              SubmitCompute(uint32_t queue, std::span<const uint32_t> commands);
-	void              SubmitFlipPreparation(uint64_t request_id);
-	void              Done();
+	void Submit(uint32_t* draw_commands, uint32_t draw_size_dw, uint32_t* constant_commands,
+	            uint32_t constant_size_dw, bool trigger_agc_interrupt_on_done = false);
+	void SubmitCompute(uint32_t queue, uint32_t* commands, uint32_t size_dw,
+	                   bool trigger_agc_interrupt_on_done = false);
+	void SubmitFlipPreparation(uint64_t request_id);
+	void Done();
 	[[nodiscard]] int GetFrameNum() const;
 
-	[[nodiscard]] static bool IsGpuThread() noexcept;
+	[[nodiscard]] static bool              IsCommandProcessorThread() noexcept;
+	[[nodiscard]] static CommandProcessor* CurrentCommandProcessor() noexcept;
+	[[nodiscard]] static bool              SubmissionLockHeld() noexcept;
+	[[nodiscard]] static bool              MutexHeld() noexcept;
 
-private:
-	static constexpr uint32_t ComputePipeCount     = 7;
-	static constexpr uint32_t QueuesPerComputePipe = 8;
-	static constexpr uint32_t ComputeQueueCount    = ComputePipeCount * QueuesPerComputePipe;
-	static constexpr uint32_t ComputeQueueBase     = 0x20;
-	static constexpr uint32_t QueueCount           = 1 + ComputeQueueCount;
+	class SubmissionLock final {
+	public:
+		explicit SubmissionLock(Gpu& gpu);
+		~SubmissionLock();
+		KYTY_CLASS_NO_COPY(SubmissionLock);
 
-	enum class SubmissionType { Graphics, Compute, FlipPreparation };
-
-	struct Submission {
-		SubmissionType            type     = SubmissionType::Graphics;
-		uint32_t                  queue_id = 0;
-		std::span<const uint32_t> commands;
-		std::span<const uint32_t> constant_commands;
-		Pm4Execution              command_execution;
-		Pm4Execution              constant_execution;
-		bool                      reset_processor   = false;
-		bool                      started           = false;
-		bool                      command_complete  = false;
-		bool                      constant_complete = false;
-		bool                      blocked           = false;
-		uint64_t                  flip_request_id   = 0;
+	private:
+		Gpu& m_gpu;
 	};
 
-	void              Enqueue(Submission submission);
-	void              WaitForIdle();
-	void              ProcessCommands();
-	bool              Process(Submission& submission);
-	static void       ThreadRun(void* data);
-	CommandProcessor& GetProcessor(uint32_t queue_id);
+private:
+	friend class SubmissionLock;
 
-	RenderContext&                                 m_renderer;
-	Common::Mutex                                  m_submission_mutex;
-	Common::Mutex                                  m_queue_mutex;
-	std::mutex                                     m_shutdown_mutex;
-	Common::CondVar                                m_work_available;
-	Common::CondVar                                m_idle;
-	std::array<std::deque<Submission>, QueueCount> m_queues;
-	std::deque<Common::UniqueFunction<void>>       m_commands;
-	std::atomic_uint32_t                           m_pending_commands {0};
-	uint32_t                                       m_next_queue        = 0;
-	uint32_t                                       m_submission_count  = 0;
-	bool                                           m_processing        = false;
-	bool                                           m_graphics_done     = true;
-	bool                                           m_accepting         = true;
-	bool                                           m_stopping          = false;
-	bool                                           m_shutdown_complete = false;
+	void PauseSubmissions();
+	void ResumeSubmissions();
 
-	std::unique_ptr<CommandProcessor>                                m_gfx_cp;
-	std::array<std::unique_ptr<CommandProcessor>, ComputeQueueCount> m_compute_cp;
-
-	uint64_t        m_submit_id = 0;
-	std::atomic_int m_done_num  = 0;
-	std::jthread    m_thread;
-
-	friend class CommandProcessor;
+	std::unique_ptr<GpuState> m_state;
 };
 } // namespace Libs::Graphics
 

src/graphics/guest_gpu/hardwareContext.h

@@ -11,6 +11,15 @@ struct ColorBase {
 	uint64_t addr = 0;
 };
 
+struct ColorPitch {
+	uint32_t pitch_div8_minus1       = 0;
+	uint32_t fmask_pitch_div8_minus1 = 0;
+};
+
+struct ColorSlice {
+	uint32_t slice_div64_minus1 = 0;
+};
+
 struct ColorView {
 	uint32_t base_array_slice_index = 0;
 	uint32_t last_array_slice_index = 0;
@@ -20,20 +29,25 @@ struct ColorView {
 struct ColorInfo {
 	bool fmask_compression_enable = false;
 	// uint32_t fmask_compression_mode   = 0;
-	bool                    fmask_data_compression_disable = false;
-	bool                    fmask_one_frag_mode            = false;
-	bool                    cmask_fast_clear_enable        = false;
-	bool                    dcc_compression_enable         = false;
-	bool                    blend_clamp                    = false;
-	bool                    blend_bypass                   = false;
-	bool                    round_mode                     = false;
-	Prospero::ChannelLayout format                         = Prospero::ChannelLayout::kInvalid;
-	Prospero::ChannelType   channel_type                   = Prospero::ChannelType::kUNorm;
-	Prospero::ChannelOrder  channel_order                  = Prospero::ChannelOrder::kStandard;
+	bool     fmask_data_compression_disable = false;
+	bool     fmask_one_frag_mode            = false;
+	bool     cmask_fast_clear_enable        = false;
+	bool     dcc_compression_enable         = false;
+	bool     blend_clamp                    = false;
+	bool     blend_bypass                   = false;
+	bool     round_mode                     = false;
+	uint32_t cmask_is_linear                = 0;
+	uint32_t cmask_addr_type                = 0;
+	bool     alt_tile_mode                  = false;
+	uint32_t format                         = 0;
+	uint32_t channel_type                   = 0;
+	uint32_t channel_order                  = 0;
 };
 
 struct ColorAttrib {
 	bool     force_dest_alpha_to_one = false;
+	uint32_t tile_mode               = 0;
+	uint32_t fmask_tile_mode         = 0;
 	uint32_t num_samples             = 0;
 	uint32_t num_fragments           = 0;
 };
@@ -45,33 +59,41 @@ struct ColorAttrib2 {
 };
 
 struct ColorAttrib3 {
-	uint32_t           depth                        = 0;
-	Prospero::TileMode tile_mode                    = Prospero::TileMode::kRenderTarget;
-	uint32_t           dimension                    = 0;
-	bool               metadata_pipe_aligned        = false;
-	bool               write_vrs_rate_hint_to_cmask = false;
+	uint32_t depth              = 0;
+	uint32_t tile_mode          = 0;
+	uint32_t dimension          = 0;
+	bool     cmask_pipe_aligned = false;
+	bool     dcc_pipe_aligned   = false;
 };
 
 struct ColorDccControl {
-	enum class IndependentBlockSize : uint8_t { Disabled, Bytes64, Bytes128 };
-
-	uint32_t             max_uncompressed_block_size    = 2;
-	uint32_t             max_compressed_block_size      = 2;
-	uint32_t             color_transform                = 0;
-	bool                 dcc_clear_key_enable           = false;
-	bool                 overwrite_combiner_disable     = false;
-	IndependentBlockSize independent_block_size         = IndependentBlockSize::Disabled;
-	bool                 data_write_on_dcc_clear_to_reg = false;
+	uint32_t max_uncompressed_block_size    = 0;
+	uint32_t max_compressed_block_size      = 0;
+	uint32_t min_compressed_block_size      = 0;
+	uint32_t color_transform                = 0;
+	bool     dcc_clear_key_enable           = false;
+	bool     overwrite_combiner_disable     = false;
+	bool     independent_64b_blocks         = false;
+	bool     independent_128b_blocks        = false;
+	bool     data_write_on_dcc_clear_to_reg = false;
 };
 
 struct ColorCmask {
 	uint64_t addr = 0;
 };
 
+struct ColorCmaskSlice {
+	uint32_t slice_minus1 = 0;
+};
+
 struct ColorFmask {
 	uint64_t addr = 0;
 };
 
+struct ColorFmaskSlice {
+	uint32_t slice_minus1 = 0;
+};
+
 struct ColorClearWord0 {
 	uint32_t word0 = 0;
 };
@@ -84,8 +106,15 @@ struct ColorDccAddr {
 	uint64_t addr = 0;
 };
 
+struct ColorSize {
+	uint32_t width  = 0;
+	uint32_t height = 0;
+};
+
 struct RenderTarget {
 	ColorBase       base;
+	ColorPitch      pitch;
+	ColorSlice      slice;
 	ColorView       view;
 	ColorInfo       info;
 	ColorAttrib     attrib;
@@ -93,18 +122,21 @@ struct RenderTarget {
 	ColorAttrib3    attrib3;
 	ColorDccControl dcc;
 	ColorCmask      cmask;
+	ColorCmaskSlice cmask_slice;
 	ColorFmask      fmask;
+	ColorFmaskSlice fmask_slice;
 	ColorClearWord0 clear_word0;
 	ColorClearWord1 clear_word1;
 	ColorDccAddr    dcc_addr;
+	ColorSize       size;
 };
 
 struct DepthZInfo {
-	Prospero::DepthFormat                       format      = Prospero::DepthFormat::kInvalid;
+	uint32_t                                    format      = 0;
 	uint32_t                                    num_samples = 0;
 	Prospero::TextureCompatiblePlaneCompression texture_compatibility =
 	    Prospero::TextureCompatiblePlaneCompression::kDisable;
-	Prospero::ZCompareBase z_compare_base     = Prospero::ZCompareBase::kZMax;
+	Prospero::ZCompareBase z_compare_base     = Prospero::ZCompareBase::kZMin;
 	bool                   htile_acceleration = false;
 	bool                   expclear_enabled   = false;
 	bool                   partially_resident = false;
@@ -112,16 +144,16 @@ struct DepthZInfo {
 
 	[[nodiscard]] static DepthZInfo Decode(uint32_t value) {
 		DepthZInfo info;
-		info.format                = static_cast<Prospero::DepthFormat>(value & 0x3u);
+		info.format                = value & 0x3u;
 		info.num_samples           = (value >> 2u) & 0x3u;
 		info.texture_compatibility = static_cast<Prospero::TextureCompatiblePlaneCompression>(
-		    value & static_cast<uint32_t>(Prospero::TextureCompatiblePlaneCompression::kBitMask));
+		    value & Prospero::GpuEnumValue(Prospero::TextureCompatiblePlaneCompression::kBitMask));
 		info.partially_resident = (value & 0x00001000u) != 0;
 		info.max_mip_level      = static_cast<uint8_t>((value >> 16u) & 0x0fu);
 		info.expclear_enabled   = (value & 0x08000000u) != 0;
 		info.htile_acceleration = (value & 0x20000000u) != 0;
 		info.z_compare_base     = static_cast<Prospero::ZCompareBase>(
-		    value & static_cast<uint32_t>(Prospero::ZCompareBase::kBitMask));
+		    value & Prospero::GpuEnumValue(Prospero::ZCompareBase::kBitMask));
 		return info;
 	}
 
@@ -135,18 +167,18 @@ struct DepthZInfo {
 };
 
 struct DepthStencilInfo {
-	Prospero::StencilFormat            format = Prospero::StencilFormat::kInvalid;
+	uint32_t                           format = 0;
 	Prospero::TextureCompatibleStencil texture_compatibility =
 	    Prospero::TextureCompatibleStencil::kDisable;
 	bool expclear_enabled       = false;
-	bool htile_stencil_disabled = true;
+	bool htile_stencil_disabled = false;
 	bool partially_resident     = false;
 
 	[[nodiscard]] static DepthStencilInfo Decode(uint32_t value) {
 		DepthStencilInfo info;
-		info.format                = static_cast<Prospero::StencilFormat>(value & 0x1u);
+		info.format                = value & 0x1u;
 		info.texture_compatibility = static_cast<Prospero::TextureCompatibleStencil>(
-		    value & static_cast<uint32_t>(Prospero::TextureCompatibleStencil::kBitMask));
+		    value & Prospero::GpuEnumValue(Prospero::TextureCompatibleStencil::kBitMask));
 		info.partially_resident     = (value & 0x00001000u) != 0;
 		info.expclear_enabled       = (value & 0x08000000u) != 0;
 		info.htile_stencil_disabled = (value & 0x20000000u) != 0;
@@ -162,6 +194,16 @@ struct DepthStencilInfo {
 	}
 };
 
+struct DepthRenderTargetDepthInfo {
+	uint32_t addr5_swizzle_mask = 0;
+	uint32_t array_mode         = 0;
+	uint32_t pipe_config        = 0;
+	uint32_t bank_width         = 0;
+	uint32_t bank_height        = 0;
+	uint32_t macro_tile_aspect  = 0;
+	uint32_t num_banks          = 0;
+};
+
 struct DepthDepthView {
 	uint32_t slice_start           = 0;
 	uint32_t slice_max             = 0;
@@ -176,18 +218,36 @@ struct DepthDepthSizeXY {
 	bool     valid = false;
 };
 
+struct DepthRenderTargetHTileSurface {
+	uint32_t linear                  = 0;
+	uint32_t full_cache              = 0;
+	uint32_t htile_uses_preload_win  = 0;
+	uint32_t preload                 = 0;
+	uint32_t prefetch_width          = 0;
+	uint32_t prefetch_height         = 0;
+	uint32_t dst_outside_zero_to_one = 0;
+};
+
 struct DepthRenderTarget {
-	DepthZInfo       z_info;
-	DepthStencilInfo stencil_info;
-	DepthDepthView   depth_view;
-	DepthDepthSizeXY size;
+	DepthZInfo                    z_info;
+	DepthStencilInfo              stencil_info;
+	DepthDepthView                depth_view;
+	DepthDepthSizeXY              size;
+	DepthRenderTargetDepthInfo    depth_info;
+	DepthRenderTargetHTileSurface htile_surface;
 
 	uint64_t z_read_base_addr        = 0;
 	uint64_t stencil_read_base_addr  = 0;
 	uint64_t z_write_base_addr       = 0;
 	uint64_t stencil_write_base_addr = 0;
+	uint32_t pitch_div8_minus1       = 0;
+	uint32_t height_div8_minus1      = 0;
+	bool     pitch_height_valid      = false;
+	uint32_t slice_div64_minus1      = 0;
 	uint64_t htile_data_base_addr    = 0;
-	uint8_t  shading_rate_encoding   = 0;
+	uint32_t width                   = 0;
+	uint32_t height                  = 0;
+	bool     width_height_valid      = false;
 };
 
 struct RenderControl {
@@ -196,8 +256,6 @@ struct RenderControl {
 	bool    resummarize_enable       = false;
 	bool    stencil_compress_disable = false;
 	bool    depth_compress_disable   = false;
-	bool    copy_depth_to_color      = false;
-	bool    copy_stencil_to_color    = false;
 	bool    copy_centroid            = false;
 	uint8_t copy_sample              = 0;
 };
@@ -237,18 +295,23 @@ struct ClipControl {
 	bool    linear_attribute_clip_enable        = false;
 	bool    force_viewport_index_from_vs_enable = false;
 
-	[[nodiscard]] bool IsZClipEnabled() const { return !min_z_clip_disable && !max_z_clip_disable; }
+	[[nodiscard]] bool IsZClipModeRepresentable() const {
+		return min_z_clip_disable == max_z_clip_disable;
+	}
+	[[nodiscard]] bool IsZClipEnabled() const { return !min_z_clip_disable; }
 };
 
 struct DepthControl {
-	bool    stencil_enable      = false;
-	bool    z_enable            = false;
-	bool    z_write_enable      = false;
-	bool    depth_bounds_enable = false;
-	uint8_t zfunc               = 0;
-	bool    backface_enable     = false;
-	uint8_t stencilfunc         = 0;
-	uint8_t stencilfunc_bf      = 0;
+	bool    stencil_enable                     = false;
+	bool    z_enable                           = false;
+	bool    z_write_enable                     = false;
+	bool    depth_bounds_enable                = false;
+	uint8_t zfunc                              = 0;
+	bool    backface_enable                    = false;
+	uint8_t stencilfunc                        = 0;
+	uint8_t stencilfunc_bf                     = 0;
+	bool    color_writes_on_depth_fail_enable  = false;
+	bool    color_writes_on_depth_pass_disable = false;
 };
 
 struct StencilControl {
@@ -285,16 +348,6 @@ struct ModeControl {
 	bool    persp_corr_dis           = false;
 };
 
-struct PolyOffset {
-	int8_t neg_num_db_bits = -23;
-	bool   db_is_float_fmt = true;
-	float  clamp           = 0.0f;
-	float  front_scale     = 0.0f;
-	float  front_offset    = 0.0f;
-	float  back_scale      = 0.0f;
-	float  back_offset     = 0.0f;
-};
-
 struct BlendControl {
 	uint8_t color_srcblend       = 1;
 	uint8_t color_comb_fcn       = 0;
@@ -408,28 +461,30 @@ struct ScreenViewport {
 	bool     clip_rect_window_offset_enable[4]    = {};
 };
 
-struct HsShaderResource1 {
-	uint8_t vgprs                     = 0;
-	uint8_t priority                  = 0;
-	uint8_t float_mode                = 0;
-	bool    dx10_clamp                = false;
-	bool    debug_mode                = false;
-	bool    ieee_mode                 = false;
-	bool    require_forward_progress  = false;
-	bool    threadgroup_configuration = false;
-	uint8_t ls_vgpr_component_count   = 0;
-	bool    fp16_overflow             = false;
+struct VsShaderResource1 {
+	uint8_t vgprs                    = 0;
+	uint8_t sgprs                    = 0;
+	uint8_t priority                 = 0;
+	uint8_t float_mode               = 0;
+	bool    dx10_clamp               = false;
+	bool    ieee_mode                = false;
+	uint8_t vgpr_component_count     = 0;
+	bool    cu_group_enable          = false;
+	bool    require_forward_progress = false;
+	bool    fp16_overflow            = false;
 };
 
-struct HsShaderResource2 {
-	bool     scratch_en   = false;
-	uint8_t  user_sgpr    = 0;
-	uint16_t lds_size     = 0;
-	uint8_t  shared_vgprs = 0;
+struct VsShaderResource2 {
+	bool    scratch_en        = false;
+	uint8_t user_sgpr         = 0;
+	bool    offchip_lds       = false;
+	bool    streamout_enabled = false;
+	uint8_t shared_vgprs      = 0;
 };
 
 struct PsShaderResource1 {
 	uint8_t vgprs                    = 0;
+	uint8_t sgprs                    = 0;
 	uint8_t priority                 = 0;
 	uint8_t float_mode               = 0;
 	bool    dx10_clamp               = false;
@@ -445,7 +500,7 @@ struct PsShaderResource2 {
 	uint8_t user_sgpr              = 0;
 	bool    wave_cnt_en            = false;
 	uint8_t extra_lds_size         = 0;
-	uint8_t raster_ordered_shading = 0;
+	bool    raster_ordered_shading = false;
 	uint8_t shared_vgprs           = 0;
 };
 
@@ -453,33 +508,27 @@ struct PsStageRegisters {
 	uint64_t          data_addr = 0;
 	PsShaderResource1 rsrc1;
 	PsShaderResource2 rsrc2;
+	uint64_t          chksum = 0;
 };
 
 struct CsStageRegisters {
 
-	uint64_t data_addr                 = 0;
-	uint32_t num_thread_x              = 0;
-	uint32_t num_thread_y              = 0;
-	uint32_t num_thread_z              = 0;
-	uint8_t  vgprs                     = 0;
-	uint8_t  priority                  = 0;
-	uint8_t  float_mode                = 0;
-	bool     dx10_clamp                = false;
-	bool     debug_mode                = false;
-	bool     ieee_mode                 = false;
-	bool     require_forward_progress  = false;
-	bool     fp16_overflow             = false;
-	bool     threadgroup_configuration = false;
-	uint8_t  wave_size                 = 64;
-	bool     scratch_en                = false;
-	uint8_t  user_sgpr                 = 0;
-	bool     tgid_x_en                 = false;
-	bool     tgid_y_en                 = false;
-	bool     tgid_z_en                 = false;
-	bool     tg_size_en                = false;
-	uint8_t  tidig_comp_cnt            = 0;
-	uint16_t lds_size                  = 0;
-	uint8_t  shared_vgprs              = 0;
+	uint64_t data_addr      = 0;
+	uint32_t num_thread_x   = 0;
+	uint32_t num_thread_y   = 0;
+	uint32_t num_thread_z   = 0;
+	uint8_t  vgprs          = 0;
+	uint8_t  sgprs          = 0;
+	uint8_t  bulky          = 0;
+	uint8_t  wave_size      = 64;
+	uint8_t  scratch_en     = 0;
+	uint8_t  user_sgpr      = 0;
+	uint8_t  tgid_x_en      = 0;
+	uint8_t  tgid_y_en      = 0;
+	uint8_t  tgid_z_en      = 0;
+	uint8_t  tg_size_en     = 0;
+	uint8_t  tidig_comp_cnt = 0;
+	uint8_t  lds_size       = 0;
 };
 
 struct EsStageRegisters {
@@ -487,27 +536,31 @@ struct EsStageRegisters {
 };
 
 struct LsStageRegisters {
-	uint64_t data_addr = 0;
+	uint64_t          data_addr = 0;
+	VsShaderResource1 rsrc1;
+	VsShaderResource2 rsrc2;
 };
 
 struct HsStageRegisters {
 	uint64_t          data_addr = 0;
-	HsShaderResource1 rsrc1;
-	HsShaderResource2 rsrc2;
+	VsShaderResource1 rsrc1;
+	VsShaderResource2 rsrc2;
+	uint64_t          chksum = 0;
 };
 
 struct GsShaderResource1 {
-	uint8_t vgprs                     = 0;
-	uint8_t priority                  = 0;
-	uint8_t float_mode                = 0;
-	bool    dx10_clamp                = false;
-	bool    debug_mode                = false;
-	bool    ieee_mode                 = false;
-	bool    cu_group_enable           = false;
-	bool    require_forward_progress  = false;
-	bool    threadgroup_configuration = false;
-	uint8_t gs_vgpr_component_count   = 0;
-	bool    fp16_overflow             = false;
+	uint8_t vgprs                    = 0;
+	uint8_t sgprs                    = 0;
+	uint8_t priority                 = 0;
+	uint8_t float_mode               = 0;
+	bool    dx10_clamp               = false;
+	bool    debug_mode               = false;
+	bool    ieee_mode                = false;
+	bool    cu_group_enable          = false;
+	bool    require_forward_progress = false;
+	bool    lds_configuration        = false;
+	uint8_t gs_vgpr_component_count  = 0;
+	bool    fp16_overflow            = false;
 };
 
 struct GsShaderResource2 {
@@ -523,6 +576,7 @@ struct GsStageRegisters {
 	uint64_t          data_addr = 0;
 	GsShaderResource1 rsrc1;
 	GsShaderResource2 rsrc2;
+	uint64_t          chksum = 0;
 };
 
 struct ShaderRegisters {
@@ -578,7 +632,8 @@ struct ShaderRegisters {
 enum class UserSgprType { Unknown, Region, Vsharp };
 
 struct UserSgprInfo {
-	static constexpr int SGPRS_MAX = 32;
+	// Changed from 16 to 64
+	static constexpr int SGPRS_MAX = 64;
 
 	uint32_t     value[SGPRS_MAX] = {0};
 	UserSgprType type[SGPRS_MAX]  = {};
@@ -625,6 +680,12 @@ public:
 	void Reset() { *this = Context(); }
 
 	void SetColorBase(uint32_t slot, const ColorBase& base) { m_render_targets[slot].base = base; }
+	void SetColorPitch(uint32_t slot, const ColorPitch& pitch) {
+		m_render_targets[slot].pitch = pitch;
+	}
+	void SetColorSlice(uint32_t slot, const ColorSlice& slice) {
+		m_render_targets[slot].slice = slice;
+	}
 	void SetColorView(uint32_t slot, const ColorView& view) { m_render_targets[slot].view = view; }
 	void SetColorInfo(uint32_t slot, const ColorInfo& info) { m_render_targets[slot].info = info; }
 	void SetColorAttrib(uint32_t slot, const ColorAttrib& attrib) {
@@ -642,9 +703,15 @@ public:
 	void SetColorCmask(uint32_t slot, const ColorCmask& cmask) {
 		m_render_targets[slot].cmask = cmask;
 	}
+	void SetColorCmaskSlice(uint32_t slot, const ColorCmaskSlice& cmask_slice) {
+		m_render_targets[slot].cmask_slice = cmask_slice;
+	}
 	void SetColorFmask(uint32_t slot, const ColorFmask& fmask) {
 		m_render_targets[slot].fmask = fmask;
 	}
+	void SetColorFmaskSlice(uint32_t slot, const ColorFmaskSlice& fmask_slice) {
+		m_render_targets[slot].fmask_slice = fmask_slice;
+	}
 	void SetColorClearWord0(uint32_t slot, const ColorClearWord0& clear_word0) {
 		m_render_targets[slot].clear_word0 = clear_word0;
 	}
@@ -654,6 +721,7 @@ public:
 	void SetColorDccAddr(uint32_t slot, const ColorDccAddr& dcc_addr) {
 		m_render_targets[slot].dcc_addr = dcc_addr;
 	}
+	void SetColorSize(uint32_t slot, const ColorSize& size) { m_render_targets[slot].size = size; }
 	[[nodiscard]] const RenderTarget& GetRenderTarget(uint32_t slot) const {
 		return m_render_targets[slot];
 	}
@@ -812,8 +880,6 @@ public:
 	void SetDepthControl(const DepthControl& control) { m_depth_control = control; }
 	[[nodiscard]] const ModeControl& GetModeControl() const { return m_mode_control; }
 	void SetModeControl(const ModeControl& control) { m_mode_control = control; }
-	[[nodiscard]] const PolyOffset& GetPolyOffset() const { return m_poly_offset; }
-	void SetPolyOffset(const PolyOffset& offset) { m_poly_offset = offset; }
 	[[nodiscard]] const EqaaControl& GetEqaaControl() const { return m_eqaa_control; }
 	void SetEqaaControl(const EqaaControl& control) { m_eqaa_control = control; }
 	[[nodiscard]] const StencilControl& GetStencilControl() const { return m_stencil_control; }
@@ -838,10 +904,8 @@ public:
 	[[nodiscard]] uint8_t GetStencilClearValue() const { return m_stencil_clear_value; }
 	void SetStencilClearValue(uint8_t clear_value) { m_stencil_clear_value = clear_value; }
 
-	[[nodiscard]] float    GetLineWidth() const { return m_line_width; }
-	void                   SetLineWidth(float width) { m_line_width = width; }
-	[[nodiscard]] uint32_t GetPrimitiveResetIndex() const { return m_primitive_reset_index; }
-	void SetPrimitiveResetIndex(uint32_t index) { m_primitive_reset_index = index; }
+	[[nodiscard]] float GetLineWidth() const { return m_line_width; }
+	void                SetLineWidth(float width) { m_line_width = width; }
 
 	[[nodiscard]] const ShaderRegisters& GetShaderRegisters() const { return m_sh_regs; }
 
@@ -886,8 +950,7 @@ public:
 	void SetScShaderControl(uint32_t value) { m_sh_regs.m_paScShaderControl = value; }
 
 private:
-	float    m_line_width            = 1.0f;
-	uint32_t m_primitive_reset_index = 0xffffffffu;
+	float m_line_width = 1.0f;
 
 	BlendControl    m_blend_control[8];
 	BlendColor      m_blend_color;
@@ -914,7 +977,6 @@ private:
 	uint8_t           m_stencil_clear_value = 0;
 
 	ModeControl m_mode_control;
-	PolyOffset  m_poly_offset;
 	EqaaControl m_eqaa_control;
 
 	ShaderRegisters m_sh_regs;
@@ -929,14 +991,12 @@ public:
 
 	void Reset() { *this = UserConfig(); }
 
-	void SetPrimitiveType(Prospero::PrimitiveType prim_type) { m_prim_type = prim_type; }
-	[[nodiscard]] Prospero::PrimitiveType GetPrimType() const { return m_prim_type; }
+	void                   SetPrimitiveType(uint32_t prim_type) { m_prim_type = prim_type; }
+	[[nodiscard]] uint32_t GetPrimType() const { return m_prim_type; }
 	void                   SetIndexOffset(uint32_t index_offset) { m_index_offset = index_offset; }
 	[[nodiscard]] uint32_t GetIndexOffset() const { return m_index_offset; }
 	void                   SetObjectId(uint32_t object_id) { m_object_id = object_id; }
 	[[nodiscard]] uint32_t GetObjectId() const { return m_object_id; }
-	void SetPrimitiveResetControl(uint32_t control) { m_primitive_reset_control = control; }
-	[[nodiscard]] uint32_t GetPrimitiveResetControl() const { return m_primitive_reset_control; }
 
 	[[nodiscard]] const GeControl& GetGeControl() const { return m_ge_cntl; }
 	void                           SetGeControl(const GeControl& control) { m_ge_cntl = control; }
@@ -951,10 +1011,9 @@ public:
 	void SetGdsOaAddress(uint32_t value) { m_gds_oa.counters[m_gds_oa.GetIndex()].address = value; }
 
 private:
-	Prospero::PrimitiveType m_prim_type               = Prospero::PrimitiveType::kNone;
-	uint32_t                m_index_offset            = 0;
-	uint32_t                m_object_id               = 0;
-	uint32_t                m_primitive_reset_control = 0;
+	uint32_t m_prim_type    = 0;
+	uint32_t m_index_offset = 0;
+	uint32_t m_object_id    = 0;
 
 	GeControl    m_ge_cntl;
 	GeUserVgprEn m_ge_user_vgpr_en;
@@ -972,19 +1031,23 @@ public:
 
 	void SetEsShaderBase(uint64_t addr) { m_vs.es_regs.data_addr = addr; }
 	void SetLsShaderBase(uint64_t addr) { m_vs.ls_regs.data_addr = addr; }
+	void SetLsShaderResource1(const VsShaderResource1& rsrc1) { m_vs.ls_regs.rsrc1 = rsrc1; }
+	void SetLsShaderResource2(const VsShaderResource2& rsrc2) { m_vs.ls_regs.rsrc2 = rsrc2; }
 	void SetHsShaderBase(uint64_t addr) { m_vs.hs_regs.data_addr = addr; }
-	void SetHsShaderResource1(const HsShaderResource1& rsrc1) { m_vs.hs_regs.rsrc1 = rsrc1; }
-	void SetHsShaderResource2(const HsShaderResource2& rsrc2) { m_vs.hs_regs.rsrc2 = rsrc2; }
+	void SetHsShaderResource1(const VsShaderResource1& rsrc1) { m_vs.hs_regs.rsrc1 = rsrc1; }
+	void SetHsShaderResource2(const VsShaderResource2& rsrc2) { m_vs.hs_regs.rsrc2 = rsrc2; }
+	void SetHsShaderChksum(uint32_t value) { m_vs.hs_regs.chksum = value; }
 	void SetGsShaderBase(uint64_t addr) { m_vs.gs_regs.data_addr = addr; }
 	void SetGsShaderResource1(const GsShaderResource1& rsrc1) { m_vs.gs_regs.rsrc1 = rsrc1; }
 	void SetGsShaderResource2(const GsShaderResource2& rsrc2) { m_vs.gs_regs.rsrc2 = rsrc2; }
+	void SetGsShaderChksum(uint32_t value) { m_vs.gs_regs.chksum = value; }
 
 	void SetPsShaderBase(uint64_t addr) { m_ps.ps_regs.data_addr = addr; }
 	void SetPsShaderResource1(const PsShaderResource1& rsrc1) { m_ps.ps_regs.rsrc1 = rsrc1; }
 	void SetPsShaderResource2(const PsShaderResource2& rsrc2) { m_ps.ps_regs.rsrc2 = rsrc2; }
+	void SetPsShaderChksum(uint32_t value) { m_ps.ps_regs.chksum = value; }
 
 	void SetCsShader(const CsStageRegisters& cs_regs) { m_cs.cs_regs = cs_regs; }
-	void SetCsWaveSize(uint8_t wave_size) { m_cs.cs_regs.wave_size = wave_size; }
 
 	void SetPsUserSgpr(uint32_t id, uint32_t value, UserSgprType type) {
 		m_ps.ps_user_sgpr.value[id] = value;

src/graphics/guest_gpu/pm4.cpp

@@ -21,14 +21,15 @@ constexpr auto MakeRegisterNames() {
 	names[R_DRAW_RESET]     = "R_DRAW_RESET";
 	names[R_WAIT_FLIP_DONE] = "R_WAIT_FLIP_DONE";
 	names[R_DISPATCH_RESET] = "R_DISPATCH_RESET";
+	names[R_WAIT_MEM_32]    = "R_WAIT_MEM_32";
 	names[R_PUSH_MARKER]    = "R_PUSH_MARKER";
 	names[R_POP_MARKER]     = "R_POP_MARKER";
 	names[R_ACQUIRE_MEM]    = "R_ACQUIRE_MEM";
 	names[R_WRITE_DATA]     = "R_WRITE_DATA";
+	names[R_WAIT_MEM_64]    = "R_WAIT_MEM_64";
 	names[R_FLIP]           = "R_FLIP";
 	names[R_RELEASE_MEM]    = "R_RELEASE_MEM";
 	names[R_DMA_DATA]       = "R_DMA_DATA";
-	names[R_CONTEXT_STATE]  = "R_CONTEXT_STATE";
 	return names;
 }
 
@@ -60,7 +61,6 @@ constexpr auto MakeOpcodeNames() {
 	names[IT_WRITE_DATA]                = "IT_WRITE_DATA";
 	names[IT_MEM_SEMAPHORE]             = "IT_MEM_SEMAPHORE";
 	names[IT_DRAW_INDEX_INDIRECT_MULTI] = "IT_DRAW_INDEX_INDIRECT_MULTI";
-	names[IT_WAIT_REG_MEM]               = "IT_WAIT_REG_MEM";
 	names[IT_INDIRECT_BUFFER]           = "IT_INDIRECT_BUFFER";
 	names[IT_COPY_DATA]                 = "IT_COPY_DATA";
 	names[IT_CP_DMA]                    = "IT_CP_DMA";
@@ -90,7 +90,6 @@ constexpr auto MakeOpcodeNames() {
 	names[IT_DISPATCH_DRAW_PREAMBLE]    = "IT_DISPATCH_DRAW_PREAMBLE";
 	names[IT_DISPATCH_DRAW]             = "IT_DISPATCH_DRAW";
 	names[IT_GET_LOD_STATS]             = "IT_GET_LOD_STATS";
-	names[IT_WAIT_REG_MEM_64]           = "IT_WAIT_REG_MEM_64";
 	names[IT_SET_CONTEXT_REG_INDIRECT]  = "IT_SET_CONTEXT_REG_INDIRECT";
 	return names;
 }
@@ -100,7 +99,7 @@ constexpr auto g_opcode_names   = MakeOpcodeNames();
 
 } // namespace
 
-void DumpPm4PacketStream(Common::File* file, const uint32_t* cmd_buffer, uint32_t start_dw,
+void DumpPm4PacketStream(Common::File* file, uint32_t* cmd_buffer, uint32_t start_dw,
                          uint32_t num_dw) {
 	// db_dump();
 
@@ -143,9 +142,9 @@ void DumpPm4PacketStream(Common::File* file, const uint32_t* cmd_buffer, uint32_
 				if ((op == IT_SET_CONTEXT_REG_INDIRECT || op == IT_SET_SH_REG_INDIRECT ||
 				     op == IT_SET_UCONFIG_REG_INDIRECT) &&
 				    len == 4) {
-					auto* indirect_buffer = reinterpret_cast<const uint32_t*>(
-					    (static_cast<uint64_t>(cmd[0]) & 0xfffffffcu) |
-					    (static_cast<uint64_t>(cmd[1]) << 32u));
+					auto* indirect_buffer =
+					    reinterpret_cast<uint32_t*>((static_cast<uint64_t>(cmd[0]) & 0xfffffffcu) |
+					                                (static_cast<uint64_t>(cmd[1]) << 32u));
 					const uint32_t indirect_num_regs = cmd[3] & 0x3fffu;
 
 					for (uint32_t i = 0; indirect_buffer != nullptr && i < indirect_num_regs;

src/graphics/guest_gpu/pm4.h

@@ -42,7 +42,6 @@ constexpr uint32_t IT_WRITE_DATA                = 0x37;
 constexpr uint32_t IT_MEM_SEMAPHORE             = 0x39;
 constexpr uint32_t IT_DRAW_INDEX_INDIRECT_MULTI = 0x38;
 constexpr uint32_t IT_DISPATCH_DRAW_PREAMBLE    = 0x3A;
-constexpr uint32_t IT_WAIT_REG_MEM              = 0x3C;
 constexpr uint32_t IT_INDIRECT_BUFFER           = 0x3F;
 constexpr uint32_t IT_COPY_DATA                 = 0x40;
 constexpr uint32_t IT_CP_DMA                    = 0x41;
@@ -71,7 +70,6 @@ constexpr uint32_t IT_WAIT_ON_CE_COUNTER        = 0x86;
 constexpr uint32_t IT_WAIT_ON_DE_COUNTER_DIFF   = 0x88;
 constexpr uint32_t IT_DISPATCH_DRAW             = 0x8D;
 constexpr uint32_t IT_GET_LOD_STATS             = 0x8E;
-constexpr uint32_t IT_WAIT_REG_MEM_64           = 0x93;
 constexpr uint32_t IT_SET_CONTEXT_REG_INDIRECT  = 0x9F;
 
 /* Custom codes. Implemented via IT_NOP */
@@ -80,14 +78,15 @@ constexpr uint32_t R_ZERO           = 0x00;
 constexpr uint32_t R_DRAW_RESET     = 0x05;
 constexpr uint32_t R_WAIT_FLIP_DONE = 0x06;
 constexpr uint32_t R_DISPATCH_RESET = 0x09;
+constexpr uint32_t R_WAIT_MEM_32    = 0x0A;
 constexpr uint32_t R_PUSH_MARKER    = 0x0B;
 constexpr uint32_t R_POP_MARKER     = 0x0C;
 constexpr uint32_t R_ACQUIRE_MEM    = 0x14;
 constexpr uint32_t R_WRITE_DATA     = 0x15;
+constexpr uint32_t R_WAIT_MEM_64    = 0x16;
 constexpr uint32_t R_FLIP           = 0x17;
 constexpr uint32_t R_RELEASE_MEM    = 0x18;
 constexpr uint32_t R_DMA_DATA       = 0x19;
-constexpr uint32_t R_CONTEXT_STATE  = 0x1A;
 
 constexpr uint32_t R_NUM = 0x3F + 1;
 
@@ -98,10 +97,6 @@ constexpr uint32_t DB_RENDER_CONTROL_DEPTH_CLEAR_ENABLE_SHIFT       = 0;
 constexpr uint32_t DB_RENDER_CONTROL_DEPTH_CLEAR_ENABLE_MASK        = 0x1;
 constexpr uint32_t DB_RENDER_CONTROL_STENCIL_CLEAR_ENABLE_SHIFT     = 1;
 constexpr uint32_t DB_RENDER_CONTROL_STENCIL_CLEAR_ENABLE_MASK      = 0x1;
-constexpr uint32_t DB_RENDER_CONTROL_COPY_DEPTH_TO_COLOR_SHIFT      = 2;
-constexpr uint32_t DB_RENDER_CONTROL_COPY_DEPTH_TO_COLOR_MASK       = 0x1;
-constexpr uint32_t DB_RENDER_CONTROL_COPY_STENCIL_TO_COLOR_SHIFT    = 3;
-constexpr uint32_t DB_RENDER_CONTROL_COPY_STENCIL_TO_COLOR_MASK     = 0x1;
 constexpr uint32_t DB_RENDER_CONTROL_RESUMMARIZE_ENABLE_SHIFT       = 4;
 constexpr uint32_t DB_RENDER_CONTROL_RESUMMARIZE_ENABLE_MASK        = 0x1;
 constexpr uint32_t DB_RENDER_CONTROL_STENCIL_COMPRESS_DISABLE_SHIFT = 5;
@@ -167,6 +162,22 @@ constexpr uint32_t PA_SC_SCREEN_SCISSOR_BR_BR_Y_MASK  = 0xFFFF;
 
 constexpr uint32_t DB_DFSM_CONTROL = 0xE;
 
+constexpr uint32_t DB_DEPTH_INFO                          = 0xF;
+constexpr uint32_t DB_DEPTH_INFO_ADDR5_SWIZZLE_MASK_SHIFT = 0;
+constexpr uint32_t DB_DEPTH_INFO_ADDR5_SWIZZLE_MASK_MASK  = 0xF;
+constexpr uint32_t DB_DEPTH_INFO_ARRAY_MODE_SHIFT         = 4;
+constexpr uint32_t DB_DEPTH_INFO_ARRAY_MODE_MASK          = 0xF;
+constexpr uint32_t DB_DEPTH_INFO_PIPE_CONFIG_SHIFT        = 8;
+constexpr uint32_t DB_DEPTH_INFO_PIPE_CONFIG_MASK         = 0x1F;
+constexpr uint32_t DB_DEPTH_INFO_BANK_WIDTH_SHIFT         = 13;
+constexpr uint32_t DB_DEPTH_INFO_BANK_WIDTH_MASK          = 0x3;
+constexpr uint32_t DB_DEPTH_INFO_BANK_HEIGHT_SHIFT        = 15;
+constexpr uint32_t DB_DEPTH_INFO_BANK_HEIGHT_MASK         = 0x3;
+constexpr uint32_t DB_DEPTH_INFO_MACRO_TILE_ASPECT_SHIFT  = 17;
+constexpr uint32_t DB_DEPTH_INFO_MACRO_TILE_ASPECT_MASK   = 0x3;
+constexpr uint32_t DB_DEPTH_INFO_NUM_BANKS_SHIFT          = 19;
+constexpr uint32_t DB_DEPTH_INFO_NUM_BANKS_MASK           = 0x3;
+
 constexpr uint32_t DB_Z_INFO                               = 0x10;
 constexpr uint32_t DB_Z_INFO_FORMAT_SHIFT                  = 0;
 constexpr uint32_t DB_Z_INFO_FORMAT_MASK                   = 0x3;
@@ -210,6 +221,16 @@ constexpr uint32_t DB_STENCIL_READ_BASE  = 0x13;
 constexpr uint32_t DB_Z_WRITE_BASE       = 0x14;
 constexpr uint32_t DB_STENCIL_WRITE_BASE = 0x15;
 
+constexpr uint32_t DB_DEPTH_SIZE                       = 0x16;
+constexpr uint32_t DB_DEPTH_SIZE_PITCH_TILE_MAX_SHIFT  = 0;
+constexpr uint32_t DB_DEPTH_SIZE_PITCH_TILE_MAX_MASK   = 0x7FF;
+constexpr uint32_t DB_DEPTH_SIZE_HEIGHT_TILE_MAX_SHIFT = 11;
+constexpr uint32_t DB_DEPTH_SIZE_HEIGHT_TILE_MAX_MASK  = 0x7FF;
+
+constexpr uint32_t DB_DEPTH_SLICE                      = 0x17;
+constexpr uint32_t DB_DEPTH_SLICE_SLICE_TILE_MAX_SHIFT = 0;
+constexpr uint32_t DB_DEPTH_SLICE_SLICE_TILE_MAX_MASK  = 0x3FFFFF;
+
 constexpr uint32_t DB_Z_READ_BASE_HI                  = 0x1A;
 constexpr uint32_t DB_STENCIL_READ_BASE_HI            = 0x1B;
 constexpr uint32_t DB_Z_WRITE_BASE_HI                 = 0x1C;
@@ -295,8 +316,8 @@ constexpr uint32_t FSR_RECURSIONS1              = 0xF2;
 constexpr uint32_t VGT_MULTI_PRIM_IB_RESET_INDX = 0x103;
 constexpr uint32_t CB_RMI_GL2_CACHE_CONTROL     = 0x104;
 constexpr uint32_t CB_BLEND_RED                 = 0x105;
-constexpr uint32_t CB_BLEND_BLUE                = 0x106;
-constexpr uint32_t CB_BLEND_GREEN               = 0x107;
+constexpr uint32_t CB_BLEND_GREEN               = 0x106;
+constexpr uint32_t CB_BLEND_BLUE                = 0x107;
 constexpr uint32_t CB_BLEND_ALPHA               = 0x108;
 constexpr uint32_t CB_DCC_CONTROL               = 0x109;
 
@@ -350,7 +371,6 @@ constexpr uint32_t PA_CL_UCP_0_X          = 0x16F;
 constexpr uint32_t PA_CL_UCP_0_Y          = 0x170;
 constexpr uint32_t PA_CL_UCP_0_Z          = 0x171;
 constexpr uint32_t PA_CL_UCP_0_W          = 0x172;
-constexpr uint32_t PA_CL_UCP_5_W          = 0x186;
 constexpr uint32_t SPI_PS_INPUT_CNTL_0    = 0x191;
 constexpr uint32_t SPI_PS_INPUT_CNTL_31   = 0x1B0;
 constexpr uint32_t SPI_VS_OUT_CONFIG      = 0x1B1;
@@ -365,6 +385,9 @@ constexpr uint32_t SPI_SHADER_POS_FORMAT  = 0x1C3;
 constexpr uint32_t SPI_SHADER_Z_FORMAT    = 0x1C4;
 constexpr uint32_t SPI_SHADER_COL_FORMAT  = 0x1C5;
 
+// Indirect Cx descriptor selector for the 32-entry PS input-control register bank.
+constexpr uint32_t CX_PS_SHADER_USAGE_BASE = 0x10000000u;
+
 constexpr uint32_t CB_BLEND0_CONTROL                            = 0x1E0;
 constexpr uint32_t CB_BLEND0_CONTROL_COLOR_SRCBLEND_SHIFT       = 0;
 constexpr uint32_t CB_BLEND0_CONTROL_COLOR_SRCBLEND_MASK        = 0x1F;
@@ -402,6 +425,11 @@ constexpr uint32_t DB_DEPTH_CONTROL_STENCILFUNC_SHIFT                        = 8
 constexpr uint32_t DB_DEPTH_CONTROL_STENCILFUNC_MASK                         = 0x7;
 constexpr uint32_t DB_DEPTH_CONTROL_STENCILFUNC_BF_SHIFT                     = 20;
 constexpr uint32_t DB_DEPTH_CONTROL_STENCILFUNC_BF_MASK                      = 0x7;
+constexpr uint32_t DB_DEPTH_CONTROL_ENABLE_COLOR_WRITES_ON_DEPTH_FAIL_SHIFT  = 30;
+constexpr uint32_t DB_DEPTH_CONTROL_ENABLE_COLOR_WRITES_ON_DEPTH_FAIL_MASK   = 0x1;
+constexpr uint32_t DB_DEPTH_CONTROL_DISABLE_COLOR_WRITES_ON_DEPTH_PASS_SHIFT = 31;
+constexpr uint32_t DB_DEPTH_CONTROL_DISABLE_COLOR_WRITES_ON_DEPTH_PASS_MASK  = 0x1;
+
 constexpr uint32_t DB_EQAA                                  = 0x201;
 constexpr uint32_t DB_EQAA_MAX_ANCHOR_SAMPLES_SHIFT         = 0;
 constexpr uint32_t DB_EQAA_MAX_ANCHOR_SAMPLES_MASK          = 0x7;
@@ -533,32 +561,40 @@ constexpr uint32_t VGT_DRAW_PAYLOAD_CNTL  = 0x2A6;
 constexpr uint32_t VGT_ESGS_RING_ITEMSIZE = 0x2AB;
 constexpr uint32_t VGT_REUSE_OFF          = 0x2AD;
 
-constexpr uint32_t DB_SHADING_RATE_ENCODING                             = 0x2AF;
-constexpr uint32_t DB_SHADING_RATE_ENCODING_SHADING_RATE_ENCODING_SHIFT = 19;
-constexpr uint32_t DB_SHADING_RATE_ENCODING_SHADING_RATE_ENCODING_MASK  = 0x3;
+constexpr uint32_t DB_HTILE_SURFACE                               = 0x2AF;
+constexpr uint32_t DB_HTILE_SURFACE_LINEAR_SHIFT                  = 0;
+constexpr uint32_t DB_HTILE_SURFACE_LINEAR_MASK                   = 0x1;
+constexpr uint32_t DB_HTILE_SURFACE_FULL_CACHE_SHIFT              = 1;
+constexpr uint32_t DB_HTILE_SURFACE_FULL_CACHE_MASK               = 0x1;
+constexpr uint32_t DB_HTILE_SURFACE_HTILE_USES_PRELOAD_WIN_SHIFT  = 2;
+constexpr uint32_t DB_HTILE_SURFACE_HTILE_USES_PRELOAD_WIN_MASK   = 0x1;
+constexpr uint32_t DB_HTILE_SURFACE_PRELOAD_SHIFT                 = 3;
+constexpr uint32_t DB_HTILE_SURFACE_PRELOAD_MASK                  = 0x1;
+constexpr uint32_t DB_HTILE_SURFACE_PREFETCH_WIDTH_SHIFT          = 4;
+constexpr uint32_t DB_HTILE_SURFACE_PREFETCH_WIDTH_MASK           = 0x3F;
+constexpr uint32_t DB_HTILE_SURFACE_PREFETCH_HEIGHT_SHIFT         = 10;
+constexpr uint32_t DB_HTILE_SURFACE_PREFETCH_HEIGHT_MASK          = 0x3F;
+constexpr uint32_t DB_HTILE_SURFACE_DST_OUTSIDE_ZERO_TO_ONE_SHIFT = 16;
+constexpr uint32_t DB_HTILE_SURFACE_DST_OUTSIDE_ZERO_TO_ONE_MASK  = 0x1;
 
-constexpr uint32_t DB_SRESULTS_COMPARE_STATE0                          = 0x2B0;
-constexpr uint32_t DB_SRESULTS_COMPARE_STATE1                          = 0x2B1;
-constexpr uint32_t VGT_GS_MAX_VERT_OUT                                 = 0x2CE;
-constexpr uint32_t GE_NGG_SUBGRP_CNTL                                  = 0x2D3;
-constexpr uint32_t VGT_TESS_DISTRIBUTION                               = 0x2D4;
-constexpr uint32_t VGT_SHADER_STAGES_EN                                = 0x2D5;
-constexpr uint32_t VGT_LS_HS_CONFIG                                    = 0x2D6;
-constexpr uint32_t VGT_TF_PARAM                                        = 0x2DB;
-constexpr uint32_t DB_ALPHA_TO_MASK                                    = 0x2DC;
-constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL                       = 0x2DE;
-constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL_NEG_NUM_DB_BITS_SHIFT = 0;
-constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL_NEG_NUM_DB_BITS_MASK  = 0xFF;
-constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL_DB_IS_FLOAT_FMT_SHIFT = 8;
-constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL_DB_IS_FLOAT_FMT_MASK  = 0x1;
-constexpr uint32_t PA_SU_POLY_OFFSET_CLAMP                             = 0x2DF;
-constexpr uint32_t PA_SU_POLY_OFFSET_FRONT_SCALE                       = 0x2E0;
-constexpr uint32_t PA_SU_POLY_OFFSET_FRONT_OFFSET                      = 0x2E1;
-constexpr uint32_t PA_SU_POLY_OFFSET_BACK_SCALE                        = 0x2E2;
-constexpr uint32_t PA_SU_POLY_OFFSET_BACK_OFFSET                       = 0x2E3;
-constexpr uint32_t VGT_GS_INSTANCE_CNT                                 = 0x2E4;
-constexpr uint32_t PA_SC_CENTROID_PRIORITY_0                           = 0x2F5;
-constexpr uint32_t PA_SC_CENTROID_PRIORITY_1                           = 0x2F6;
+constexpr uint32_t DB_SRESULTS_COMPARE_STATE0     = 0x2B0;
+constexpr uint32_t DB_SRESULTS_COMPARE_STATE1     = 0x2B1;
+constexpr uint32_t VGT_GS_MAX_VERT_OUT            = 0x2CE;
+constexpr uint32_t GE_NGG_SUBGRP_CNTL             = 0x2D3;
+constexpr uint32_t VGT_TESS_DISTRIBUTION          = 0x2D4;
+constexpr uint32_t VGT_SHADER_STAGES_EN           = 0x2D5;
+constexpr uint32_t VGT_LS_HS_CONFIG               = 0x2D6;
+constexpr uint32_t VGT_TF_PARAM                   = 0x2DB;
+constexpr uint32_t DB_ALPHA_TO_MASK               = 0x2DC;
+constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL  = 0x2DE;
+constexpr uint32_t PA_SU_POLY_OFFSET_CLAMP        = 0x2DF;
+constexpr uint32_t PA_SU_POLY_OFFSET_FRONT_SCALE  = 0x2E0;
+constexpr uint32_t PA_SU_POLY_OFFSET_FRONT_OFFSET = 0x2E1;
+constexpr uint32_t PA_SU_POLY_OFFSET_BACK_SCALE   = 0x2E2;
+constexpr uint32_t PA_SU_POLY_OFFSET_BACK_OFFSET  = 0x2E3;
+constexpr uint32_t VGT_GS_INSTANCE_CNT            = 0x2E4;
+constexpr uint32_t PA_SC_CENTROID_PRIORITY_0      = 0x2F5;
+constexpr uint32_t PA_SC_CENTROID_PRIORITY_1      = 0x2F6;
 
 constexpr uint32_t PA_SC_AA_CONFIG                             = 0x2F8;
 constexpr uint32_t PA_SC_AA_CONFIG_MSAA_NUM_SAMPLES_SHIFT      = 0;
@@ -582,6 +618,7 @@ constexpr uint32_t PA_SC_SHADER_CONTROL                  = 0x310;
 constexpr uint32_t PA_SC_BINNER_CNTL_0                   = 0x311;
 constexpr uint32_t PA_SC_BINNER_CNTL_1                   = 0x312;
 constexpr uint32_t PA_SC_CONSERVATIVE_RASTERIZATION_CNTL = 0x313;
+constexpr uint32_t PA_SC_NGG_MODE_CNTL                   = 0x314;
 constexpr uint32_t CB_COLOR0_BASE                        = 0x318;
 
 constexpr uint32_t CB_COLOR0_VIEW                   = 0x31B;
@@ -609,13 +646,24 @@ constexpr uint32_t CB_COLOR0_INFO_BLEND_BYPASS_SHIFT              = 16;
 constexpr uint32_t CB_COLOR0_INFO_BLEND_BYPASS_MASK               = 0x1;
 constexpr uint32_t CB_COLOR0_INFO_ROUND_MODE_SHIFT                = 18;
 constexpr uint32_t CB_COLOR0_INFO_ROUND_MODE_MASK                 = 0x1;
+constexpr uint32_t CB_COLOR0_INFO_CMASK_IS_LINEAR_SHIFT           = 19;
+constexpr uint32_t CB_COLOR0_INFO_CMASK_IS_LINEAR_MASK            = 0x1;
 constexpr uint32_t CB_COLOR0_INFO_FMASK_COMPRESSION_DISABLE_SHIFT = 26;
 constexpr uint32_t CB_COLOR0_INFO_FMASK_COMPRESSION_DISABLE_MASK  = 0x1;
 constexpr uint32_t CB_COLOR0_INFO_FMASK_COMPRESS_1FRAG_ONLY_SHIFT = 27;
 constexpr uint32_t CB_COLOR0_INFO_FMASK_COMPRESS_1FRAG_ONLY_MASK  = 0x1;
 constexpr uint32_t CB_COLOR0_INFO_DCC_ENABLE_SHIFT                = 28;
 constexpr uint32_t CB_COLOR0_INFO_DCC_ENABLE_MASK                 = 0x1;
+constexpr uint32_t CB_COLOR0_INFO_CMASK_ADDR_TYPE_SHIFT           = 29;
+constexpr uint32_t CB_COLOR0_INFO_CMASK_ADDR_TYPE_MASK            = 0x3;
+constexpr uint32_t CB_COLOR0_INFO_ALT_TILE_MODE_SHIFT             = 31;
+constexpr uint32_t CB_COLOR0_INFO_ALT_TILE_MODE_MASK              = 0x1;
+
 constexpr uint32_t CB_COLOR0_ATTRIB                             = 0x31D;
+constexpr uint32_t CB_COLOR0_ATTRIB_TILE_MODE_INDEX_SHIFT       = 0;
+constexpr uint32_t CB_COLOR0_ATTRIB_TILE_MODE_INDEX_MASK        = 0x1F;
+constexpr uint32_t CB_COLOR0_ATTRIB_FMASK_TILE_MODE_INDEX_SHIFT = 5;
+constexpr uint32_t CB_COLOR0_ATTRIB_FMASK_TILE_MODE_INDEX_MASK  = 0x1F;
 constexpr uint32_t CB_COLOR0_ATTRIB_NUM_SAMPLES_SHIFT           = 12;
 constexpr uint32_t CB_COLOR0_ATTRIB_NUM_SAMPLES_MASK            = 0x7;
 constexpr uint32_t CB_COLOR0_ATTRIB_NUM_FRAGMENTS_SHIFT         = 15;
@@ -630,6 +678,8 @@ constexpr uint32_t CB_COLOR0_DCC_CONTROL_KEY_CLEAR_ENABLE_SHIFT
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_KEY_CLEAR_ENABLE_MASK                  = 0x1;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_MAX_UNCOMPRESSED_BLOCK_SIZE_SHIFT      = 2;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_MAX_UNCOMPRESSED_BLOCK_SIZE_MASK       = 0x3;
+constexpr uint32_t CB_COLOR0_DCC_CONTROL_MIN_COMPRESSED_BLOCK_SIZE_SHIFT        = 4;
+constexpr uint32_t CB_COLOR0_DCC_CONTROL_MIN_COMPRESSED_BLOCK_SIZE_MASK         = 0x1;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_MAX_COMPRESSED_BLOCK_SIZE_SHIFT        = 5;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_MAX_COMPRESSED_BLOCK_SIZE_MASK         = 0x3;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_COLOR_TRANSFORM_SHIFT                  = 7;
@@ -686,25 +736,31 @@ constexpr uint32_t CB_COLOR0_ATTRIB3_CMASK_PIPE_ALIGNED_SHIFT = 26;
 constexpr uint32_t CB_COLOR0_ATTRIB3_CMASK_PIPE_ALIGNED_MASK  = 0x1;
 constexpr uint32_t CB_COLOR0_ATTRIB3_DCC_PIPE_ALIGNED_SHIFT   = 30;
 constexpr uint32_t CB_COLOR0_ATTRIB3_DCC_PIPE_ALIGNED_MASK    = 0x1;
-constexpr uint32_t CB_COLOR0_ATTRIB3_WRITE_VRS_RATE_HINT_TO_CMASK_SHIFT = 31;
-constexpr uint32_t CB_COLOR0_ATTRIB3_WRITE_VRS_RATE_HINT_TO_CMASK_MASK  = 0x1;
 
 constexpr uint32_t CB_COLOR7_ATTRIB3 = 0x3BF;
 
-constexpr uint32_t CX_NOP = 0xDB;
+/* Fake codes. Don't exist on real HW */
+
+constexpr uint32_t CX_NOP = 0x800003FF;
 
 constexpr uint32_t CX_NUM = 0x3FF + 1;
 
 /* Shader registers */
 
-constexpr uint32_t SPI_SHADER_PACE_ID_PS            = 0x6;
-constexpr uint32_t SPI_GRAPHICS_SHADER_CONTROL_PS    = 0x7;
-constexpr uint32_t SPI_SHADER_PGM_LO_PS              = 0x8;
-constexpr uint32_t SPI_SHADER_PGM_HI_PS              = 0x9;
+constexpr uint32_t SPI_SHADER_TBA_LO_PS     = 0x0;
+constexpr uint32_t SPI_SHADER_PGM_RSRC4_PS  = 0x1;
+constexpr uint32_t SPI_SHADER_TMA_LO_PS     = 0x2;
+constexpr uint32_t SPI_SHADER_TMA_HI_PS     = 0x3;
+constexpr uint32_t SPI_SHADER_PGM_CHKSUM_PS = 0x6;
+constexpr uint32_t SPI_SHADER_PGM_RSRC3_PS  = 0x7;
+constexpr uint32_t SPI_SHADER_PGM_LO_PS     = 0x8;
+constexpr uint32_t SPI_SHADER_PGM_HI_PS     = 0x9;
 
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS                        = 0xA;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_VGPRS_SHIFT            = 0;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_VGPRS_MASK             = 0x3F;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_SGPRS_SHIFT            = 6;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_SGPRS_MASK             = 0xF;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_PRIORITY_SHIFT         = 10;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_PRIORITY_MASK          = 0x3;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_FLOAT_MODE_SHIFT       = 12;
@@ -722,30 +778,33 @@ constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_FWD_PROGRESS_MASK      = 0x1;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_FP16_OVFL_SHIFT        = 29;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_FP16_OVFL_MASK         = 0x1;
 
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS                              = 0xB;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SCRATCH_EN_SHIFT             = 0;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SCRATCH_EN_MASK              = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_SHIFT              = 1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MASK               = 0x1F;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_WAVE_CNT_EN_SHIFT            = 7;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_WAVE_CNT_EN_MASK             = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_EXTRA_LDS_SIZE_SHIFT         = 8;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_EXTRA_LDS_SIZE_MASK          = 0xFF;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_RASTER_ORDERED_SHADING_SHIFT = 25;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_RASTER_ORDERED_SHADING_MASK  = 0x3;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MSB_SHIFT          = 27;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MSB_MASK           = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SHARED_VGPR_CNT_SHIFT        = 28;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SHARED_VGPR_CNT_MASK         = 0xF;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS                                = 0xB;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SCRATCH_EN_SHIFT               = 0;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SCRATCH_EN_MASK                = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_SHIFT                = 1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MASK                 = 0x1F;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_WAVE_CNT_EN_SHIFT              = 7;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_WAVE_CNT_EN_MASK               = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_EXTRA_LDS_SIZE_SHIFT           = 8;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_EXTRA_LDS_SIZE_MASK            = 0xFF;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_LOAD_INTRAWAVE_COLLISION_SHIFT = 26;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_LOAD_INTRAWAVE_COLLISION_MASK  = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MSB_SHIFT            = 27;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MSB_MASK             = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SHARED_VGPR_CNT_SHIFT          = 28;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SHARED_VGPR_CNT_MASK           = 0xF;
 
 constexpr uint32_t SPI_SHADER_USER_DATA_PS_0  = 0xC;
 constexpr uint32_t SPI_SHADER_USER_DATA_PS_15 = 0x1B;
 constexpr uint32_t SPI_SHADER_USER_DATA_PS_31 = 0x2B;
+constexpr uint32_t SPI_SHADER_REQ_CTRL_PS     = 0x30;
 constexpr uint32_t SPI_SHADER_USER_ACCUM_PS_0 = 0x32;
 constexpr uint32_t SPI_SHADER_USER_ACCUM_PS_3 = 0x35;
 
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_VGPRS_SHIFT           = 0;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_VGPRS_MASK            = 0x3F;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_SGPRS_SHIFT           = 6;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_SGPRS_MASK            = 0xF;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_PRIORITY_SHIFT        = 10;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_PRIORITY_MASK         = 0x3;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_FLOAT_MODE_SHIFT      = 12;
@@ -776,20 +835,19 @@ constexpr uint32_t SPI_SHADER_PGM_RSRC2_VS_USER_SGPR_MSB_MASK    = 0x1;
 constexpr uint32_t SPI_SHADER_PGM_RSRC2_VS_SHARED_VGPR_CNT_SHIFT = 28;
 constexpr uint32_t SPI_SHADER_PGM_RSRC2_VS_SHARED_VGPR_CNT_MASK  = 0xF;
 
-constexpr uint32_t SPI_SHADER_PACE_ID_GS           = 0x80;
-// AGC compiler records use this numeric tag as opaque metadata. It is not a shader checksum
-// register and intentionally has no checksum-state consumer in HardwareContext.
-constexpr uint32_t SPI_SHADER_PGM_CHKSUM_GS        = SPI_SHADER_PACE_ID_GS;
+constexpr uint32_t SPI_SHADER_PGM_CHKSUM_GS        = 0x80;
 constexpr uint32_t SPI_SHADER_PGM_RSRC4_GS         = 0x81;
 constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_LO_GS = 0x82;
 constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_HI_GS = 0x83;
-constexpr uint32_t SPI_GRAPHICS_SHADER_CONTROL_GS  = 0x87;
+constexpr uint32_t SPI_SHADER_PGM_RSRC3_GS         = 0x87;
 constexpr uint32_t SPI_SHADER_PGM_LO_GS            = 0x88;
 constexpr uint32_t SPI_SHADER_PGM_HI_GS            = 0x89;
 
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS                        = 0x8A;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_VGPRS_SHIFT            = 0;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_VGPRS_MASK             = 0x3F;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_SGPRS_SHIFT            = 6;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_SGPRS_MASK             = 0xF;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_PRIORITY_SHIFT         = 10;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_PRIORITY_MASK          = 0x3;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_FLOAT_MODE_SHIFT       = 12;
@@ -827,98 +885,61 @@ constexpr uint32_t SPI_SHADER_PGM_RSRC2_GS_USER_SGPR_MSB_MASK     = 0x1;
 constexpr uint32_t SPI_SHADER_PGM_RSRC2_GS_SHARED_VGPR_CNT_SHIFT  = 28;
 constexpr uint32_t SPI_SHADER_PGM_RSRC2_GS_SHARED_VGPR_CNT_MASK   = 0xF;
 
-constexpr uint32_t SPI_SHADER_USER_DATA_GS_0                      = 0x8C;
-constexpr uint32_t SPI_SHADER_USER_DATA_GS_15                     = 0x9B;
-constexpr uint32_t SPI_SHADER_USER_DATA_GS_31                     = 0xAB;
-constexpr uint32_t SPI_SHADER_USER_ACCUM_ESGS_0                   = 0xB2;
-constexpr uint32_t SPI_SHADER_USER_ACCUM_ESGS_3                   = 0xB5;
-constexpr uint32_t SPI_SHADER_PGM_LO_ES                           = 0xC8;
-constexpr uint32_t SPI_SHADER_PGM_HI_ES                           = 0xC9;
-// Private AGC registers used by shader binaries submitted through SET_SH_REG_INDIRECT.
-constexpr uint32_t SPI_SHADER_PGM_CHKSUM_HS                       = 0x100;
-constexpr uint32_t SPI_SHADER_PGM_RSRC4_HS                        = 0x101;
-constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_LO_HS                = 0x102;
-constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_HI_HS                = 0x103;
-constexpr uint32_t SPI_GRAPHICS_SHADER_CONTROL_HS                 = 0x107;
-constexpr uint32_t SPI_SHADER_PGM_LO_HS                           = 0x108;
-constexpr uint32_t SPI_SHADER_PGM_HI_HS                           = 0x109;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS                        = 0x10A;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS                        = 0x10B;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_VGPRS_SHIFT            = 0;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_VGPRS_MASK             = 0x3F;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_PRIORITY_SHIFT         = 10;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_PRIORITY_MASK          = 0x3;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FLOAT_MODE_SHIFT       = 12;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FLOAT_MODE_MASK        = 0xFF;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_DX10_CLAMP_SHIFT       = 21;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_DX10_CLAMP_MASK        = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_DEBUG_MODE_SHIFT       = 22;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_DEBUG_MODE_MASK        = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_IEEE_MODE_SHIFT        = 23;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_IEEE_MODE_MASK         = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FWD_PROGRESS_SHIFT     = 25;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FWD_PROGRESS_MASK      = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_WGP_MODE_SHIFT         = 26;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_WGP_MODE_MASK          = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_LS_VGPR_COMP_CNT_SHIFT = 28;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_LS_VGPR_COMP_CNT_MASK  = 0x3;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FP16_OVFL_SHIFT        = 30;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FP16_OVFL_MASK         = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_SCRATCH_EN_SHIFT       = 0;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_SCRATCH_EN_MASK        = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_USER_SGPR_SHIFT        = 1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_USER_SGPR_MASK         = 0x1F;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_LDS_SIZE_SHIFT         = 18;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_LDS_SIZE_MASK          = 0x1FF;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_USER_SGPR_MSB_SHIFT    = 27;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_USER_SGPR_MSB_MASK     = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_SHARED_VGPR_CNT_SHIFT  = 28;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_SHARED_VGPR_CNT_MASK   = 0xF;
-constexpr uint32_t SPI_SHADER_USER_DATA_HS_0                      = 0x10C;
-constexpr uint32_t SPI_SHADER_USER_DATA_HS_15                     = 0x11B;
-constexpr uint32_t SPI_SHADER_USER_DATA_HS_31                     = 0x12B;
-constexpr uint32_t SPI_SHADER_USER_ACCUM_LSHS_0                   = 0x132;
-constexpr uint32_t SPI_SHADER_USER_ACCUM_LSHS_3                   = 0x135;
-constexpr uint32_t SPI_SHADER_PGM_LO_LS                           = 0x148;
-constexpr uint32_t SPI_SHADER_PGM_HI_LS                           = 0x149;
-constexpr uint32_t COMPUTE_START_X                                = 0x204;
-constexpr uint32_t COMPUTE_START_Y                                = 0x205;
-constexpr uint32_t COMPUTE_START_Z                                = 0x206;
-constexpr uint32_t COMPUTE_NUM_THREAD_X                           = 0x207;
-constexpr uint32_t COMPUTE_NUM_THREAD_Y                           = 0x208;
-constexpr uint32_t COMPUTE_NUM_THREAD_Z                           = 0x209;
-constexpr uint32_t COMPUTE_PGM_LO                                 = 0x20C;
-constexpr uint32_t COMPUTE_PGM_HI                                 = 0x20D;
+constexpr uint32_t SPI_SHADER_USER_DATA_GS_0       = 0x8C;
+constexpr uint32_t SPI_SHADER_USER_DATA_GS_15      = 0x9B;
+constexpr uint32_t SPI_SHADER_USER_DATA_GS_31      = 0xAB;
+constexpr uint32_t SPI_SHADER_REQ_CTRL_ESGS        = 0xB0;
+constexpr uint32_t SPI_SHADER_USER_ACCUM_ESGS_0    = 0xB2;
+constexpr uint32_t SPI_SHADER_USER_ACCUM_ESGS_3    = 0xB5;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_ES_GS      = 0xBC;
+constexpr uint32_t SPI_SHADER_PGM_LO_ES            = 0xC8;
+constexpr uint32_t SPI_SHADER_PGM_HI_ES            = 0xC9;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_ES         = 0xCA;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_ES         = 0xCB;
+constexpr uint32_t SPI_SHADER_USER_DATA_ES_0       = 0xCC;
+constexpr uint32_t SPI_SHADER_USER_DATA_ES_15      = 0xDB;
+constexpr uint32_t SPI_SHADER_USER_DATA_ES_31      = 0xEB;
+constexpr uint32_t SPI_SHADER_PGM_CHKSUM_HS        = 0x100;
+constexpr uint32_t SPI_SHADER_PGM_RSRC4_HS         = 0x101;
+constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_LO_HS = 0x102;
+constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_HI_HS = 0x103;
+constexpr uint32_t SPI_SHADER_PGM_RSRC3_HS         = 0x107;
+constexpr uint32_t SPI_SHADER_PGM_LO_HS            = 0x108;
+constexpr uint32_t SPI_SHADER_PGM_HI_HS            = 0x109;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS         = 0x10A;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS         = 0x10B;
+constexpr uint32_t SPI_SHADER_USER_DATA_HS_0       = 0x10C;
+constexpr uint32_t SPI_SHADER_USER_DATA_HS_15      = 0x11B;
+constexpr uint32_t SPI_SHADER_USER_DATA_HS_31      = 0x12B;
+constexpr uint32_t SPI_SHADER_REQ_CTRL_LSHS        = 0x130;
+constexpr uint32_t SPI_SHADER_USER_ACCUM_LSHS_0    = 0x132;
+constexpr uint32_t SPI_SHADER_USER_ACCUM_LSHS_3    = 0x135;
+constexpr uint32_t SPI_SHADER_PGM_LO_LS            = 0x148;
+constexpr uint32_t SPI_SHADER_PGM_HI_LS            = 0x149;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_LS         = 0x14A;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_LS         = 0x14B;
+constexpr uint32_t COMPUTE_START_X                 = 0x204;
+constexpr uint32_t COMPUTE_START_Y                 = 0x205;
+constexpr uint32_t COMPUTE_START_Z                 = 0x206;
+constexpr uint32_t COMPUTE_NUM_THREAD_X            = 0x207;
+constexpr uint32_t COMPUTE_NUM_THREAD_Y            = 0x208;
+constexpr uint32_t COMPUTE_NUM_THREAD_Z            = 0x209;
+constexpr uint32_t COMPUTE_PGM_LO                  = 0x20C;
+constexpr uint32_t COMPUTE_PGM_HI                  = 0x20D;
+constexpr uint32_t COMPUTE_TBA_LO                  = 0x20E;
+constexpr uint32_t COMPUTE_TBA_HI                  = 0x20F;
+constexpr uint32_t COMPUTE_TMA_LO                  = 0x210;
+constexpr uint32_t COMPUTE_TMA_HI                  = 0x211;
 
-constexpr uint32_t COMPUTE_PGM_RSRC1                  = 0x212;
-constexpr uint32_t COMPUTE_PGM_RSRC1_VGPRS_SHIFT      = 0;
-constexpr uint32_t COMPUTE_PGM_RSRC1_VGPRS_MASK       = 0x3F;
-constexpr uint32_t COMPUTE_PGM_RSRC1_PRIORITY_SHIFT   = 10;
-constexpr uint32_t COMPUTE_PGM_RSRC1_PRIORITY_MASK    = 0x3;
-constexpr uint32_t COMPUTE_PGM_RSRC1_FLOAT_MODE_SHIFT = 12;
-constexpr uint32_t COMPUTE_PGM_RSRC1_FLOAT_MODE_MASK  = 0xFF;
-constexpr uint32_t COMPUTE_PGM_RSRC1_DX10_CLAMP_SHIFT = 21;
-constexpr uint32_t COMPUTE_PGM_RSRC1_DX10_CLAMP_MASK  = 0x1;
-constexpr uint32_t COMPUTE_PGM_RSRC1_DEBUG_MODE_SHIFT = 22;
-constexpr uint32_t COMPUTE_PGM_RSRC1_DEBUG_MODE_MASK  = 0x1;
-constexpr uint32_t COMPUTE_PGM_RSRC1_IEEE_MODE_SHIFT  = 23;
-constexpr uint32_t COMPUTE_PGM_RSRC1_IEEE_MODE_MASK   = 0x1;
-constexpr uint32_t COMPUTE_PGM_RSRC1_FP16_OVFL_SHIFT  = 26;
-constexpr uint32_t COMPUTE_PGM_RSRC1_FP16_OVFL_MASK   = 0x1;
-constexpr uint32_t COMPUTE_PGM_RSRC1_WGP_MODE_SHIFT   = 29;
-constexpr uint32_t COMPUTE_PGM_RSRC1_WGP_MODE_MASK    = 0x1;
-constexpr uint32_t COMPUTE_PGM_RSRC1_FWD_PROGRESS_SHIFT = 31;
-constexpr uint32_t COMPUTE_PGM_RSRC1_FWD_PROGRESS_MASK  = 0x1;
-
-constexpr uint32_t COMPUTE_DISPATCH_INITIATOR_CS_W32_EN_SHIFT = 15;
-constexpr uint32_t COMPUTE_DISPATCH_INITIATOR_CS_W32_EN_MASK  = 0x1;
-
-[[nodiscard]] constexpr uint8_t ComputeWaveSize(uint32_t dispatch_initiator) {
-	return ((dispatch_initiator >> COMPUTE_DISPATCH_INITIATOR_CS_W32_EN_SHIFT) &
-	        COMPUTE_DISPATCH_INITIATOR_CS_W32_EN_MASK) != 0u
-	           ? 32u
-	           : 64u;
-}
+constexpr uint32_t COMPUTE_PGM_RSRC1              = 0x212;
+constexpr uint32_t COMPUTE_PGM_RSRC1_VGPRS_SHIFT  = 0;
+constexpr uint32_t COMPUTE_PGM_RSRC1_VGPRS_MASK   = 0x3F;
+constexpr uint32_t COMPUTE_PGM_RSRC1_SGPRS_SHIFT  = 6;
+constexpr uint32_t COMPUTE_PGM_RSRC1_SGPRS_MASK   = 0xF;
+constexpr uint32_t COMPUTE_PGM_RSRC1_BULKY_SHIFT  = 24;
+constexpr uint32_t COMPUTE_PGM_RSRC1_BULKY_MASK   = 0x1;
+constexpr uint32_t COMPUTE_PGM_RSRC1_W32_EN_SHIFT = 30;
+constexpr uint32_t COMPUTE_PGM_RSRC1_W32_EN_MASK  = 0x1;
 
 constexpr uint32_t COMPUTE_PGM_RSRC2                      = 0x213;
 constexpr uint32_t COMPUTE_PGM_RSRC2_SCRATCH_EN_SHIFT     = 0;
@@ -939,16 +960,21 @@ constexpr uint32_t COMPUTE_PGM_RSRC2_LDS_SIZE_SHIFT       = 15;
 constexpr uint32_t COMPUTE_PGM_RSRC2_LDS_SIZE_MASK        = 0x1FF;
 
 constexpr uint32_t COMPUTE_RESOURCE_LIMITS    = 0x215;
+constexpr uint32_t COMPUTE_DESTINATION_EN_SE0 = 0x216;
+constexpr uint32_t COMPUTE_DESTINATION_EN_SE1 = 0x217;
 constexpr uint32_t COMPUTE_TMPRING_SIZE       = 0x218;
+constexpr uint32_t COMPUTE_DESTINATION_EN_SE2 = 0x219;
+constexpr uint32_t COMPUTE_DESTINATION_EN_SE3 = 0x21A;
 constexpr uint32_t COMPUTE_USER_ACCUM_0       = 0x224;
 constexpr uint32_t COMPUTE_PGM_RSRC3          = 0x228;
-constexpr uint32_t COMPUTE_PGM_RSRC3_SHARED_VGPRS_SHIFT = 0;
-constexpr uint32_t COMPUTE_PGM_RSRC3_SHARED_VGPRS_MASK  = 0xF;
-constexpr uint32_t COMPUTE_PACE_ID             = 0x22A;
+constexpr uint32_t COMPUTE_SHADER_CHKSUM      = 0x22A;
 constexpr uint32_t COMPUTE_USER_DATA_0        = 0x240;
 constexpr uint32_t COMPUTE_USER_DATA_15       = 0x24F;
+constexpr uint32_t COMPUTE_DISPATCH_TUNNEL    = 0x27D;
 
-constexpr uint32_t SH_NOP = 0x280;
+/* Fake codes. Don't exist on real HW */
+
+constexpr uint32_t SH_NOP = 0x800002FF;
 
 constexpr uint32_t SH_NUM = 0x2FF + 1;
 
@@ -965,7 +991,6 @@ constexpr uint32_t GE_INDX_OFFSET            = 0x24A;
 constexpr uint32_t GE_MULTI_PRIM_IB_RESET_EN = 0x24B;
 constexpr uint32_t VGT_HS_OFFCHIP_PARAM      = 0x24F;
 constexpr uint32_t VGT_TF_MEMORY_BASE        = 0x250;
-constexpr uint32_t IA_MULTI_VGT_PARAM        = 0x258;
 
 constexpr uint32_t GE_CNTL                     = 0x25B;
 constexpr uint32_t GE_CNTL_PRIM_GRP_SIZE_SHIFT = 0;
@@ -977,7 +1002,6 @@ constexpr uint32_t GE_USER_VGPR1  = 0x25C;
 constexpr uint32_t GE_USER_VGPR2  = 0x25D;
 constexpr uint32_t GE_USER_VGPR3  = 0x25E;
 constexpr uint32_t GE_STEREO_CNTL = 0x25F;
-constexpr uint32_t UC_PARAMETER_OVERSUBSCRIPTION = 0x260;
 
 constexpr uint32_t GE_USER_VGPR_EN                     = 0x262;
 constexpr uint32_t GE_USER_VGPR_EN_EN_USER_VGPR1_SHIFT = 0;
@@ -987,19 +1011,32 @@ constexpr uint32_t GE_USER_VGPR_EN_EN_USER_VGPR2_MASK  = 0x1;
 constexpr uint32_t GE_USER_VGPR_EN_EN_USER_VGPR3_SHIFT = 2;
 constexpr uint32_t GE_USER_VGPR_EN_EN_USER_VGPR3_MASK  = 0x1;
 
+constexpr uint32_t IA_MULTI_VGT_PARAM       = 0x258;
 constexpr uint32_t TA_CS_BC_BASE_ADDR       = 0x380;
 constexpr uint32_t TA_CS_BC_BASE_ADDR_HI    = 0x381;
-constexpr uint32_t TEXTURE_GRADIENT_FACTORS = 0x383;
-constexpr uint32_t TEXTURE_GRADIENT_CONTROL = 0x384;
+constexpr uint32_t TEXTURE_GRADIENT_FACTORS = 0x382;
 constexpr uint32_t GDS_OA_CNTL              = 0x41D;
 constexpr uint32_t GDS_OA_COUNTER           = 0x41E;
 constexpr uint32_t GDS_OA_ADDRESS           = 0x41F;
 
-constexpr uint32_t UC_NOP = 0xA2;
+/* Fake codes. Don't exist on real HW */
+
+constexpr uint32_t FSR_EXTEND_SUBPIXEL_ROUNDING = 0x80003FF4;
+constexpr uint32_t FSR_ALPHA_VALUE0             = 0x80003FF5;
+constexpr uint32_t FSR_ALPHA_VALUE1             = 0x80003FF6;
+constexpr uint32_t FSR_CONTROL_POINT0           = 0x80003FF7;
+constexpr uint32_t FSR_CONTROL_POINT1           = 0x80003FF8;
+constexpr uint32_t FSR_CONTROL_POINT2           = 0x80003FF9;
+constexpr uint32_t FSR_CONTROL_POINT3           = 0x80003FFA;
+constexpr uint32_t FSR_WINDOW0                  = 0x80003FFB;
+constexpr uint32_t FSR_WINDOW1                  = 0x80003FFC;
+constexpr uint32_t TEXTURE_GRADIENT_CONTROL     = 0x80003FFD;
+constexpr uint32_t MEMORY_MAPPING_MASK          = 0x80003FFE;
+constexpr uint32_t UC_NOP                       = 0x80003FFF;
 
 constexpr uint32_t UC_NUM = 0x3FFF + 1;
 
-void DumpPm4PacketStream(Common::File* file, const uint32_t* cmd_buffer, uint32_t start_dw,
+void DumpPm4PacketStream(Common::File* file, uint32_t* cmd_buffer, uint32_t start_dw,
                          uint32_t num_dw);
 
 } // namespace Libs::Graphics::Pm4

src/graphics/guest_gpu/tile.h

@@ -3,7 +3,6 @@
 
 #include "common/abi.h"
 #include "common/common.h"
-#include "graphics/guest_gpu/gpu_defs.h"
 
 namespace Libs::Graphics {
 
@@ -40,7 +39,7 @@ enum class TileBlockFamily : uint32_t {
 };
 
 struct TileBlockLayout {
-	TileBlockFamily family            = TileBlockFamily::Count;
+	TileBlockFamily family            = TileBlockFamily::Standard256B;
 	uint32_t        bytes_per_element = 0;
 	uint32_t        block_size        = 0;
 	uint32_t        block_width       = 0;
@@ -48,73 +47,42 @@ struct TileBlockLayout {
 	uint32_t        block_depth       = 0;
 };
 
-struct TileTextureElementLayout {
-	uint32_t bytes        = 0;
-	uint32_t texel_width  = 1;
-	uint32_t texel_height = 1;
-};
-
-struct TileTextureBlockLayout {
-	TileBlockLayout block;
-	uint32_t        texel_width  = 1;
-	uint32_t        texel_height = 1;
-};
-
-enum class TileSurfaceDimension : uint32_t {
-	Dim2D,
-	Dim3D,
-};
-
-struct TileSurfaceDescription {
-	Prospero::BufferFormat format    = Prospero::BufferFormat::kInvalid;
-	Prospero::TileMode     tile_mode = Prospero::TileMode::kLinear;
-	TileSurfaceDimension   dimension = TileSurfaceDimension::Dim2D;
-	uint32_t               width     = 0;
-	uint32_t               height    = 0;
-	uint32_t               depth     = 1;
-	uint32_t               levels    = 1;
-	uint32_t               layers    = 1;
-};
-
-// Width/height fields are measured in addressable elements, not texture texels.
-struct TileMipLayout {
-	uint64_t offset        = 0;
-	uint64_t size          = 0;
-	uint32_t width         = 0;
-	uint32_t height        = 0;
-	uint32_t padded_width  = 0;
-	uint32_t padded_height = 0;
-	uint32_t tail_x        = 0;
-	uint32_t tail_y        = 0;
-};
-
-struct TileSurfaceLayout {
-	TileSurfaceDescription description;
-	TileTextureBlockLayout texture;
-	uint32_t               first_tail_level = 0;
-	uint64_t               block_slice_size = 0;
-	uint64_t               total_size       = 0;
-	TileMipLayout          mips[16]         = {};
+struct TileVolumeLayout {
+	TileBlockFamily family            = TileBlockFamily::Count;
+	uint32_t        bytes_per_element = 0;
+	uint32_t        texel_width       = 1;
+	uint32_t        texel_height      = 1;
+	uint32_t        first_tail_level  = 0;
+	uint32_t        block_depth       = 1;
+	uint64_t        block_slice_size  = 0;
+	uint64_t        total_size        = 0;
+	uint64_t        level_offsets[16] = {};
+	uint64_t        level_sizes[16]   = {};
+	uint32_t        tail_x[16]        = {};
+	uint32_t        tail_y[16]        = {};
+	uint32_t        level_widths[16]  = {};
+	uint32_t        level_heights[16] = {};
 };
 
 bool TileGetBlockLayout(TileBlockFamily family, uint32_t bytes_per_element,
                         TileBlockLayout& layout);
-bool TileGetTextureElementLayout(Prospero::BufferFormat format, TileTextureElementLayout& layout);
-bool TileGetTextureBlockLayout(Prospero::BufferFormat format, Prospero::TileMode tile, bool volume,
-                               TileTextureBlockLayout& layout);
-bool TileGetTiledTextureLayout(const TileSurfaceDescription& description,
-                               TileSurfaceLayout&            layout);
 bool TileGetBlockOffset(const TileBlockLayout& layout, uint32_t x, uint32_t y, uint32_t z,
                         uint32_t& byte_offset);
 bool TileGetBlockXor(const TileBlockLayout& layout, uint32_t block_x, uint32_t block_y,
                      uint32_t& byte_offset);
 bool TileGetBlockXor(const TileBlockLayout& layout, uint32_t block_x, uint32_t block_y,
                      uint32_t block_z, uint32_t& byte_offset);
+bool TileIsStandard256BTextureSupported(uint32_t format);
+bool TileIsStandard4KBTextureSupported(uint32_t format);
+bool TileIsStandard64KBTextureSupported(uint32_t format);
+bool TileGetTextureVolumeLayout(uint32_t format, uint32_t width, uint32_t height, uint32_t depth,
+                                uint32_t levels, uint32_t tile, TileVolumeLayout& layout);
 
-bool     TileGetDepthSize(uint32_t width, uint32_t height, uint32_t pitch,
-                          Prospero::DepthFormat z_format, Prospero::StencilFormat stencil_format,
-                          bool htile, TileSizeAlign& stencil_size, TileSizeAlign& htile_size,
-                          TileSizeAlign& depth_size, uint32_t num_fragments_log2 = 0);
+bool     TileGetHtileSize(uint32_t width, uint32_t height, TileSizeAlign& htile_size);
+bool     TileGetDepthSize(uint32_t width, uint32_t height, uint32_t pitch, uint32_t z_format,
+                          uint32_t stencil_format, bool htile, TileSizeAlign& stencil_size,
+                          TileSizeAlign& htile_size, TileSizeAlign& depth_size,
+                          uint32_t num_fragments_log2 = 0);
 uint32_t TileGetRenderTargetPitch(uint32_t width, uint32_t bytes_per_element,
                                   uint32_t num_fragments_log2 = 0);
 uint32_t TileGetDepthPitch(uint32_t width, uint32_t bytes_per_element,
@@ -126,14 +94,13 @@ bool     TileGetRenderTargetMipLayout(uint32_t width, uint32_t height, uint32_t
                                       uint32_t bytes_per_element, uint32_t levels,
                                       TileSizeAlign& total_size, TileSizeOffset* level_sizes,
                                       TilePaddedSize* padded_size);
-void     TileGetTextureSize(Prospero::BufferFormat format, uint32_t width, uint32_t height,
-                            uint32_t levels, Prospero::TileMode tile, TileSizeAlign* total_size,
+void     TileGetTextureSize(uint32_t format, uint32_t width, uint32_t height, uint32_t pitch,
+                            uint32_t levels, uint32_t tile, TileSizeAlign* total_size,
                             TileSizeOffset* level_sizes, TilePaddedSize* padded_size);
-void     TileGetTextureTotalSize(Prospero::BufferFormat format, uint32_t width, uint32_t height,
-                                 uint32_t depth, uint32_t levels, Prospero::TileMode tile,
-                                 bool volume_texture, TileSizeAlign& total_size);
-uint32_t TileGetTexturePitch(Prospero::BufferFormat format, uint32_t width,
-                             Prospero::TileMode tile);
+void TileGetTextureTotalSize(uint32_t format, uint32_t width, uint32_t height, uint32_t depth,
+                             uint32_t pitch, uint32_t levels, uint32_t tile, bool volume_texture,
+                             TileSizeAlign& total_size);
+uint32_t TileGetTexturePitch(uint32_t format, uint32_t width, uint32_t levels, uint32_t tile);
 
 } // namespace Libs::Graphics
 

src/graphics/host_gpu/graphicContext.h

@@ -3,88 +3,20 @@
 
 #include "common/abi.h"
 #include "common/common.h"
-#include "common/threads.h"
 #include "graphics/host_gpu/vulkanCommon.h" // IWYU pragma: export
+#include "graphics/host_gpu/vulkanInstance.h"
 
-#include <map>
-#include <mutex>
-#include <tuple>
 #include <vector>
 #include <vk_mem_alloc.h>
 
 namespace Libs::Graphics {
 
+class CommandBuffer;
 struct VulkanBuffer;
 struct VulkanImage;
 struct VulkanMemory;
 
-inline constexpr uint32_t VULKAN_TARGET_API_VERSION = VK_API_VERSION_1_3;
-
-struct GraphicContext {
-	vk::Instance                       instance                              = nullptr;
-	vk::DebugUtilsMessengerEXT         debug_messenger                       = nullptr;
-	vk::PhysicalDevice                 physical_device                       = nullptr;
-	vk::PhysicalDeviceProperties       physical_device_properties            = {};
-	vk::PhysicalDeviceMemoryProperties physical_device_memory_properties     = {};
-	vk::Device                         device                                = nullptr;
-	VmaAllocator                       allocator                             = nullptr;
-	bool                               memory_budget_ext_enabled             = false;
-	bool                               rt_extensions_enabled                 = false;
-	bool                               compute_subgroup_size_control_enabled = false;
-	bool                               compute_wave64_supported              = false;
-	bool                               sample_rate_shading_enabled           = false;
-	uint32_t                           subgroup_size                         = 0;
-	uint32_t                           min_subgroup_size                     = 0;
-	uint32_t                           max_subgroup_size                     = 0;
-	uint32_t                           max_push_descriptors                  = 0;
-	vk::ShaderStageFlags               required_subgroup_size_stages         = {};
-	Common::Mutex                      queue_mutex;
-	uint32_t                           queue_family = static_cast<uint32_t>(-1);
-	vk::Queue                          queue        = nullptr;
-
-	[[nodiscard]] const vk::PhysicalDeviceProperties& GetPhysicalDeviceProperties() const {
-		return physical_device_properties;
-	}
-
-	[[nodiscard]] const vk::PhysicalDeviceMemoryProperties&
-	GetPhysicalDeviceMemoryProperties() const {
-		return physical_device_memory_properties;
-	}
-
-	[[nodiscard]] vk::FormatProperties GetFormatProperties(vk::Format format) const {
-		std::scoped_lock lock(m_format_properties_mutex);
-		auto [it, inserted] = m_format_properties.try_emplace(format);
-		if (inserted) {
-			physical_device.getFormatProperties(format, &it->second);
-		}
-		return it->second;
-	}
-
-	[[nodiscard]] vk::Result GetImageFormatProperties(vk::Format format, vk::ImageType type,
-	                                                  vk::ImageTiling            tiling,
-	                                                  vk::ImageUsageFlags        usage,
-	                                                  vk::ImageCreateFlags       flags,
-	                                                  vk::ImageFormatProperties* properties) const {
-		using Key = std::tuple<vk::Format, vk::ImageType, vk::ImageTiling, vk::ImageUsageFlags,
-		                       vk::ImageCreateFlags>;
-		std::scoped_lock lock(m_image_format_properties_mutex);
-		auto [it, inserted] =
-		    m_image_format_properties.try_emplace(Key {format, type, tiling, usage, flags});
-		if (inserted) {
-			it->second.first = physical_device.getImageFormatProperties(format, type, tiling, usage,
-			                                                            flags, &it->second.second);
-		}
-		if (properties != nullptr) {
-			*properties = it->second.second;
-		}
-		return it->second.first;
-	}
-
-	[[nodiscard]] vk::DeviceSize StorageMinAlignment() const {
-		const auto alignment = physical_device_properties.limits.minStorageBufferOffsetAlignment;
-		return alignment != 0 ? alignment : 1;
-	}
-
+struct GraphicContext: public VulkanInstance {
 	[[nodiscard]] bool CreateAllocator();
 	void               DestroyAllocator();
 	void               LogMemoryBudget() const;
@@ -92,6 +24,7 @@ struct GraphicContext {
 	[[nodiscard]] uint64_t GetDeviceMemoryUsage() const;
 	[[nodiscard]] uint64_t GetTotalMemoryBudget() const;
 	void                   CreateBuffer(uint64_t size, VulkanBuffer& buffer);
+	void                   DeleteBuffer(VulkanBuffer& buffer);
 	[[nodiscard]] bool     CreateImage(const vk::ImageCreateInfo& info, VulkanImage& image);
 	void                   DeleteImage(VulkanImage& image);
 	void                   MapMemory(VulkanMemory& memory, void*& data);
@@ -103,15 +36,6 @@ struct GraphicContext {
 
 	uint32_t screen_width  = 0;
 	uint32_t screen_height = 0;
-
-private:
-	mutable std::mutex                                 m_format_properties_mutex;
-	mutable std::map<vk::Format, vk::FormatProperties> m_format_properties;
-	mutable std::mutex                                 m_image_format_properties_mutex;
-	mutable std::map<std::tuple<vk::Format, vk::ImageType, vk::ImageTiling, vk::ImageUsageFlags,
-	                            vk::ImageCreateFlags>,
-	                 std::pair<vk::Result, vk::ImageFormatProperties>>
-	    m_image_format_properties;
 };
 
 struct VulkanMemory {

src/graphics/host_gpu/memoryTracker.cpp

@@ -6,7 +6,13 @@ namespace Libs::Graphics {
 
 static_assert(std::atomic<void*>::is_always_lock_free);
 
-MemoryTracker::MemoryTracker(PageManager& page_manager): m_page_manager(page_manager) {
+MemoryTracker::MemoryTracker(PageManager& page_manager, PageWatchMode gpu_watch_mode)
+    : m_page_manager(page_manager), m_gpu_watch_mode(gpu_watch_mode) {
+	switch (m_gpu_watch_mode) {
+		case PageWatchMode::Write:
+		case PageWatchMode::ReadWrite: break;
+		default: EXIT("unsupported memory tracker GPU page-watch mode\n");
+	}
 	m_regions = std::make_unique<std::atomic<RegionManager*>[]>(REGION_COUNT);
 	for (size_t i = 0; i < REGION_COUNT; i++) {
 		m_regions[i].store(nullptr, std::memory_order_relaxed);
@@ -15,11 +21,10 @@ MemoryTracker::MemoryTracker(PageManager& page_manager): m_page_manager(page_man
 
 MemoryTracker::~MemoryTracker() = default;
 
-#if KYTY_BUILD == KYTY_BUILD_DEBUG
 void MemoryTracker::ValidateGpuDirtyPages(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
                                           const char* operation) const noexcept {
-	if (!GuestRange {vaddr, size}.Valid() || (vaddr & (TRACKER_PAGE_SIZE - 1)) != 0 ||
-	    (size & (TRACKER_PAGE_SIZE - 1)) != 0) {
+	if (vaddr == 0 || size == 0 || size > UINT64_MAX - vaddr ||
+	    (vaddr & (TRACKER_PAGE_SIZE - 1)) != 0 || (size & (TRACKER_PAGE_SIZE - 1)) != 0) {
 		EXIT("MemoryTracker: invalid dirty-page validation range\n");
 	}
 	for (auto page = vaddr; page < vaddr + size; page += TRACKER_PAGE_SIZE) {
@@ -37,6 +42,9 @@ void MemoryTracker::ValidateGpuDirtyPages(const RangeSet& dirty, uint64_t vaddr,
 void MemoryTracker::ValidateGpuDirtyOwnership(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
                                               const char* operation) {
 	ValidateRange(vaddr, size);
+	if (vaddr + size > UINT64_MAX - (TRACKER_PAGE_SIZE - 1)) {
+		EXIT("MemoryTracker: dirty ownership range alignment overflow\n");
+	}
 	const auto begin = vaddr & ~(TRACKER_PAGE_SIZE - 1);
 	const auto end   = (vaddr + size + TRACKER_PAGE_SIZE - 1) & ~(TRACKER_PAGE_SIZE - 1);
 	for (auto page = begin; page < end; page += TRACKER_PAGE_SIZE) {
@@ -50,10 +58,10 @@ void MemoryTracker::ValidateGpuDirtyOwnership(const RangeSet& dirty, uint64_t va
 		}
 	}
 }
-#endif
 
 void MemoryTracker::ValidateRange(uint64_t vaddr, uint64_t size) {
-	if (!GuestRange {vaddr, size}.Valid()) {
+	if (vaddr == 0 || size == 0 || vaddr >= TRACKER_ADDRESS_SIZE ||
+	    size > TRACKER_ADDRESS_SIZE - vaddr) {
 		EXIT("invalid memory tracker range\n");
 	}
 }
@@ -75,6 +83,7 @@ RegionManager* MemoryTracker::GetOrCreateRegion(uint64_t index) {
 
 bool MemoryTracker::IsRegionCpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
+	std::lock_guard access(m_access_mutex);
 	return Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
 		return manager->IsModified<DirtySource::Cpu>(offset, bytes);
@@ -83,6 +92,7 @@ bool MemoryTracker::IsRegionCpuModified(uint64_t vaddr, uint64_t size) {
 
 bool MemoryTracker::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
+	std::lock_guard access(m_access_mutex);
 	return Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
 		return manager->IsModified<DirtySource::Gpu>(offset, bytes);
@@ -91,29 +101,41 @@ bool MemoryTracker::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
 
 void MemoryTracker::MarkRegionAsCpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
+	std::lock_guard access(m_access_mutex);
 	Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
-		manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
+		const auto       changed =
+		    manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
+		manager->ApplyProtection(changed, false);
 	});
 }
 
 void MemoryTracker::MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
-	Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+	std::lock_guard access(m_access_mutex);
+	Iterate<true>(vaddr, size, [this](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
-		manager->ChangeState<DirtySource::Gpu, true>(manager->GetCpuAddr() + offset, bytes);
+		const auto       changed =
+		    manager->ChangeState<DirtySource::Gpu, true>(manager->GetCpuAddr() + offset, bytes);
+		manager->ApplyGpuProtection(changed, true, m_gpu_watch_mode);
 	});
 }
 
 void MemoryTracker::UnmarkRegionAsGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
-	Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+	std::lock_guard access(m_access_mutex);
+	Iterate<true>(vaddr, size, [this](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
-		manager->ChangeState<DirtySource::Gpu, false>(manager->GetCpuAddr() + offset, bytes);
+		if (!manager->IsFullyModified<DirtySource::Gpu>(offset, bytes)) {
+			EXIT("cannot clear partially GPU-dirty tracking range\n");
+		}
+		const auto changed =
+		    manager->ChangeState<DirtySource::Gpu, false>(manager->GetCpuAddr() + offset, bytes);
+		manager->ApplyGpuProtection(changed, false, m_gpu_watch_mode);
 	});
 }
 
-void MemoryTracker::UntrackMemoryImpl(uint64_t vaddr, uint64_t size) {
+void MemoryTracker::UntrackMemoryLocked(uint64_t vaddr, uint64_t size) {
 	std::vector<RegionManager*> managers;
 	managers.reserve((vaddr % TRACKER_REGION_SIZE + size + TRACKER_REGION_SIZE - 1) /
 	                 TRACKER_REGION_SIZE);
@@ -132,14 +154,17 @@ void MemoryTracker::UntrackMemoryImpl(uint64_t vaddr, uint64_t size) {
 		EXIT("cannot untrack GPU-dirty memory\n");
 	}
 	Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-		manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
+		const auto changed =
+		    manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
+		manager->ApplyProtection(changed, false);
 	});
 	locks.clear();
 }
 
 void MemoryTracker::UntrackMemory(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
-	UntrackMemoryImpl(vaddr, size);
+	std::lock_guard access(m_access_mutex);
+	UntrackMemoryLocked(vaddr, size);
 }
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/memoryTracker.h

@@ -18,7 +18,8 @@ namespace Libs::Graphics {
 
 class MemoryTracker final {
 public:
-	explicit MemoryTracker(PageManager& page_manager);
+	explicit MemoryTracker(PageManager&  page_manager,
+	                       PageWatchMode gpu_watch_mode = PageWatchMode::ReadWrite);
 	~MemoryTracker();
 
 	KYTY_CLASS_NO_COPY(MemoryTracker);
@@ -29,45 +30,58 @@ public:
 	void               MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UnmarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UntrackMemory(uint64_t vaddr, uint64_t size);
-	// Removes protection from a range and flushes GPU-owned data when required.
 	template <typename Flush>
-	void InvalidateRegion(uint64_t vaddr, uint64_t size, Flush&& on_flush) noexcept {
+	void InvalidateRegion(uint64_t vaddr, uint64_t size, Flush&& on_flush) {
 		static_assert(std::is_invocable_v<Flush&>);
 		CheckNotInUploadCallback();
 		ValidateRange(vaddr, size);
 
-		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-			const bool should_flush = [&] {
-				// Perform both the GPU modification check and CPU state change with the lock in
-				// case the GPU thread is racing to mark the page modified. If a flush is needed,
-				// on_flush performs the CPU state change.
-				std::scoped_lock lock(manager->lock);
-				if (manager->IsModified<DirtySource::Gpu>(offset, bytes)) {
-					return true;
-				}
-				manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
-				return false;
-			}();
-			if (should_flush) {
-				on_flush();
+		const auto update_cpu_state = [this, vaddr, size] {
+			std::lock_guard             access(m_access_mutex);
+			std::vector<RegionManager*> managers;
+			Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t, uint64_t) {
+				managers.push_back(manager);
+			});
+			std::vector<std::unique_lock<TrackingSpinLock>> locks;
+			locks.reserve(managers.size());
+			for (auto* manager: managers) {
+				locks.emplace_back(manager->lock);
 			}
-		});
+			const bool gpu_modified = Iterate<false>(
+			    vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+				    return manager->IsModified<DirtySource::Gpu>(offset, bytes);
+			    });
+			if (gpu_modified) {
+				return true;
+			}
+			Iterate<false>(vaddr, size,
+			               [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+				               const auto changed = manager->ChangeState<DirtySource::Cpu, true>(
+				                   manager->GetCpuAddr() + offset, bytes);
+				               manager->ApplyProtection(changed, false);
+			               });
+			return false;
+		};
+
+		if (!update_cpu_state()) {
+			return;
+		}
+		std::forward<Flush>(on_flush)();
+		if (update_cpu_state()) {
+			EXIT("memory invalidation retained GPU-owned pages\n");
+		}
 	}
-#if KYTY_BUILD == KYTY_BUILD_DEBUG
 	void ValidateGpuDirtyPages(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
 	                           const char* operation) const noexcept;
 	void ValidateGpuDirtyOwnership(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
 	                               const char* operation);
-#else
-	void ValidateGpuDirtyPages(const RangeSet&, uint64_t, uint64_t, const char*) const noexcept {}
-	void ValidateGpuDirtyOwnership(const RangeSet&, uint64_t, uint64_t, const char*) {}
-#endif
 
 	template <bool clear, typename Preflight, typename Func>
 	void ForEachDownloadRange(uint64_t vaddr, uint64_t size, Preflight&& preflight, Func&& func) {
 		static_assert(std::is_nothrow_invocable_v<Preflight&, uint64_t, uint64_t>);
 		static_assert(std::is_nothrow_invocable_v<Func&, uint64_t, uint64_t>);
 		CheckNotInUploadCallback();
+		std::lock_guard             access(m_access_mutex);
 		std::vector<RegionManager*> managers;
 		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t, uint64_t) {
 			managers.push_back(manager);
@@ -90,8 +104,10 @@ public:
 			Iterate<false>(vaddr, size,
 			               [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 				               const auto address = manager->GetCpuAddr() + offset;
-				               manager->template ForEachModifiedRange<DirtySource::Gpu, true>(
-				                   address, bytes, [](uint64_t, uint64_t) noexcept {});
+				               const auto changed =
+				                   manager->template ForEachModifiedRange<DirtySource::Gpu, true>(
+				                       address, bytes, [](uint64_t, uint64_t) noexcept {});
+				               manager->ApplyGpuProtection(changed, false, m_gpu_watch_mode);
 			               });
 		}
 	}
@@ -108,6 +124,7 @@ public:
 		static_assert(std::is_nothrow_invocable_v<RangeFunc&, uint64_t, uint64_t>);
 		static_assert(std::is_nothrow_invocable_v<UploadFunc&>);
 		CheckNotInUploadCallback();
+		std::unique_lock access(m_access_mutex);
 		Iterate<true>(vaddr, size, [](RegionManager*, uint64_t, uint64_t) {});
 		const auto* previous_upload_owner = std::exchange(s_upload_owner, this);
 		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
@@ -120,12 +137,13 @@ public:
 		});
 		upload_func();
 		if (is_written) {
-			Iterate<false>(vaddr, size,
-			               [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				               manager->template ChangeState<DirtySource::Gpu, true>(
-				                   manager->GetCpuAddr() + offset, bytes);
-				               manager->lock.unlock();
-			               });
+			Iterate<false>(
+			    vaddr, size, [this](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+				    const auto changed = manager->template ChangeState<DirtySource::Gpu, true>(
+				        manager->GetCpuAddr() + offset, bytes);
+				    manager->ApplyGpuProtection(changed, true, m_gpu_watch_mode);
+				    manager->lock.unlock();
+			    });
 		}
 		s_upload_owner = previous_upload_owner;
 	}
@@ -171,13 +189,15 @@ private:
 	}
 
 	static void    ValidateRange(uint64_t vaddr, uint64_t size);
-	void           UntrackMemoryImpl(uint64_t vaddr, uint64_t size);
+	void           UntrackMemoryLocked(uint64_t vaddr, uint64_t size);
 	RegionManager* GetOrCreateRegion(uint64_t index);
 
 	std::unique_ptr<std::atomic<RegionManager*>[]> m_regions;
 	std::vector<std::unique_ptr<RegionManager>>    m_region_storage;
 	std::mutex                                     m_region_mutex;
+	std::mutex                                     m_access_mutex;
 	PageManager&                                   m_page_manager;
+	PageWatchMode                                  m_gpu_watch_mode = PageWatchMode::ReadWrite;
 };
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/pageManager.cpp

@@ -1,6 +1,5 @@
 #include "graphics/host_gpu/pageManager.h"
 
-#include "common/platform/sysDbg.h"
 #include "graphics/host_gpu/regionDefinitions.h"
 #include "kernel/memory.h"
 
@@ -10,6 +9,7 @@
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
+#include <limits>
 #include <memory>
 #include <mutex>
 #include <vector>
@@ -22,9 +22,13 @@
 #undef min
 #undef max
 #elif defined(__APPLE__)
+#include <pthread.h>
+#include <sys/mman.h>
 #include <unistd.h>
 #else
 #include <execinfo.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
 #include <unistd.h>
 #endif
 
@@ -37,8 +41,9 @@ constexpr uint64_t ADDRESS_SIZE = TRACKER_ADDRESS_SIZE;
 constexpr uint64_t REGION_COUNT = ADDRESS_SIZE / REGION_SIZE;
 
 #if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
-// The tracker reuses Win32 memory-protection tags as internal page-state values.
-// Mirror their canonical numeric values so the shared state-machine logic is identical.
+// The tracker reuses Win32 memory-protection tags as internal page-state values (on
+// Windows they come from <windows.h> and are what VirtualQuery returns). Mirror the
+// canonical Win32 numeric values so the shared state-machine logic is identical.
 constexpr uint32_t PAGE_NOACCESS  = 0x01;
 constexpr uint32_t PAGE_READONLY  = 0x02;
 constexpr uint32_t PAGE_READWRITE = 0x04;
@@ -48,25 +53,27 @@ constexpr uint64_t REGION_PAGES = REGION_SIZE / PAGE_SIZE;
 constexpr uint32_t NO_ACCESS_PROTECTION  = PAGE_NOACCESS;
 constexpr uint32_t READ_ONLY_PROTECTION  = PAGE_READONLY;
 constexpr uint32_t READ_WRITE_PROTECTION = PAGE_READWRITE;
+// Zero is the unknown protection sentinel.
+constexpr uint32_t UNKNOWN_PROTECTION = 0;
 
 [[noreturn]] void FailFast(const char* reason = nullptr) noexcept {
 	std::fputs("PageManager fail-fast: ", stderr);
 	std::fputs(reason != nullptr ? reason : "invalid page state", stderr);
 	std::fputc('\n', stderr);
-#if !defined(__APPLE__)
-	void* frames[16] {};
-	int   frame_count = static_cast<int>(std::size(frames));
-	SysStackWalk(frames, &frame_count);
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	void*      frames[16] {};
+	const auto frame_count =
+	    CaptureStackBackTrace(0, static_cast<DWORD>(std::size(frames)), frames, nullptr);
 	const auto image_base = reinterpret_cast<uintptr_t>(GetModuleHandleW(nullptr));
-	for (int i = 0; i < frame_count; i++) {
+	for (uint16_t i = 0; i < frame_count; i++) {
 		const auto address = reinterpret_cast<uintptr_t>(frames[i]);
-		std::fprintf(stderr, "  frame[%d]=0x%016" PRIxPTR " image_rva=0x%016" PRIxPTR "\n", i,
+		std::fprintf(stderr, "  frame[%u]=0x%016" PRIxPTR " image_rva=0x%016" PRIxPTR "\n", i,
 		             address, address >= image_base ? address - image_base : 0);
 	}
-#else
+#elif !defined(__APPLE__)
+	void*     frames[16] {};
+	const int frame_count = ::backtrace(frames, static_cast<int>(std::size(frames)));
 	::backtrace_symbols_fd(frames, frame_count, STDERR_FILENO);
-#endif
 #endif
 	std::fflush(stderr);
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
@@ -95,6 +102,25 @@ Common::VirtualMemory::Mode ToMemoryMode(uint32_t protection) {
 	}
 }
 
+uint32_t CurrentThread() noexcept {
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	return GetCurrentThreadId();
+#elif defined(__APPLE__)
+	return static_cast<uint32_t>(pthread_mach_thread_np(pthread_self()));
+#elif defined(__linux__)
+	static thread_local const uint32_t tid = [] {
+		const auto raw = static_cast<uint32_t>(::syscall(SYS_gettid));
+		if (raw == 0) {
+			FailFast("gettid returned the reserved zero owner token");
+		}
+		return raw;
+	}();
+	return tid;
+#else
+	FailFast("page tracking thread identity is unsupported on this platform");
+#endif
+}
+
 class SpinGuard final {
 public:
 	explicit SpinGuard(std::atomic_flag& lock): m_lock(lock) {
@@ -110,7 +136,7 @@ private:
 };
 
 void ValidateRange(uint64_t vaddr, uint64_t size) {
-	if (!GuestRange {vaddr, size}.Valid()) {
+	if (vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE || size > ADDRESS_SIZE - vaddr) {
 		Fatal("invalid range vaddr=0x%016" PRIx64 ", size=0x%016" PRIx64, vaddr, size);
 	}
 }
@@ -128,60 +154,40 @@ uint64_t PageEnd(uint64_t vaddr, uint64_t size) {
 
 struct PageManager::Impl {
 	struct PageState {
-		uint8_t write_watchers  : 7 = 0;
-		uint8_t access_watchers : 1 = 0;
-
-		[[nodiscard]] uint32_t Perms() const noexcept {
-			if (access_watchers != 0) {
-				return NO_ACCESS_PROTECTION;
-			}
-			if (write_watchers != 0) {
-				return READ_ONLY_PROTECTION;
-			}
-			return READ_WRITE_PROTECTION;
-		}
-
-		template <int delta, bool is_read>
-		uint32_t AddDelta(uint64_t address) {
-			static_assert(delta >= -1 && delta <= 1);
-			if constexpr (is_read) {
-				if constexpr (delta == 1) {
-					if (access_watchers != 0) {
-						Fatal("read-watcher overflow at 0x%016" PRIx64, address);
-					}
-					return ++access_watchers;
-				} else if constexpr (delta == -1) {
-					if (access_watchers == 0) {
-						Fatal("read-watcher underflow at 0x%016" PRIx64, address);
-					}
-					return --access_watchers;
-				} else {
-					return access_watchers;
-				}
-			} else {
-				if constexpr (delta == 1) {
-					if (write_watchers == 0x7f) {
-						Fatal("write-watcher overflow at 0x%016" PRIx64, address);
-					}
-					return ++write_watchers;
-				} else if constexpr (delta == -1) {
-					if (write_watchers == 0) {
-						Fatal("write-watcher underflow at 0x%016" PRIx64, address);
-					}
-					return --write_watchers;
-				} else {
-					return write_watchers;
-				}
-			}
-		}
+		std::atomic_flag lock                = ATOMIC_FLAG_INIT;
+		uint32_t         write_watchers      = 0;
+		uint32_t         access_watchers     = 0;
+		uint32_t         original_protection = 0;
+		uint32_t         backing_writer      = 0;
+		// Shadow the protection applied through Protect().
+		uint32_t current_protection = UNKNOWN_PROTECTION;
+		bool     resolving          = false;
 	};
-	static_assert(sizeof(PageState) == 1);
 
 	struct Region {
-		std::atomic_flag                    lock = ATOMIC_FLAG_INIT;
 		std::array<PageState, REGION_PAGES> pages;
 	};
 
+	class PageRangeGuard final {
+	public:
+		explicit PageRangeGuard(std::span<PageState*> pages): m_pages(pages) {
+			for (auto* page: m_pages) {
+				while (page->lock.test_and_set(std::memory_order_acquire)) {
+					std::atomic_signal_fence(std::memory_order_seq_cst);
+				}
+			}
+		}
+		~PageRangeGuard() {
+			for (auto it = m_pages.rbegin(); it != m_pages.rend(); ++it) {
+				(*it)->lock.clear(std::memory_order_release);
+			}
+		}
+		KYTY_CLASS_NO_COPY(PageRangeGuard);
+
+	private:
+		std::span<PageState*> m_pages;
+	};
+
 	Impl() {
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 		SYSTEM_INFO info {};
@@ -209,9 +215,10 @@ struct PageManager::Impl {
 
 	~Impl() {
 		for (const auto& region: region_storage) {
-			SpinGuard lock(region->lock);
 			for (auto& page: region->pages) {
-				if (page.write_watchers != 0 || page.access_watchers != 0) {
+				SpinGuard lock(page.lock);
+				if (page.write_watchers != 0 || page.access_watchers != 0 ||
+				    page.backing_writer != 0 || page.resolving) {
 					FailFast("PageManager destroyed with live page state");
 				}
 			}
@@ -239,81 +246,56 @@ struct PageManager::Impl {
 		return ptr;
 	}
 
-	void Protect(uint64_t vaddr, uint64_t size, uint32_t protection) noexcept {
+	PageState& GetPage(Region& region, uint64_t vaddr) const {
+		return region.pages[(vaddr % REGION_SIZE) / PAGE_SIZE];
+	}
+
+	static uint32_t WatcherProtection(const PageState& page) {
+		if (page.access_watchers != 0) {
+			return NO_ACCESS_PROTECTION;
+		}
+		if (page.write_watchers != 0) {
+			return READ_ONLY_PROTECTION;
+		}
+		return page.original_protection;
+	}
+
+	static void InitializeProtection(std::span<PageState*> pages) {
+		for (auto* page: pages) {
+			page->original_protection = READ_WRITE_PROTECTION;
+			page->current_protection  = READ_WRITE_PROTECTION;
+		}
+	}
+
+	void ProtectRange(std::span<PageState*> pages, uint64_t vaddr, uint32_t protection,
+	                  std::span<const uint32_t> expected_old) noexcept {
+		const auto size = pages.size() * PAGE_SIZE;
+		if (pages.size() != expected_old.size()) {
+			FailFast("protection range state size mismatch");
+		}
+		for (size_t i = 0; i < pages.size(); i++) {
+			const auto actual = pages[i]->current_protection;
+			if (actual != UNKNOWN_PROTECTION && actual != expected_old[i]) {
+				Fatal("invalid protection transition at 0x%016" PRIx64 ", old=0x%08" PRIx32
+				      ", expected=0x%08" PRIx32 ", new=0x%08" PRIx32,
+				      vaddr + i * PAGE_SIZE, actual, expected_old[i], protection);
+			}
+		}
 		if (!Libs::LibKernel::Memory::ProtectGuestHostMemory(vaddr, size,
 		                                                     ToMemoryMode(protection))) {
 			Fatal("address-space protection failed at 0x%016" PRIx64 ", new=0x%08" PRIx32, vaddr,
 			      protection);
 		}
+		for (auto* page: pages) {
+			page->current_protection = protection;
+		}
 	}
 
-	template <bool track, bool is_read, bool masked>
-	void UpdateRegionWatchers(Region& region, uint64_t base_addr, size_t first, size_t last,
-	                          const RegionBits* mask = nullptr) {
-		SpinGuard lock(region.lock);
-		auto      perms                 = region.pages[first].Perms();
-		uint64_t  range_begin           = 0;
-		uint64_t  range_bytes           = 0;
-		uint64_t  potential_range_bytes = 0;
-
-		const auto release_pending = [&] {
-			if (range_bytes != 0) {
-				Protect(base_addr + range_begin * PAGE_SIZE, range_bytes, perms);
-				range_bytes           = 0;
-				potential_range_bytes = 0;
-			}
-		};
-
-		for (size_t page_index = first; page_index < last; page_index++) {
-			auto&      page    = region.pages[page_index];
-			const auto address = base_addr + page_index * PAGE_SIZE;
-			const bool update  = !masked || mask->Get(page_index);
-
-			const auto old_perms = page.Perms();
-			const auto new_count = update ? page.AddDelta<track ? 1 : -1, is_read>(address)
-			                              : page.AddDelta<0, is_read>(address);
-			const auto new_perms = page.Perms();
-
-			if (new_perms != perms) [[unlikely]] {
-				release_pending();
-				perms = new_perms;
-			} else if (range_bytes != 0) {
-				potential_range_bytes += PAGE_SIZE;
-			}
-
-			if (!update) {
-				continue;
-			}
-
-			const bool watcher_edge = (track && new_count == 1) || (!track && new_count == 0);
-			if (watcher_edge && old_perms != new_perms) {
-				if (range_bytes == 0) {
-					range_begin           = page_index;
-					potential_range_bytes = PAGE_SIZE;
-				}
-				range_bytes = potential_range_bytes;
-			}
-		}
-
-		release_pending();
-	}
-
-	template <bool track, bool is_read>
-	void UpdatePageWatchers(uint64_t vaddr, uint64_t size) {
-		const auto begin = PageStart(vaddr);
-		const auto end   = PageEnd(vaddr, size);
-		for (auto chunk_begin = begin; chunk_begin < end;) {
-			const auto chunk_end   = std::min(end, (chunk_begin / REGION_SIZE + 1) * REGION_SIZE);
-			const auto region_base = chunk_begin / REGION_SIZE * REGION_SIZE;
-			auto*      region = track ? GetOrCreateRegion(chunk_begin) : FindRegion(chunk_begin);
-			if (region == nullptr) {
-				Fatal("untracking unknown page 0x%016" PRIx64, chunk_begin);
-			}
-			const auto first = static_cast<size_t>((chunk_begin - region_base) / PAGE_SIZE);
-			const auto last  = static_cast<size_t>((chunk_end - region_base) / PAGE_SIZE);
-			UpdateRegionWatchers<track, is_read, false>(*region, region_base, first, last);
-			chunk_begin = chunk_end;
-		}
+	void Protect(PageState& page, uint64_t vaddr, uint32_t protection,
+	             uint32_t expected_old) noexcept {
+		PageState* pages[]    = {&page};
+		uint32_t   expected[] = {expected_old};
+		ProtectRange(pages, vaddr, protection, expected);
 	}
 
 	std::unique_ptr<std::atomic<Region*>[]> regions;
@@ -331,48 +313,212 @@ uint64_t PageManager::GetPageSize() const {
 	return PAGE_SIZE;
 }
 
-template <bool track>
-void PageManager::UpdatePageWatchers(uint64_t vaddr, uint64_t size) {
-	m_impl->UpdatePageWatchers<track, false>(vaddr, size);
+void PageManager::UpdatePageWatchers(bool track, uint64_t vaddr, uint64_t size,
+                                     PageWatchMode mode) {
+	if (mode != PageWatchMode::Write && mode != PageWatchMode::ReadWrite) {
+		Fatal("invalid watcher mode");
+	}
+	const auto begin = PageStart(vaddr);
+	const auto end   = PageEnd(vaddr, size);
+	for (auto chunk_begin = begin; chunk_begin < end;) {
+		const auto chunk_end = std::min(end, (chunk_begin / REGION_SIZE + 1) * REGION_SIZE);
+		auto*      region =
+		    track ? m_impl->GetOrCreateRegion(chunk_begin) : m_impl->FindRegion(chunk_begin);
+		if (region == nullptr) {
+			Fatal("untracking unknown page 0x%016" PRIx64, chunk_begin);
+		}
+
+		const auto page_count = static_cast<size_t>((chunk_end - chunk_begin) / PAGE_SIZE);
+		std::vector<Impl::PageState*> pages;
+		pages.reserve(page_count);
+		for (auto address = chunk_begin; address < chunk_end; address += PAGE_SIZE) {
+			pages.push_back(&m_impl->GetPage(*region, address));
+		}
+		Impl::PageRangeGuard lock(pages);
+
+		std::vector<uint8_t> first_watchers(page_count);
+		for (size_t i = 0; i < page_count; i++) {
+			auto&      page    = *pages[i];
+			const auto address = chunk_begin + i * PAGE_SIZE;
+			if (page.resolving && track) {
+				FailFast("new page watcher raced active fault resolution");
+			}
+			auto& watchers =
+			    (mode == PageWatchMode::ReadWrite ? page.access_watchers : page.write_watchers);
+			if (track) {
+				if (watchers == std::numeric_limits<uint32_t>::max()) {
+					Fatal("watcher overflow at 0x%016" PRIx64, address);
+				}
+				first_watchers[i] = page.write_watchers == 0 && page.access_watchers == 0;
+			} else {
+				if (watchers == 0) {
+					Fatal("watcher underflow at 0x%016" PRIx64, address);
+				}
+				if (page.backing_writer != 0 && page.backing_writer != CurrentThread()) {
+					Fatal("backing write ownership changed at 0x%016" PRIx64, address);
+				}
+			}
+		}
+
+		if (track) {
+			for (size_t first = 0; first < page_count;) {
+				while (first < page_count && first_watchers[first] == 0) {
+					first++;
+				}
+				auto last = first;
+				while (last < page_count && first_watchers[last] != 0) {
+					last++;
+				}
+				if (first != last) {
+					Impl::InitializeProtection(std::span {pages}.subspan(first, last - first));
+				}
+				first = last;
+			}
+		}
+
+		std::vector<uint32_t> old_protections(page_count);
+		std::vector<uint32_t> new_protections(page_count);
+		std::vector<uint8_t>  transitions(page_count);
+		for (size_t i = 0; i < page_count; i++) {
+			auto& page = *pages[i];
+			auto& watchers =
+			    (mode == PageWatchMode::ReadWrite ? page.access_watchers : page.write_watchers);
+			const auto old_protection = Impl::WatcherProtection(page);
+			if (track) {
+				watchers++;
+			} else {
+				watchers--;
+			}
+			const auto new_protection = Impl::WatcherProtection(page);
+			old_protections[i]        = old_protection;
+			new_protections[i]        = new_protection;
+			if (new_protection != old_protection && (track || page.backing_writer == 0)) {
+				transitions[i] = 1;
+			}
+		}
+
+		for (size_t first = 0; first < page_count;) {
+			while (first < page_count && transitions[first] == 0) {
+				first++;
+			}
+			if (first == page_count) {
+				break;
+			}
+			const auto protection = new_protections[first];
+			auto       current    = first + 1;
+			auto       last       = current;
+			for (; current < page_count && new_protections[current] == protection; current++) {
+				if (old_protections[current] != new_protections[current] &&
+				    transitions[current] == 0) {
+					break;
+				}
+				if (transitions[current] != 0) {
+					last = current + 1;
+				}
+			}
+			m_impl->ProtectRange(std::span {pages}.subspan(first, last - first),
+			                     chunk_begin + first * PAGE_SIZE, protection,
+			                     std::span {old_protections}.subspan(first, last - first));
+			first = current;
+		}
+
+		for (auto* page: pages) {
+			if (!track && page->backing_writer == 0 && page->write_watchers == 0 &&
+			    page->access_watchers == 0) {
+				page->original_protection = 0;
+			}
+		}
+		chunk_begin = chunk_end;
+	}
 }
 
-template void PageManager::UpdatePageWatchers<true>(uint64_t, uint64_t);
-template void PageManager::UpdatePageWatchers<false>(uint64_t, uint64_t);
-
-template <bool track, bool is_read>
-void PageManager::UpdatePageWatchersForRegion(uint64_t base_addr, RegionBits& mask) {
-	if (base_addr % REGION_SIZE != 0 || base_addr >= ADDRESS_SIZE ||
-	    REGION_SIZE > ADDRESS_SIZE - base_addr) {
-		Fatal("invalid tracking region base 0x%016" PRIx64, base_addr);
-	}
-
-	const auto start_range = mask.FirstRange();
-	const auto end_range   = mask.LastRange();
-	if (start_range.first == REGION_PAGES) {
-		FailFast("empty region watcher mask");
-	}
-	const auto first = start_range.first;
-	const auto last  = end_range.second;
-	if (start_range.second == end_range.second) {
-		m_impl->UpdatePageWatchers<track, is_read>(base_addr + first * PAGE_SIZE,
-		                                           (last - first) * PAGE_SIZE);
-		return;
-	}
-
-	auto* region = track ? m_impl->GetOrCreateRegion(base_addr) : m_impl->FindRegion(base_addr);
-	if (region == nullptr) {
-		Fatal("untracking unknown region 0x%016" PRIx64, base_addr);
-	}
-	m_impl->UpdateRegionWatchers<track, is_read, true>(*region, base_addr, first, last, &mask);
-}
-
-template void PageManager::UpdatePageWatchersForRegion<true, true>(uint64_t, RegionBits&);
-template void PageManager::UpdatePageWatchersForRegion<true, false>(uint64_t, RegionBits&);
-template void PageManager::UpdatePageWatchersForRegion<false, true>(uint64_t, RegionBits&);
-template void PageManager::UpdatePageWatchersForRegion<false, false>(uint64_t, RegionBits&);
-
 void PageManager::OnGpuMap(uint64_t, uint64_t) {}
 
 void PageManager::OnGpuUnmap(uint64_t, uint64_t) {}
 
+PageManager::BackingWrite::BackingWrite(PageManager& manager, uint64_t vaddr,
+                                        uint64_t size) noexcept
+    : m_manager(manager), m_vaddr(vaddr), m_size(size) {
+	m_manager.BeginBackingWrite(vaddr, size);
+}
+
+PageManager::BackingWrite::~BackingWrite() {
+	m_manager.EndBackingWrite(m_vaddr, m_size);
+}
+
+std::vector<std::unique_ptr<PageManager::BackingWrite>>
+PageManager::ReserveBackingWrites(std::span<const RangeSet::Range> ranges) {
+	if (ranges.empty()) {
+		Fatal("cannot reserve empty backing-write ranges");
+	}
+	std::vector<std::unique_ptr<BackingWrite>> writes;
+	writes.reserve(ranges.size());
+	uint64_t begin = 0;
+	uint64_t end   = 0;
+	for (const auto& range: ranges) {
+		if (range.address == 0 || range.size == 0 || range.size > UINT64_MAX - range.address ||
+		    range.address + range.size > UINT64_MAX - (PAGE_SIZE - 1)) {
+			Fatal("invalid backing-write range");
+		}
+		const auto page_begin = PageStart(range.address);
+		const auto page_end   = PageStart(range.address + range.size + PAGE_SIZE - 1);
+		if (begin != 0 && page_begin > end) {
+			writes.push_back(std::make_unique<BackingWrite>(*this, begin, end - begin));
+			begin = 0;
+		}
+		if (begin == 0) {
+			begin = page_begin;
+			end   = page_end;
+		} else {
+			end = std::max(end, page_end);
+		}
+	}
+	writes.push_back(std::make_unique<BackingWrite>(*this, begin, end - begin));
+	return writes;
+}
+
+void PageManager::BeginBackingWrite(uint64_t vaddr, uint64_t size) noexcept {
+	const auto end    = PageEnd(vaddr, size);
+	const auto writer = CurrentThread();
+	for (auto address = PageStart(vaddr); address < end; address += PAGE_SIZE) {
+		auto* region = m_impl->FindRegion(address);
+		if (region == nullptr) {
+			Fatal("backing write reserves an unknown page at 0x%016" PRIx64, address);
+		}
+		auto&     page = m_impl->GetPage(*region, address);
+		SpinGuard lock(page.lock);
+		if (page.resolving || page.backing_writer != 0 || page.access_watchers == 0) {
+			Fatal("backing write races page resolution at 0x%016" PRIx64, address);
+		}
+		page.resolving      = true;
+		page.backing_writer = writer;
+	}
+}
+
+void PageManager::EndBackingWrite(uint64_t vaddr, uint64_t size) noexcept {
+	const auto end    = PageEnd(vaddr, size);
+	const auto writer = CurrentThread();
+	for (auto address = PageStart(vaddr); address < end; address += PAGE_SIZE) {
+		auto* region = m_impl->FindRegion(address);
+		if (region == nullptr) {
+			FailFast("backing write ended for an unknown page");
+		}
+		auto&     page = m_impl->GetPage(*region, address);
+		SpinGuard lock(page.lock);
+		if (!page.resolving || page.backing_writer != writer) {
+			FailFast("backing write ended without matching owner and resolving state");
+		}
+		const auto old_protection = NO_ACCESS_PROTECTION;
+		const auto new_protection = Impl::WatcherProtection(page);
+		if (new_protection != old_protection) {
+			m_impl->Protect(page, address, new_protection, old_protection);
+		}
+		if (page.write_watchers == 0 && page.access_watchers == 0) {
+			page.original_protection = 0;
+		}
+		page.backing_writer = 0;
+		page.resolving      = false;
+	}
+}
+
 } // namespace Libs::Graphics

src/graphics/host_gpu/pageManager.h

@@ -2,16 +2,31 @@
 #define EMULATOR_SRC_GRAPHICS_HOST_GPU_PAGEMANAGER_H_
 
 #include "common/common.h"
-#include "graphics/host_gpu/regionDefinitions.h"
+#include "graphics/host_gpu/rangeSet.h"
 
 #include <memory>
+#include <span>
+#include <vector>
 
 namespace Libs::Graphics {
 
 enum class PageFaultAccess { Read, Write, Execute, Unknown };
+enum class PageWatchMode { Write, ReadWrite };
 
 class PageManager final {
 public:
+	class BackingWrite final {
+	public:
+		BackingWrite(PageManager& manager, uint64_t vaddr, uint64_t size) noexcept;
+		~BackingWrite();
+		KYTY_CLASS_NO_COPY(BackingWrite);
+
+	private:
+		PageManager& m_manager;
+		uint64_t     m_vaddr = 0;
+		uint64_t     m_size  = 0;
+	};
+
 	PageManager();
 	// The owner must stop all PageManager callers before destruction.
 	~PageManager();
@@ -20,14 +35,18 @@ public:
 
 	[[nodiscard]] uint64_t GetPageSize() const;
 
-	template <bool track>
-	void UpdatePageWatchers(uint64_t vaddr, uint64_t size);
-	template <bool track, bool is_read = false>
-	void UpdatePageWatchersForRegion(uint64_t base_addr, RegionBits& mask);
+	void UpdatePageWatchers(bool track, uint64_t vaddr, uint64_t size,
+	                        PageWatchMode mode = PageWatchMode::Write);
 	void OnGpuMap(uint64_t vaddr, uint64_t size);
 	void OnGpuUnmap(uint64_t vaddr, uint64_t size);
 
+	[[nodiscard]] std::vector<std::unique_ptr<BackingWrite>>
+	ReserveBackingWrites(std::span<const RangeSet::Range> ranges);
+
 private:
+	void BeginBackingWrite(uint64_t vaddr, uint64_t size) noexcept;
+	void EndBackingWrite(uint64_t vaddr, uint64_t size) noexcept;
+
 	struct Impl;
 	std::unique_ptr<Impl> m_impl;
 };

src/graphics/host_gpu/rangeSet.h

@@ -53,30 +53,12 @@ public:
 		}
 	}
 
-	void Clear() { m_ranges.clear(); }
-
-	template <typename Func>
-	void ForEach(Func&& func) const {
-		for (const auto& [begin, end]: m_ranges) {
-			func(begin, end);
-		}
-	}
-
 	[[nodiscard]] std::vector<Range> Intersections(uint64_t address, uint64_t size) const {
 		std::vector<Range> result;
 		ForEachIntersection(address, size, [&result](Range range) { result.push_back(range); });
 		return result;
 	}
 
-	[[nodiscard]] bool Intersects(uint64_t address, uint64_t size) const {
-		const auto end = End(address, size);
-		auto       it  = m_ranges.lower_bound(address);
-		if (it != m_ranges.begin() && std::prev(it)->second > address) {
-			return true;
-		}
-		return it != m_ranges.end() && it->first < end;
-	}
-
 	[[nodiscard]] bool Contains(uint64_t address, uint64_t size) const {
 		const auto end = End(address, size);
 		auto       it  = m_ranges.upper_bound(address);
@@ -107,7 +89,7 @@ public:
 
 private:
 	static uint64_t End(uint64_t address, uint64_t size) {
-		if (size == 0 || size > UINT64_MAX - address) {
+		if (address == 0 || size == 0 || size > UINT64_MAX - address) {
 			EXIT("invalid range-set address or size\n");
 		}
 		return address + size;

src/graphics/host_gpu/regionDefinitions.h

@@ -1,10 +1,9 @@
 #ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_REGIONDEFINITIONS_H_
 #define EMULATOR_SRC_GRAPHICS_HOST_GPU_REGIONDEFINITIONS_H_
 
-#include "common/bitArray.h"
 #include "common/common.h"
 
-#include <compare>
+#include <bitset>
 
 namespace Libs::Graphics {
 
@@ -13,23 +12,8 @@ constexpr uint64_t TRACKER_REGION_SIZE  = 4ull * 1024ull * 1024ull;
 constexpr uint64_t TRACKER_ADDRESS_SIZE = 1ull << 40u;
 constexpr size_t   TRACKER_REGION_PAGES = TRACKER_REGION_SIZE / TRACKER_PAGE_SIZE;
 
-struct GuestRange {
-	uint64_t address = 0;
-	uint64_t size    = 0;
-
-	[[nodiscard]] constexpr bool Empty() const noexcept { return address == 0 && size == 0; }
-	[[nodiscard]] constexpr bool Valid() const noexcept {
-		return address != 0 && size != 0 && address < TRACKER_ADDRESS_SIZE &&
-		       size <= TRACKER_ADDRESS_SIZE - address;
-	}
-	[[nodiscard]] constexpr bool     ValidOrEmpty() const noexcept { return Empty() || Valid(); }
-	[[nodiscard]] constexpr uint64_t End() const noexcept { return address + size; }
-	auto                             operator<=>(const GuestRange&) const = default;
-};
-
 enum class DirtySource { Cpu, Gpu };
-using RegionBits = Common::BitArray<TRACKER_REGION_PAGES>;
-static_assert(sizeof(RegionBits) == TRACKER_REGION_PAGES / 8);
+using RegionBits = std::bitset<TRACKER_REGION_PAGES>;
 
 } // namespace Libs::Graphics
 

src/graphics/host_gpu/regionManager.h

@@ -76,9 +76,8 @@ public:
 		if (m_cpu_addr % TRACKER_REGION_SIZE != 0) {
 			EXIT("invalid region tracking manager construction\n");
 		}
-		m_cpu_dirty.Fill();
-		m_writable.Fill();
-		m_readable.Fill();
+		m_cpu_dirty.set();
+		m_writable.set();
 	}
 
 	KYTY_CLASS_NO_COPY(RegionManager);
@@ -88,81 +87,106 @@ public:
 	[[nodiscard]] bool IsModified(uint64_t offset, uint64_t size) const {
 		const auto [start, end] = GetPageRange(m_cpu_addr + offset, size);
 		const auto& bits        = GetBits<source>();
-		return RegionBits(bits, start, end).Any();
+		for (auto page = start; page < end; page++) {
+			if (bits.test(page)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	template <DirtySource source>
+	[[nodiscard]] bool IsFullyModified(uint64_t offset, uint64_t size) const {
+		const auto [start, end] = GetPageRange(m_cpu_addr + offset, size);
+		const auto& bits        = GetBits<source>();
+		for (auto page = start; page < end; page++) {
+			if (!bits.test(page)) {
+				return false;
+			}
+		}
+		return true;
 	}
 
 	template <DirtySource source, bool enable>
-	void ChangeState(uint64_t vaddr, uint64_t size) {
+	RegionBits ChangeState(uint64_t vaddr, uint64_t size) {
 		const auto [start, end] = GetPageRange(vaddr, size);
 		if constexpr (source == DirtySource::Cpu && enable) {
-			if (RegionBits(m_gpu_dirty, start, end).Any()) {
-				EXIT("CPU dirty state conflicts with GPU dirty state\n");
+			for (auto page = start; page < end; page++) {
+				if (m_gpu_dirty.test(page)) {
+					EXIT("CPU dirty state conflicts with GPU dirty state\n");
+				}
 			}
 		}
 		if constexpr (source == DirtySource::Gpu && enable) {
-			if (RegionBits(m_cpu_dirty, start, end).Any()) {
-				EXIT("GPU dirty state conflicts with CPU dirty state\n");
+			for (auto page = start; page < end; page++) {
+				if (m_cpu_dirty.test(page)) {
+					EXIT("GPU dirty state conflicts with CPU dirty state\n");
+				}
 			}
 		}
-		auto& bits = GetBits<source>();
-		if constexpr (enable) {
-			bits.SetRange(start, end);
-		} else {
-			bits.UnsetRange(start, end);
+		auto& bits    = GetBits<source>();
+		auto  changed = bits;
+		for (auto page = start; page < end; page++) {
+			bits.set(page, enable);
 		}
+		changed ^= bits;
 		if constexpr (source == DirtySource::Cpu) {
-			UpdateCpuProtection<!enable>();
-		} else {
-			UpdateGpuProtection<enable>();
+			changed    = m_cpu_dirty ^ m_writable;
+			m_writable = m_cpu_dirty;
 		}
+		return changed;
 	}
 
 	template <DirtySource source, bool clear, typename Func>
-	void ForEachModifiedRange(uint64_t vaddr, uint64_t size, Func&& func) {
+	RegionBits ForEachModifiedRange(uint64_t vaddr, uint64_t size, Func&& func) {
 		const auto [start, end] = GetPageRange(vaddr, size);
-		RegionBits mask(GetBits<source>(), start, end);
+		auto mask               = GetBits<source>();
+		for (auto page = 0u; page < start; page++) {
+			mask.reset(page);
+		}
+		for (auto page = end; page < TRACKER_REGION_PAGES; page++) {
+			mask.reset(page);
+		}
 		if constexpr (clear) {
-			GetBits<source>().UnsetRange(start, end);
+			auto& bits = GetBits<source>();
+			for (auto page = start; page < end; page++) {
+				if (mask.test(page)) {
+					bits.reset(page);
+				}
+			}
 		}
 		if constexpr (source == DirtySource::Cpu && clear) {
-			UpdateCpuProtection<true>();
+			auto changed = m_cpu_dirty ^ m_writable;
+			m_writable   = m_cpu_dirty;
+			ApplyProtection(changed, true);
 			ForEachRange(mask, std::forward<Func>(func));
-			return;
-		}
-		if constexpr (source == DirtySource::Gpu && clear) {
-			UpdateGpuProtection<false>();
+			return changed;
 		}
 		ForEachRange(mask, std::forward<Func>(func));
+		if constexpr (clear) {
+			return mask;
+		}
+		return {};
+	}
+
+	void ApplyProtection(const RegionBits& changed, bool track) {
+		ForEachRange(changed, [this, track](uint64_t vaddr, uint64_t size) {
+			m_page_manager.UpdatePageWatchers(track, vaddr, size);
+		});
+	}
+
+	void ApplyGpuProtection(const RegionBits& changed, bool track, PageWatchMode mode) {
+		if (mode != PageWatchMode::Write && mode != PageWatchMode::ReadWrite) {
+			EXIT("unsupported GPU page-watch mode\n");
+		}
+		ForEachRange(changed, [this, track, mode](uint64_t vaddr, uint64_t size) {
+			m_page_manager.UpdatePageWatchers(track, vaddr, size, mode);
+		});
 	}
 
 	TrackingSpinLock lock;
 
 private:
-	template <bool track>
-	void UpdateCpuProtection() {
-		auto mask  = m_cpu_dirty ^ m_writable;
-		m_writable = m_cpu_dirty;
-		if (mask.None()) {
-			return;
-		}
-		m_page_manager.UpdatePageWatchersForRegion<track>(m_cpu_addr, mask);
-	}
-
-	template <bool track>
-	void UpdateGpuProtection() {
-		auto readable = ~m_gpu_dirty;
-		auto mask     = readable ^ m_readable;
-		m_readable    = readable;
-		if (mask.None()) {
-			return;
-		}
-		if constexpr (track) {
-			m_page_manager.UpdatePageWatchersForRegion<true, true>(m_cpu_addr, mask);
-		} else {
-			m_page_manager.UpdatePageWatchersForRegion<false, true>(m_cpu_addr, mask);
-		}
-	}
-
 	template <DirtySource source>
 	RegionBits& GetBits() {
 		if constexpr (source == DirtySource::Cpu) {
@@ -193,8 +217,18 @@ private:
 
 	template <typename Func>
 	void ForEachRange(const RegionBits& bits, Func&& func) const {
-		for (const auto [start, end]: bits) {
-			func(m_cpu_addr + start * TRACKER_PAGE_SIZE, (end - start) * TRACKER_PAGE_SIZE);
+		size_t page = 0;
+		while (page < TRACKER_REGION_PAGES) {
+			while (page < TRACKER_REGION_PAGES && !bits.test(page)) {
+				page++;
+			}
+			const auto start = page;
+			while (page < TRACKER_REGION_PAGES && bits.test(page)) {
+				page++;
+			}
+			if (start != page) {
+				func(m_cpu_addr + start * TRACKER_PAGE_SIZE, (page - start) * TRACKER_PAGE_SIZE);
+			}
 		}
 	}
 
@@ -203,7 +237,6 @@ private:
 	RegionBits   m_cpu_dirty;
 	RegionBits   m_gpu_dirty;
 	RegionBits   m_writable;
-	RegionBits   m_readable;
 };
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/cache/bufferCache.h

@@ -3,15 +3,14 @@
 
 #include "common/abi.h"
 #include "common/common.h"
-#include "common/lruCache.h"
-#include "common/slotVector.h"
+#include "common/threads.h"
 #include "graphics/host_gpu/memoryTracker.h"
 #include "graphics/host_gpu/rangeSet.h"
-#include "graphics/host_gpu/renderer/cache/faultManager.h"
-#include "graphics/host_gpu/renderer/cache/multiLevelPageTable.h"
 #include "graphics/host_gpu/renderer/cache/streamBuffer.h"
 
 #include <map>
+#include <memory>
+#include <mutex>
 #include <span>
 #include <utility>
 #include <vector>
@@ -19,103 +18,118 @@
 namespace Libs::Graphics {
 
 struct GraphicContext;
+class CommandBuffer;
 class CommandScheduler;
 class TextureCache;
+class ResourceMutex;
 
-using BufferId = Common::SlotId;
-inline constexpr BufferId NULL_BUFFER_ID {0};
+struct BufferBinding {
+	std::shared_ptr<void> owner;
+	vk::Buffer            buffer = nullptr;
+	uint64_t              offset = 0;
+};
+
+struct ImageBufferSource {
+	Buffer*  buffer    = nullptr;
+	uint64_t offset    = 0;
+	bool     gpu_owned = false;
+};
 
 class BufferCache {
 public:
-	static constexpr uint32_t CACHING_PAGEBITS  = 14;
-	static constexpr uint64_t CACHING_PAGESIZE  = uint64_t {1} << CACHING_PAGEBITS;
-	static constexpr uint64_t CACHING_NUMPAGES  = uint64_t {1} << (40 - CACHING_PAGEBITS);
-	static constexpr uint64_t BDA_PAGETABLE_SIZE =
-	    CACHING_NUMPAGES * sizeof(vk::DeviceAddress);
+	static constexpr uint64_t CACHING_PAGE_SIZE = 16ull * 1024ull;
+	static constexpr uint64_t GetBufferOffset(uint64_t vaddr) {
+		return vaddr & (CACHING_PAGE_SIZE - 1);
+	}
 
 	BufferCache(GraphicContext& graphics, CommandScheduler& scheduler, PageManager& page_manager,
-	            TextureCache& texture_cache);
+	            TextureCache& texture_cache, ResourceMutex& resource_mutex);
 	~BufferCache();
 	KYTY_CLASS_NO_COPY(BufferCache);
 
-	void                   InvalidateMemory(uint64_t vaddr, uint64_t size);
-	void                   ReadMemory(uint64_t vaddr, uint64_t size, bool is_write = false);
-	[[nodiscard]] Buffer&  GetBuffer(BufferId id) { return m_slot_buffers[id]; }
-	[[nodiscard]] BufferId FindBuffer(uint64_t vaddr, uint64_t size);
-	[[nodiscard]] std::pair<Buffer*, uint64_t> ObtainBuffer(uint64_t vaddr, uint64_t size,
-	                                                        bool     is_written,
-	                                                        bool     is_texel_buffer = false,
-	                                                        BufferId id              = {});
-	[[nodiscard]] StreamBuffer&                GetUtilityBuffer(MemoryUsage usage) noexcept {
-		switch (usage) {
-			case MemoryUsage::Upload: return m_staging_buffer;
-			case MemoryUsage::Stream: return m_stream_buffer;
-			case MemoryUsage::Download: return m_download_buffer;
-			case MemoryUsage::DeviceLocal: return m_device_buffer;
-		}
-		EXIT("BufferCache: invalid utility-buffer usage\n");
-	}
-	[[nodiscard]] const Buffer* GetGdsBuffer() const noexcept { return &m_gds_buffer; }
-	[[nodiscard]] Buffer* GetBdaPageTableBuffer() noexcept { return &m_bda_pagetable_buffer; }
-	[[nodiscard]] Buffer* GetFaultBuffer() noexcept { return m_fault_manager.GetFaultBuffer(); }
-	[[nodiscard]] std::pair<Buffer*, uint64_t> ObtainBufferForImage(uint64_t vaddr, uint64_t size);
-	void FillBuffer(uint64_t vaddr, uint64_t size, uint32_t value, bool is_gds);
-	void CopyBuffer(uint64_t dst_vaddr, uint64_t src_vaddr, uint64_t size, bool dst_gds,
-	                bool src_gds);
-	// Cache-index and exact dirty-range queries require GPU-thread serialization.
-	[[nodiscard]] bool IsRegionRegistered(uint64_t vaddr, uint64_t size);
+	void                        InvalidateMemory(uint64_t vaddr, uint64_t size);
+	void                        ReadMemory(uint64_t vaddr, uint64_t size);
+	void                        UnmapMemory(uint64_t vaddr, uint64_t size);
+	[[nodiscard]] BufferBinding ObtainBuffer(CommandBuffer& command, uint64_t vaddr, uint64_t size,
+	                                         bool is_written = false, bool is_read = true,
+	                                         bool is_formatted = false);
+	[[nodiscard]] StreamBuffer& GetUtilityBuffer(MemoryUsage usage) noexcept;
+	[[nodiscard]] Buffer&       GetGdsBuffer() noexcept { return m_gds_buffer; }
+	[[nodiscard]] const Buffer& GetGdsBuffer() const noexcept { return m_gds_buffer; }
+	[[nodiscard]] BufferBinding UploadTransient(const void* data, uint64_t size,
+	                                            uint64_t alignment);
+	[[nodiscard]] std::shared_ptr<Buffer> ObtainNullBuffer();
+	[[nodiscard]] ImageBufferSource       ObtainBufferForImage(uint64_t vaddr, uint64_t size);
+	[[nodiscard]] std::pair<std::shared_ptr<Buffer>, uint64_t>
+	     ObtainBufferForImageWrite(uint64_t vaddr, uint64_t size);
+	void DiscardGpuDirtyBytes(uint64_t vaddr, uint64_t size);
+	void FillBuffer(uint64_t vaddr, uint64_t size, uint32_t value, bool is_gds = false);
+	void CopyBuffer(uint64_t dst_vaddr, uint64_t src_vaddr, uint64_t size, bool dst_gds = false,
+	                bool src_gds = false);
+	[[nodiscard]] bool HasPageOverlap(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] bool HasGpuDirtyBytes(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] bool IsRegionCpuModified(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] bool IsRegionGpuModified(uint64_t vaddr, uint64_t size);
-	void               ProcessFaultBuffer();
-	void               SynchronizeBuffersInRange(uint64_t vaddr, uint64_t size);
+	void               InvalidateImageAliases(uint64_t vaddr, uint64_t size);
+	void               BeginBackingPublication(uint64_t vaddr, uint64_t size, uint64_t tick);
+	void               CompleteBackingPublication(uint64_t vaddr, uint64_t size, uint64_t tick);
+	[[nodiscard]] bool SynchronizeBacking(uint64_t vaddr, uint64_t size);
+	void               PublishImageBuffer(uint64_t vaddr, uint64_t size);
 	void               RunGarbageCollector();
 
 private:
 	friend struct BufferCacheTestAccess;
 
+	struct CacheRange {
+		uint64_t address = 0;
+		uint64_t size    = 0;
+	};
+	struct CachedBuffer;
 	struct DownloadCopy;
-	using PageTable = MultiLevelPageTable<BufferId, CACHING_PAGEBITS, 40, 16>;
-	static_assert(CACHING_PAGESIZE == (uint64_t {1} << PageTable::kPageBits));
+	struct DownloadRange;
+	struct RetiredBuffer;
+	struct PendingBackingPublication;
 	static constexpr uint64_t               DOWNLOAD_ALIGNMENT = 64;
+	[[nodiscard]] static uint64_t           AlignDown(uint64_t value) noexcept;
+	[[nodiscard]] static uint64_t           AlignUp(uint64_t value);
 	[[nodiscard]] static constexpr uint64_t AlignDownload(uint64_t size) noexcept {
 		return (size + DOWNLOAD_ALIGNMENT - 1) & ~(DOWNLOAD_ALIGNMENT - 1);
 	}
+	[[nodiscard]] static bool PageOverlaps(uint64_t left, uint64_t left_size, uint64_t right,
+	                                       uint64_t right_size) noexcept;
 	[[nodiscard]] static std::pair<uint64_t, uint64_t> DownloadEnvelope(const DownloadCopy& copy);
-	void WriteDataBuffer(Buffer& buffer, uint64_t address, const void* source, uint64_t size);
-	void TouchBuffer(const Buffer& buffer);
-	[[nodiscard]] BufferId CreateBuffer(uint64_t vaddr, uint64_t size);
-	void                   Register(BufferId id);
-	void Unregister(BufferId id);
-	template <bool insert>
-	void ChangeRegister(BufferId id);
-	void DeleteBuffer(BufferId id);
-	[[nodiscard]] bool SynchronizeBuffer(Buffer& buffer, uint64_t vaddr, uint64_t size,
-	                                     bool is_written, bool is_texel_buffer);
-	[[nodiscard]] vk::Buffer UploadCopies(Buffer& buffer, std::span<vk::BufferCopy> copies,
-	                                      uint64_t total_size);
-	[[nodiscard]] bool SynchronizeBufferFromImage(Buffer& buffer, uint64_t vaddr, uint64_t size);
-	void DownloadBufferMemory(std::span<const DownloadCopy> copies);
+	[[nodiscard]] static bool ResolveOverlap(CacheRange& merged, CacheRange candidate) noexcept;
+	void Upload(CommandBuffer& command, Buffer& destination, uint64_t destination_offset,
+	            const void* source, uint64_t size);
+	[[nodiscard]] CachedBuffer& GetOrCreateBuffer(CommandBuffer& command, uint64_t vaddr,
+	                                              uint64_t size);
+	[[nodiscard]] std::vector<DownloadRange> RecordDownloads(std::span<const DownloadCopy> copies);
+	void PublishDownloads(std::span<const DownloadRange> downloads);
+	void QueueGarbageDownload(std::span<const DownloadCopy> copies, RetiredBuffer retire);
+	void RefreshInvalidatedRanges(CommandBuffer& command, CachedBuffer& cached, uint64_t vaddr,
+	                              uint64_t size, bool upload);
+	void DiscardGpuDirtyBytesLocked(uint64_t vaddr, uint64_t size, const char* operation);
 	void WriteHostMemory(uint64_t vaddr, std::span<const uint8_t> data);
-	void ReadMemoryOnGpu(uint64_t vaddr, uint64_t size, bool is_write);
 
 	GraphicContext&                                   m_graphics;
 	CommandScheduler&                                 m_scheduler;
-	FaultManager                                      m_fault_manager;
 	Buffer                                            m_gds_buffer;
-	Buffer                                            m_bda_pagetable_buffer;
-	Common::SlotVector<Buffer>                        m_slot_buffers;
-	Common::LeastRecentlyUsedCache<BufferId, uint64_t> m_lru_cache;
-	std::map<uint64_t, BufferId>                      m_buffers;
-	PageTable                                         m_page_table;
+	Common::Mutex                                     m_mutex;
+	std::shared_ptr<Buffer>                           m_null_buffer;
+	std::map<uint64_t, std::unique_ptr<CachedBuffer>> m_buffers;
 	RangeSet                                          m_gpu_modified_ranges;
+	RangeSet                                          m_image_invalidated_ranges;
+	std::mutex                                        m_publication_mutex;
+	std::vector<PendingBackingPublication>            m_pending_backing_publications;
 	MemoryTracker                                     m_memory_tracker;
 	StreamBuffer                                      m_staging_buffer;
 	StreamBuffer                                      m_stream_buffer;
 	StreamBuffer                                      m_download_buffer;
 	StreamBuffer                                      m_device_buffer;
+	PageManager&                                      m_page_manager;
 	TextureCache&                                     m_texture_cache;
-	uint64_t                                          m_total_used_memory  = 0;
+	ResourceMutex&                                    m_resource_mutex;
+	uint64_t                                          m_total_used_memory = 0;
 	uint64_t m_trigger_gc_memory  = 1ull * 1024 * 1024 * 1024;
 	uint64_t m_critical_gc_memory = 2ull * 1024 * 1024 * 1024;
 	uint64_t m_gc_tick            = 0;

src/graphics/host_gpu/renderer/cache/faultManager.cpp

@@ -1,167 +0,0 @@
-#include "graphics/host_gpu/renderer/cache/faultManager.h"
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "gpu_tiler_shaders/fault_buffer_process_spv.h"
-#include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/renderer/cache/bufferCache.h"
-#include "graphics/host_gpu/renderer/commandScheduler.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <bit>
-#include <cinttypes>
-#include <cstring>
-#include <limits>
-
-namespace Libs::Graphics {
-
-namespace {
-
-constexpr size_t MaxPageFaults    = 1024;
-constexpr size_t PageFaultAreaSize = MaxPageFaults * sizeof(uint64_t);
-
-} // namespace
-
-FaultManager::FaultManager(GraphicContext& graphics, CommandScheduler& scheduler,
-                           BufferCache& buffer_cache, uint32_t caching_pagebits,
-                           uint64_t caching_num_pages)
-    : m_graphics(graphics), m_scheduler(scheduler), m_buffer_cache(buffer_cache),
-      m_caching_pagesize(uint64_t {1} << caching_pagebits),
-      m_caching_num_pages(caching_num_pages), m_fault_buffer_size(caching_num_pages / 8),
-      m_fault_buffer(graphics, scheduler, MemoryUsage::DeviceLocal, 0, AllFlags,
-                     m_fault_buffer_size),
-      m_download_buffer(graphics, scheduler, MemoryUsage::Download, 0, AllFlags,
-                        MaxPendingFaults * PageFaultAreaSize) {
-	SetVulkanObjectNameF(m_graphics.device, m_fault_buffer.Handle(), "Fault Buffer");
-
-	const vk::DescriptorSetLayoutBinding bindings[] {
-	    {0, vk::DescriptorType::eStorageBuffer, 1, vk::ShaderStageFlagBits::eCompute, nullptr},
-	    {1, vk::DescriptorType::eStorageBuffer, 1, vk::ShaderStageFlagBits::eCompute, nullptr},
-	};
-	vk::DescriptorSetLayoutCreateInfo layout_info {};
-	layout_info.sType        = vk::StructureType::eDescriptorSetLayoutCreateInfo;
-	layout_info.flags        = vk::DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR;
-	layout_info.bindingCount = std::size(bindings);
-	layout_info.pBindings    = bindings;
-	RequireVulkanSuccess(
-	    m_graphics.device.createDescriptorSetLayout(&layout_info, nullptr,
-	                                                &m_fault_process_desc_layout),
-	    "create fault-buffer descriptor layout");
-
-	vk::ShaderModuleCreateInfo module_info {};
-	module_info.sType    = vk::StructureType::eShaderModuleCreateInfo;
-	module_info.codeSize = std::size(FAULT_BUFFER_PROCESS_SPV) * sizeof(uint32_t);
-	module_info.pCode    = FAULT_BUFFER_PROCESS_SPV;
-	vk::ShaderModule module = nullptr;
-	RequireVulkanSuccess(m_graphics.device.createShaderModule(&module_info, nullptr, &module),
-	                     "create fault-buffer shader module");
-
-	vk::PipelineLayoutCreateInfo pipeline_layout_info {};
-	pipeline_layout_info.sType          = vk::StructureType::ePipelineLayoutCreateInfo;
-	pipeline_layout_info.setLayoutCount = 1;
-	pipeline_layout_info.pSetLayouts    = &m_fault_process_desc_layout;
-	RequireVulkanSuccess(
-	    m_graphics.device.createPipelineLayout(&pipeline_layout_info, nullptr,
-	                                           &m_fault_process_pipeline_layout),
-	    "create fault-buffer pipeline layout");
-
-	vk::PipelineShaderStageCreateInfo stage {};
-	stage.sType  = vk::StructureType::ePipelineShaderStageCreateInfo;
-	stage.stage  = vk::ShaderStageFlagBits::eCompute;
-	stage.module = module;
-	stage.pName  = "main";
-	vk::ComputePipelineCreateInfo pipeline_info {};
-	pipeline_info.sType  = vk::StructureType::eComputePipelineCreateInfo;
-	pipeline_info.stage  = stage;
-	pipeline_info.layout = m_fault_process_pipeline_layout;
-	const auto result = m_graphics.device.createComputePipelines(
-	    nullptr, 1, &pipeline_info, nullptr, &m_fault_process_pipeline);
-	m_graphics.device.destroyShaderModule(module, nullptr);
-	RequireVulkanSuccess(result, "create fault-buffer pipeline");
-	SetVulkanObjectNameF(m_graphics.device, m_fault_process_pipeline, "Fault Buffer Parser");
-}
-
-FaultManager::~FaultManager() {
-	m_graphics.device.destroyPipeline(m_fault_process_pipeline, nullptr);
-	m_graphics.device.destroyPipelineLayout(m_fault_process_pipeline_layout, nullptr);
-	m_graphics.device.destroyDescriptorSetLayout(m_fault_process_desc_layout, nullptr);
-}
-
-void FaultManager::ProcessFaultBuffer() {
-	if (const auto wait_tick = m_fault_areas[m_current_area]; wait_tick != 0) {
-		m_scheduler.Wait(wait_tick);
-		m_scheduler.PopPendingOperations();
-	}
-
-	const auto offset = m_current_area * PageFaultAreaSize;
-	auto*      mapped = m_download_buffer.Mapped().data() + offset;
-	std::memset(mapped, 0, PageFaultAreaSize);
-	m_download_buffer.Flush(offset, PageFaultAreaSize);
-
-	vk::BufferMemoryBarrier2 pre_barrier {};
-	pre_barrier.sType         = vk::StructureType::eBufferMemoryBarrier2;
-	pre_barrier.srcStageMask  = vk::PipelineStageFlagBits2::eAllCommands;
-	pre_barrier.srcAccessMask = vk::AccessFlagBits2::eShaderWrite;
-	pre_barrier.dstStageMask  = vk::PipelineStageFlagBits2::eComputeShader;
-	pre_barrier.dstAccessMask = vk::AccessFlagBits2::eShaderRead;
-	pre_barrier.buffer        = m_fault_buffer.Handle();
-	pre_barrier.offset        = 0;
-	pre_barrier.size          = m_fault_buffer_size;
-	auto post_barrier         = pre_barrier;
-	post_barrier.srcStageMask  = vk::PipelineStageFlagBits2::eComputeShader;
-	post_barrier.srcAccessMask = vk::AccessFlagBits2::eShaderWrite;
-	post_barrier.dstStageMask  = vk::PipelineStageFlagBits2::eAllCommands;
-	post_barrier.dstAccessMask = vk::AccessFlagBits2::eShaderWrite;
-
-	const vk::DescriptorBufferInfo infos[] {
-	    {m_fault_buffer.Handle(), 0, m_fault_buffer_size},
-	    {m_download_buffer.Handle(), offset, PageFaultAreaSize},
-	};
-	std::array<vk::WriteDescriptorSet, 2> writes {};
-	for (uint32_t index = 0; index < writes.size(); ++index) {
-		writes[index].sType           = vk::StructureType::eWriteDescriptorSet;
-		writes[index].dstBinding      = index;
-		writes[index].descriptorCount = 1;
-		writes[index].descriptorType  = vk::DescriptorType::eStorageBuffer;
-		writes[index].pBufferInfo     = &infos[index];
-	}
-
-	m_scheduler.EndRendering();
-	auto command = m_scheduler.Current().Handle();
-	vk::DependencyInfo dependency {};
-	dependency.sType                    = vk::StructureType::eDependencyInfo;
-	dependency.dependencyFlags          = vk::DependencyFlagBits::eByRegion;
-	dependency.bufferMemoryBarrierCount = 1;
-	dependency.pBufferMemoryBarriers    = &pre_barrier;
-	command.pipelineBarrier2(dependency);
-	command.bindPipeline(vk::PipelineBindPoint::eCompute, m_fault_process_pipeline);
-	command.pushDescriptorSetKHR(vk::PipelineBindPoint::eCompute,
-	                             m_fault_process_pipeline_layout, 0, writes);
-	const auto num_threads    = m_caching_num_pages / 32;
-	const auto num_workgroups = (num_threads + 63) / 64;
-	command.dispatch(static_cast<uint32_t>(num_workgroups), 1, 1);
-	dependency.pBufferMemoryBarriers = &post_barrier;
-	command.pipelineBarrier2(dependency);
-
-	const auto area = m_current_area;
-	m_scheduler.DeferOperation([this, mapped, offset, area] {
-		m_download_buffer.Invalidate(offset, PageFaultAreaSize);
-		m_fault_ranges.Clear();
-		const auto* faults = std::bit_cast<const uint64_t*>(mapped);
-		const auto  count  = static_cast<uint32_t>(faults[0]);
-		for (uint32_t index = 1; index <= count; ++index) {
-			m_fault_ranges.Add(faults[index], m_caching_pagesize);
-			LOGF("Accessed non-GPU cached memory at 0x%016" PRIx64 "\n", faults[index]);
-		}
-		m_fault_ranges.ForEach([this](uint64_t start, uint64_t end) {
-			EXIT_IF(end - start > std::numeric_limits<uint32_t>::max());
-			(void)m_buffer_cache.FindBuffer(start, end - start);
-		});
-		m_fault_areas[area] = 0;
-	});
-
-	m_fault_areas[m_current_area++] = m_scheduler.CurrentTick();
-	m_current_area %= MaxPendingFaults;
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/cache/faultManager.h

@@ -1,46 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_CACHE_FAULTMANAGER_H_
-#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_CACHE_FAULTMANAGER_H_
-
-#include "common/abi.h"
-#include "graphics/host_gpu/rangeSet.h"
-#include "graphics/host_gpu/renderer/cache/streamBuffer.h"
-
-#include <array>
-#include <cstdint>
-
-namespace Libs::Graphics {
-
-class BufferCache;
-
-class FaultManager {
-	static constexpr size_t MaxPendingFaults = 8;
-
-public:
-	FaultManager(GraphicContext& graphics, CommandScheduler& scheduler, BufferCache& buffer_cache,
-	             uint32_t caching_pagebits, uint64_t caching_num_pages);
-	~FaultManager();
-	KYTY_CLASS_NO_COPY(FaultManager);
-
-	[[nodiscard]] Buffer* GetFaultBuffer() noexcept { return &m_fault_buffer; }
-	void                  ProcessFaultBuffer();
-
-private:
-	GraphicContext&                            m_graphics;
-	CommandScheduler&                          m_scheduler;
-	BufferCache&                               m_buffer_cache;
-	RangeSet                                   m_fault_ranges;
-	uint64_t                                   m_caching_pagesize;
-	uint64_t                                   m_caching_num_pages;
-	uint64_t                                   m_fault_buffer_size;
-	Buffer                                     m_fault_buffer;
-	Buffer                                     m_download_buffer;
-	std::array<uint64_t, MaxPendingFaults>      m_fault_areas {};
-	uint32_t                                   m_current_area = 0;
-	vk::DescriptorSetLayout                    m_fault_process_desc_layout = nullptr;
-	vk::Pipeline                               m_fault_process_pipeline = nullptr;
-	vk::PipelineLayout                         m_fault_process_pipeline_layout = nullptr;
-};
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_CACHE_FAULTMANAGER_H_

src/graphics/host_gpu/renderer/cache/gpuResourceManager.cpp

@@ -1,13 +1,14 @@
 #include "graphics/host_gpu/renderer/cache/gpuResourceManager.h"
 
 #include "common/assert.h"
+#include "graphics/guest_gpu/command_processor/commandProcessor.h"
 #include "graphics/guest_gpu/graphicsRun.h"
 #include "graphics/host_gpu/renderer/commandScheduler.h"
 namespace Libs::Graphics {
 
 GpuResourceManager::GpuResourceManager(GraphicContext& graphics, CommandScheduler& scheduler)
-    : m_scheduler(scheduler), m_buffer_cache(graphics, scheduler, m_page_manager, m_texture_cache),
-      m_texture_cache(graphics, scheduler, m_page_manager, m_buffer_cache) {}
+    : m_buffer_cache(graphics, scheduler, m_page_manager, m_texture_cache, m_resource_mutex),
+      m_texture_cache(graphics, scheduler, m_page_manager, m_buffer_cache, m_resource_mutex) {}
 
 GpuResourceManager::~GpuResourceManager() = default;
 
@@ -16,26 +17,75 @@ bool GpuResourceManager::HandleFault(PageFaultAccess access, uint64_t fault_vadd
 	if (!IsMapped(fault_vaddr, fault_size)) {
 		return false;
 	}
-	if (access == PageFaultAccess::Write) {
-		m_buffer_cache.InvalidateMemory(fault_vaddr, fault_size);
-		m_texture_cache.InvalidateMemory(fault_vaddr, fault_size);
-	} else {
-		m_buffer_cache.ReadMemory(fault_vaddr, fault_size);
+	if (CommandScheduler::InDeferredOperation()) {
+		EXIT("unsupported guest-memory fault from an asynchronous GPU completion, "
+		     "addr=0x%016" PRIx64 " access=%u\n",
+		     fault_vaddr, static_cast<uint32_t>(access));
 	}
-	return true;
+	bool       handled = false;
+	const auto resolve = [this, access, fault_vaddr, &handled](CommandProcessor& cp) {
+		cp.BeginReadbackTransaction();
+		{
+			ResourceMutex::FaultScope fault(m_resource_mutex);
+			if (access == PageFaultAccess::Write) {
+				m_buffer_cache.InvalidateMemory(fault_vaddr, fault_size);
+				m_texture_cache.InvalidateMemory(fault_vaddr, fault_size);
+			} else {
+				m_buffer_cache.ReadMemory(fault_vaddr, fault_size);
+			}
+			handled = true;
+		}
+		cp.EndReadbackTransaction();
+	};
+	if (auto* cp = Gpu::CurrentCommandProcessor(); cp != nullptr) {
+		resolve(*cp);
+		return handled;
+	}
+	if (m_resource_mutex.IsOwnedByCurrentThread()) {
+		EXIT("unsupported page fault from a pre-owned resource transaction, addr=0x%016" PRIx64
+		     " access=%u\n",
+		     fault_vaddr, static_cast<uint32_t>(access));
+	}
+	EXIT_IF(m_gpu == nullptr);
+	m_gpu->SendCommandSyncWithProcessor(resolve);
+	return handled;
 }
 
 bool GpuResourceManager::InvalidateMemory(uint64_t vaddr, uint64_t size) {
 	if (!IsMapped(vaddr, size)) {
 		return false;
 	}
-	m_buffer_cache.InvalidateMemory(vaddr, size);
-	m_texture_cache.InvalidateMemory(vaddr, size);
+	if (CommandScheduler::InDeferredOperation()) {
+		EXIT("unsupported memory invalidation from an asynchronous GPU completion, "
+		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
+		     vaddr, size);
+	}
+	const auto resolve = [this, vaddr, size](CommandProcessor& cp) {
+		cp.BeginReadbackTransaction();
+		{
+			ResourceMutex::FaultScope fault(m_resource_mutex);
+			m_buffer_cache.InvalidateMemory(vaddr, size);
+			m_texture_cache.InvalidateMemory(vaddr, size);
+		}
+		cp.EndReadbackTransaction();
+	};
+	if (auto* cp = Gpu::CurrentCommandProcessor(); cp != nullptr) {
+		resolve(*cp);
+		return true;
+	}
+	if (m_resource_mutex.IsOwnedByCurrentThread()) {
+		EXIT("unsupported memory invalidation from a pre-owned resource transaction, "
+		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
+		     vaddr, size);
+	}
+	EXIT_IF(m_gpu == nullptr);
+	m_gpu->SendCommandSyncWithProcessor(resolve);
 	return true;
 }
 
 bool GpuResourceManager::IsMapped(uint64_t vaddr, uint64_t size) const noexcept {
-	if (!GuestRange {vaddr, size}.Valid()) {
+	if (vaddr == 0 || size == 0 || vaddr >= TRACKER_ADDRESS_SIZE ||
+	    size > TRACKER_ADDRESS_SIZE - vaddr) {
 		return false;
 	}
 	std::shared_lock lock(m_mapped_ranges_mutex);
@@ -51,43 +101,25 @@ void GpuResourceManager::MapMemory(uint64_t vaddr, uint64_t size) {
 }
 
 void GpuResourceManager::UnmapMemory(uint64_t vaddr, uint64_t size) {
-	if (CommandScheduler::InDeferredOperation()) {
-		EXIT("unsupported memory unmap from an asynchronous GPU completion, "
-		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
-		     vaddr, size);
-	}
 	const auto unmap = [this, vaddr, size] {
-		if (m_scheduler.Active()) {
-			const auto tick = m_scheduler.CurrentTick();
-			m_scheduler.Finish();
-			m_scheduler.WaitPriorityOperations(tick);
-		}
-		m_buffer_cache.InvalidateMemory(vaddr, size);
+		m_buffer_cache.UnmapMemory(vaddr, size);
 		m_texture_cache.UnmapMemory(vaddr, size);
 		m_page_manager.OnGpuUnmap(vaddr, size);
 		std::lock_guard lock(m_mapped_ranges_mutex);
 		m_mapped_ranges.Subtract(vaddr, size);
 	};
 	if (m_gpu == nullptr) {
+		if (m_resource_mutex.IsOwnedByCurrentThread()) {
+			EXIT("cannot synchronously unmap from a resource transaction\n");
+		}
 		unmap();
 		return;
 	}
+	Gpu::SubmissionLock submissions(*m_gpu);
 	m_gpu->SendCommandSync(unmap);
 }
 
-void GpuResourceManager::PrepareBda() {
-	std::shared_lock lock(m_mapped_ranges_mutex);
-	m_mapped_ranges.ForEach([this](uint64_t start, uint64_t end) {
-		m_buffer_cache.SynchronizeBuffersInRange(start, end - start);
-	});
-	m_fault_process_pending = true;
-}
-
 void GpuResourceManager::RunGarbageCollector() {
-	if (m_fault_process_pending) {
-		m_fault_process_pending = false;
-		m_buffer_cache.ProcessFaultBuffer();
-	}
 	m_texture_cache.ProcessDownloadImages();
 	m_texture_cache.RunGarbageCollector();
 	m_buffer_cache.RunGarbageCollector();

src/graphics/host_gpu/renderer/cache/gpuResourceManager.h

@@ -5,6 +5,7 @@
 #include "common/common.h"
 #include "graphics/host_gpu/pageManager.h"
 #include "graphics/host_gpu/renderer/cache/bufferCache.h"
+#include "graphics/host_gpu/renderer/cache/resourceMutex.h"
 #include "graphics/host_gpu/renderer/cache/textureCache.h"
 
 #include <cstdint>
@@ -13,7 +14,7 @@
 namespace Libs::Graphics {
 
 class CommandScheduler;
-class GuestGpu;
+class Gpu;
 
 class GpuResourceManager {
 public:
@@ -23,25 +24,23 @@ public:
 
 	[[nodiscard]] BufferCache&  GetBufferCache() { return m_buffer_cache; }
 	[[nodiscard]] TextureCache& GetTextureCache() { return m_texture_cache; }
-	void                        SetGpu(GuestGpu* gpu) noexcept { m_gpu = gpu; }
+	void                        SetGpu(Gpu* gpu) noexcept { m_gpu = gpu; }
 
 	[[nodiscard]] bool HandleFault(PageFaultAccess access, uint64_t fault_vaddr) noexcept;
 	[[nodiscard]] bool InvalidateMemory(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] bool IsMapped(uint64_t vaddr, uint64_t size) const noexcept;
 	void               MapMemory(uint64_t vaddr, uint64_t size);
 	void               UnmapMemory(uint64_t vaddr, uint64_t size);
-	void               PrepareBda();
 	void               RunGarbageCollector();
 
 private:
 	PageManager               m_page_manager;
-	CommandScheduler&         m_scheduler;
+	ResourceMutex             m_resource_mutex;
 	BufferCache               m_buffer_cache;
 	TextureCache              m_texture_cache;
 	mutable std::shared_mutex m_mapped_ranges_mutex;
 	RangeSet                  m_mapped_ranges;
-	GuestGpu*                 m_gpu = nullptr;
-	bool                      m_fault_process_pending = false;
+	Gpu*                      m_gpu = nullptr;
 };
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/cache/multiLevelPageTable.h

@@ -7,9 +7,8 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <cstring>
+#include <list>
 #include <memory>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -104,158 +103,6 @@ private:
 	size_t                               m_allocated_buckets = 0;
 };
 
-// Inline owner storage for page-table entries. Texture pages normally have only a
-// handful of owners, so avoid a heap allocation on the first 16 registrations.
-//
-// Owners are packed into live uint64_t objects instead of being constructed in
-// raw storage. This keeps sparse bucket construction cheap without relying on
-// subtle implicit-lifetime or pointer-provenance rules.
-template <typename OwnerT, size_t InlineCapacity = 16>
-class InlinePageOwnerList final {
-public:
-	using value_type = OwnerT;
-	using size_type  = size_t;
-
-	class const_iterator final {
-	public:
-		[[nodiscard]] OwnerT operator*() const noexcept { return m_owners->At(m_index); }
-		const_iterator&      operator++() noexcept {
-			++m_index;
-			return *this;
-		}
-		bool operator==(const const_iterator&) const = default;
-
-	private:
-		friend class InlinePageOwnerList;
-		const_iterator(const InlinePageOwnerList* owners, size_type index) noexcept
-		    : m_owners(owners), m_index(index) {}
-
-		const InlinePageOwnerList* m_owners = nullptr;
-		size_type                  m_index  = 0;
-	};
-
-	static_assert(InlineCapacity > 0);
-	static_assert(std::is_default_constructible_v<OwnerT>);
-	static_assert(std::is_trivially_copyable_v<OwnerT>);
-	static_assert(std::has_unique_object_representations_v<OwnerT>);
-	static_assert(sizeof(OwnerT) <= sizeof(uint64_t));
-
-	InlinePageOwnerList() noexcept {}
-	InlinePageOwnerList(const InlinePageOwnerList&)            = delete;
-	InlinePageOwnerList& operator=(const InlinePageOwnerList&) = delete;
-	InlinePageOwnerList(InlinePageOwnerList&& other) noexcept
-	    : m_overflow(std::move(other.m_overflow)),
-	      m_inline_size(std::exchange(other.m_inline_size, 0)) {
-		if (m_overflow == nullptr) {
-			std::copy_n(other.m_inline.begin(), m_inline_size, m_inline.begin());
-		}
-	}
-	InlinePageOwnerList& operator=(InlinePageOwnerList&& other) noexcept {
-		if (this != &other) {
-			m_overflow    = std::move(other.m_overflow);
-			m_inline_size = std::exchange(other.m_inline_size, 0);
-			if (m_overflow == nullptr) {
-				std::copy_n(other.m_inline.begin(), m_inline_size, m_inline.begin());
-			}
-		}
-		return *this;
-	}
-
-	[[nodiscard]] const_iterator begin() const noexcept { return {this, 0}; }
-	[[nodiscard]] const_iterator end() const noexcept { return {this, size()}; }
-
-	[[nodiscard]] bool      empty() const noexcept { return size() == 0; }
-	[[nodiscard]] size_type size() const noexcept {
-		return m_overflow == nullptr ? m_inline_size : m_overflow->size();
-	}
-	[[nodiscard]] OwnerT front() const noexcept { return At(0); }
-	[[nodiscard]] OwnerT operator[](size_type index) const noexcept { return At(index); }
-
-	void push_back(const OwnerT& owner) {
-		const uint64_t packed = Pack(owner);
-		if (m_overflow != nullptr) {
-			m_overflow->push_back(packed);
-			return;
-		}
-		if (m_inline_size < InlineCapacity) {
-			m_inline[m_inline_size] = packed;
-			++m_inline_size;
-			return;
-		}
-		auto overflow = std::make_unique<std::vector<uint64_t>>();
-		overflow->reserve(InlineCapacity * 2);
-		overflow->assign(m_inline.begin(), m_inline.end());
-		overflow->push_back(packed);
-		m_overflow = std::move(overflow);
-	}
-
-	[[nodiscard]] bool Contains(const OwnerT& owner) const noexcept {
-		const uint64_t packed = Pack(owner);
-		if (m_overflow != nullptr) {
-			return std::find(m_overflow->begin(), m_overflow->end(), packed) != m_overflow->end();
-		}
-		return std::find(m_inline.begin(), m_inline.begin() + static_cast<ptrdiff_t>(m_inline_size),
-		                 packed) != m_inline.begin() + static_cast<ptrdiff_t>(m_inline_size);
-	}
-
-	[[nodiscard]] bool Erase(const OwnerT& owner) noexcept {
-		const uint64_t packed = Pack(owner);
-		if (m_overflow != nullptr) {
-			const auto found = std::find(m_overflow->begin(), m_overflow->end(), packed);
-			if (found == m_overflow->end()) {
-				return false;
-			}
-			m_overflow->erase(found);
-			if (m_overflow->size() == InlineCapacity) {
-				std::copy(m_overflow->begin(), m_overflow->end(), m_inline.begin());
-				m_inline_size = InlineCapacity;
-				m_overflow.reset();
-			}
-			return true;
-		}
-		const auto end   = m_inline.begin() + static_cast<ptrdiff_t>(m_inline_size);
-		const auto found = std::find(m_inline.begin(), end, packed);
-		if (found == end) {
-			return false;
-		}
-		std::move(found + 1, end, found);
-		--m_inline_size;
-		return true;
-	}
-
-	template <typename Func>
-	void ForEach(Func&& func) const {
-		if (m_overflow != nullptr) {
-			for (const uint64_t owner: *m_overflow) {
-				func(Unpack(owner));
-			}
-			return;
-		}
-		for (size_type index = 0; index < m_inline_size; ++index) {
-			func(Unpack(m_inline[index]));
-		}
-	}
-
-private:
-	[[nodiscard]] OwnerT At(size_type index) const noexcept {
-		return Unpack(m_overflow == nullptr ? m_inline[index] : (*m_overflow)[index]);
-	}
-	[[nodiscard]] static uint64_t Pack(const OwnerT& owner) noexcept {
-		uint64_t packed = 0;
-		std::memcpy(&packed, &owner, sizeof(owner));
-		return packed;
-	}
-	[[nodiscard]] static OwnerT Unpack(uint64_t packed) noexcept {
-		OwnerT owner {};
-		std::memcpy(&owner, &packed, sizeof(owner));
-		return owner;
-	}
-
-	std::array<uint64_t, InlineCapacity>   m_inline;
-	std::unique_ptr<std::vector<uint64_t>> m_overflow;
-	size_type                              m_inline_size = 0;
-};
-
 // Removes only the requested owner. Other owners in the same page entry remain intact.
 template <typename Container, typename Value>
 [[nodiscard]] bool EraseExact(Container& owners, const Value& owner) {
@@ -267,6 +114,247 @@ template <typename Container, typename Value>
 	return true;
 }
 
+// Multi-range ownership with 1 MiB candidate buckets and precise 4 KiB
+// lifetime accounting. OwnerT only needs equality.
+template <typename OwnerT>
+class MultiRangePageOwnerIndex final {
+private:
+	struct Registration;
+	using MembershipList = std::vector<const Registration*>;
+
+public:
+	struct ByteRange final {
+		uint64_t address = 0;
+		uint64_t size    = 0;
+	};
+
+	using CoarseTable   = MultiLevelPageTable<MembershipList, 20, 40, 10>;
+	using TrackingTable = MultiLevelPageTable<MembershipList, 12, 40, 18>;
+
+	[[nodiscard]] bool Register(const OwnerT& owner, const std::vector<ByteRange>& ranges) {
+		if (FindRegistration(owner) != m_registrations.end()) {
+			return false;
+		}
+		auto normalized = Normalize(ranges);
+		if (normalized.empty()) {
+			return false;
+		}
+		m_registrations.push_back({owner, std::move(normalized)});
+		const Registration* registration = &m_registrations.back();
+		for (const size_t page: CollectPages<20>(registration->ranges)) {
+			m_coarse_pages[page].push_back(registration);
+		}
+		for (const size_t page: CollectPages<12>(registration->ranges)) {
+			m_tracking_pages[page].push_back(registration);
+		}
+		return true;
+	}
+
+	// No state changes if an expected membership is absent. Final releases are
+	// sorted and coalesced 4 KiB spans whose final owner disappeared.
+	[[nodiscard]] bool Unregister(const OwnerT& owner, std::vector<ByteRange>& final_releases) {
+		final_releases.clear();
+		auto registration = FindRegistration(owner);
+		if (registration == m_registrations.end()) {
+			return false;
+		}
+		const auto          coarse_pages     = CollectPages<20>(registration->ranges);
+		const auto          tracking_pages   = CollectPages<12>(registration->ranges);
+		const Registration* registration_ptr = &*registration;
+		if (!HasAllMemberships(m_coarse_pages, coarse_pages, registration_ptr) ||
+		    !HasAllMemberships(m_tracking_pages, tracking_pages, registration_ptr)) {
+			return false;
+		}
+		std::vector<size_t> final_pages;
+		for (const size_t page: coarse_pages) {
+			(void)EraseExact(*m_coarse_pages.Find(page), registration_ptr);
+		}
+		for (const size_t page: tracking_pages) {
+			auto& owners = *m_tracking_pages.Find(page);
+			if (owners.size() == 1) {
+				final_pages.push_back(page);
+			}
+			(void)EraseExact(owners, registration_ptr);
+		}
+		m_registrations.erase(registration);
+		final_releases = CoalesceTrackingPages(final_pages);
+		return true;
+	}
+
+	[[nodiscard]] std::vector<OwnerT> Query(uint64_t address, uint64_t size) const {
+		return Query(address, size, [](const OwnerT&) { return true; });
+	}
+
+	template <typename Predicate>
+	[[nodiscard]] std::vector<OwnerT> Query(uint64_t address, uint64_t size,
+	                                        Predicate&& predicate) const {
+		return QueryImpl(address, size, true, std::forward<Predicate>(predicate));
+	}
+
+	// Fault paths use page candidates: exact byte-disjoint owners sharing a
+	// touched 4 KiB page are intentionally retained.
+	[[nodiscard]] std::vector<OwnerT> QueryCandidates(uint64_t address, uint64_t size) const {
+		return QueryCandidates(address, size, [](const OwnerT&) { return true; });
+	}
+
+	template <typename Predicate>
+	[[nodiscard]] std::vector<OwnerT> QueryCandidates(uint64_t address, uint64_t size,
+	                                                  Predicate&& predicate) const {
+		return QueryImpl(address, size, false, std::forward<Predicate>(predicate));
+	}
+
+	[[nodiscard]] size_t CoarseMembershipCount(size_t page) const {
+		const auto* owners = m_coarse_pages.Find(page);
+		return owners == nullptr ? 0 : owners->size();
+	}
+	[[nodiscard]] size_t TrackingMembershipCount(size_t page) const {
+		const auto* owners = m_tracking_pages.Find(page);
+		return owners == nullptr ? 0 : owners->size();
+	}
+
+private:
+	template <typename Predicate>
+	[[nodiscard]] std::vector<OwnerT> QueryImpl(uint64_t address, uint64_t size, bool strict_bytes,
+	                                            Predicate&& predicate) const {
+		typename CoarseTable::PageRange   coarse_range {};
+		typename TrackingTable::PageRange tracking_range {};
+		if (!CoarseTable::TryGetPageRange(address, size, coarse_range) ||
+		    !TrackingTable::TryGetPageRange(address, size, tracking_range)) {
+			return {};
+		}
+		MembershipList candidates;
+		for (size_t page = coarse_range.first; page < coarse_range.last_exclusive; ++page) {
+			if (const auto* owners = m_coarse_pages.Find(page); owners != nullptr) {
+				AppendUnique(candidates, *owners);
+			}
+		}
+		std::vector<OwnerT> result;
+		for (const Registration* registration: candidates) {
+			if ((!strict_bytes || Overlaps(registration->ranges, address, size)) &&
+			    HasTrackingMembership(registration, tracking_range) &&
+			    predicate(registration->owner)) {
+				result.push_back(registration->owner);
+			}
+		}
+		return result;
+	}
+
+	struct Registration final {
+		OwnerT                 owner;
+		std::vector<ByteRange> ranges;
+	};
+	using RegistrationIterator      = typename std::list<Registration>::iterator;
+	using ConstRegistrationIterator = typename std::list<Registration>::const_iterator;
+
+	[[nodiscard]] RegistrationIterator FindRegistration(const OwnerT& owner) {
+		return std::find_if(m_registrations.begin(), m_registrations.end(),
+		                    [&](const Registration& item) { return item.owner == owner; });
+	}
+	[[nodiscard]] ConstRegistrationIterator FindRegistration(const OwnerT& owner) const {
+		return std::find_if(m_registrations.begin(), m_registrations.end(),
+		                    [&](const Registration& item) { return item.owner == owner; });
+	}
+
+	[[nodiscard]] static std::vector<ByteRange> Normalize(const std::vector<ByteRange>& ranges) {
+		std::vector<ByteRange> sorted;
+		for (const auto& range: ranges) {
+			typename CoarseTable::PageRange ignored {};
+			if (!CoarseTable::TryGetPageRange(range.address, range.size, ignored)) {
+				return {};
+			}
+			sorted.push_back(range);
+		}
+		std::sort(sorted.begin(), sorted.end(), [](const ByteRange& lhs, const ByteRange& rhs) {
+			return lhs.address < rhs.address;
+		});
+		std::vector<ByteRange> merged;
+		for (const auto& range: sorted) {
+			if (merged.empty() || range.address > merged.back().address + merged.back().size) {
+				merged.push_back(range);
+			} else {
+				const uint64_t end = std::max(merged.back().address + merged.back().size,
+				                              range.address + range.size);
+				merged.back().size = end - merged.back().address;
+			}
+		}
+		return merged;
+	}
+
+	template <size_t Bits>
+	[[nodiscard]] static std::vector<size_t> CollectPages(const std::vector<ByteRange>& ranges) {
+		std::vector<size_t> pages;
+		for (const auto& range: ranges) {
+			const size_t first = static_cast<size_t>(range.address >> Bits);
+			const size_t last  = static_cast<size_t>((range.address + range.size - 1) >> Bits);
+			for (size_t page = first; page <= last; ++page) {
+				pages.push_back(page);
+			}
+		}
+		std::sort(pages.begin(), pages.end());
+		pages.erase(std::unique(pages.begin(), pages.end()), pages.end());
+		return pages;
+	}
+
+	template <typename Table>
+	[[nodiscard]] static bool HasAllMemberships(const Table&               table,
+	                                            const std::vector<size_t>& pages,
+	                                            const Registration*        registration) {
+		for (const size_t page: pages) {
+			const auto* owners = table.Find(page);
+			if (owners == nullptr ||
+			    std::find(owners->begin(), owners->end(), registration) == owners->end()) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	[[nodiscard]] bool HasTrackingMembership(const Registration*                      registration,
+	                                         const typename TrackingTable::PageRange& range) const {
+		for (size_t page = range.first; page < range.last_exclusive; ++page) {
+			const auto* owners = m_tracking_pages.Find(page);
+			if (owners != nullptr &&
+			    std::find(owners->begin(), owners->end(), registration) != owners->end()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	[[nodiscard]] static bool Overlaps(const std::vector<ByteRange>& ranges, uint64_t address,
+	                                   uint64_t size) {
+		const uint64_t end = address + size;
+		return std::any_of(ranges.begin(), ranges.end(), [&](const ByteRange& range) {
+			return range.address < end && address < range.address + range.size;
+		});
+	}
+	static void AppendUnique(MembershipList& destination, const MembershipList& source) {
+		for (const Registration* registration: source) {
+			if (std::find(destination.begin(), destination.end(), registration) ==
+			    destination.end()) {
+				destination.push_back(registration);
+			}
+		}
+	}
+	[[nodiscard]] static std::vector<ByteRange>
+	CoalesceTrackingPages(const std::vector<size_t>& pages) {
+		std::vector<ByteRange> result;
+		for (const size_t page: pages) {
+			const uint64_t address = static_cast<uint64_t>(page) << 12;
+			if (!result.empty() && result.back().address + result.back().size == address) {
+				result.back().size += uint64_t {1} << 12;
+			} else {
+				result.push_back({address, uint64_t {1} << 12});
+			}
+		}
+		return result;
+	}
+
+	CoarseTable             m_coarse_pages;
+	TrackingTable           m_tracking_pages;
+	std::list<Registration> m_registrations;
+};
+
 } // namespace Libs::Graphics
 
 #endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_

src/graphics/host_gpu/renderer/cache/resourceMutex.cpp

@@ -0,0 +1,93 @@
+#include "graphics/host_gpu/renderer/cache/resourceMutex.h"
+
+#include "common/assert.h"
+
+namespace Libs::Graphics {
+
+ResourceMutex::FaultScope::FaultScope(ResourceMutex& mutex): m_mutex(mutex) {
+	m_resource_preowned = m_mutex.BeginFault();
+}
+
+ResourceMutex::FaultScope::~FaultScope() {
+	m_mutex.EndFault(m_resource_preowned);
+}
+
+ResourceMutex::~ResourceMutex() {
+	std::lock_guard state(m_state);
+	if (m_resource_owner != std::thread::id {} || m_fault_owner != std::thread::id {}) {
+		EXIT("ResourceMutex destroyed with an active owner or fault transaction\n");
+	}
+}
+
+void ResourceMutex::lock() {
+	const auto current = std::this_thread::get_id();
+	{
+		std::lock_guard state(m_state);
+		if (m_resource_owner == current) {
+			EXIT("recursive resource transaction\n");
+		}
+		if (m_fault_owner == current) {
+			EXIT("resource transaction re-entered from a page-fault callback\n");
+		}
+	}
+	m_resource.lock();
+	std::lock_guard state(m_state);
+	if (m_resource_owner != std::thread::id {}) {
+		EXIT("resource mutex acquired with a stale owner\n");
+	}
+	m_resource_owner = current;
+}
+
+void ResourceMutex::unlock() {
+	const auto current = std::this_thread::get_id();
+	{
+		std::lock_guard state(m_state);
+		if (m_resource_owner != current) {
+			EXIT("resource transaction released without ownership\n");
+		}
+		m_resource_owner = {};
+	}
+	m_resource.unlock();
+}
+
+bool ResourceMutex::IsOwnedByCurrentThread() {
+	std::lock_guard state(m_state);
+	return m_resource_owner == std::this_thread::get_id();
+}
+
+bool ResourceMutex::BeginFault() {
+	const auto current = std::this_thread::get_id();
+	{
+		std::lock_guard state(m_state);
+		if (m_fault_owner == current) {
+			EXIT("nested resource page-fault transaction\n");
+		}
+		if (m_resource_owner == current) {
+			m_fault_owner = current;
+			return true;
+		}
+	}
+	lock();
+	std::lock_guard state(m_state);
+	if (m_resource_owner != current || m_fault_owner != std::thread::id {}) {
+		EXIT("resource fault transaction acquired inconsistent ownership\n");
+	}
+	m_fault_owner = current;
+	return false;
+}
+
+void ResourceMutex::EndFault(bool resource_preowned) {
+	const auto current = std::this_thread::get_id();
+	{
+		std::lock_guard state(m_state);
+		if (m_fault_owner != current || m_resource_owner != current) {
+			EXIT("resource page-fault transaction ended with inconsistent ownership\n");
+		}
+		m_fault_owner = {};
+	}
+	if (!resource_preowned) {
+		unlock();
+	}
+}
+
+} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/cache/resourceMutex.h

@@ -0,0 +1,48 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_RESOURCEMUTEX_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_RESOURCEMUTEX_H_
+
+#include "common/common.h"
+
+#include <mutex>
+#include <thread>
+
+namespace Libs::Graphics {
+
+// Owner-tracked shared buffer/image transaction. External faults pause GPU submissions first;
+// command-processor faults drain pending guest processors before entering this transaction.
+class ResourceMutex final {
+public:
+	class FaultScope final {
+	public:
+		explicit FaultScope(ResourceMutex& mutex);
+		~FaultScope();
+		KYTY_CLASS_NO_COPY(FaultScope);
+
+	private:
+		ResourceMutex& m_mutex;
+		bool           m_resource_preowned = false;
+	};
+
+	ResourceMutex() = default;
+	~ResourceMutex();
+	KYTY_CLASS_NO_COPY(ResourceMutex);
+
+	void               lock();
+	void               unlock();
+	[[nodiscard]] bool IsOwnedByCurrentThread();
+
+private:
+	friend class FaultScope;
+
+	[[nodiscard]] bool BeginFault();
+	void               EndFault(bool resource_preowned);
+
+	std::mutex      m_resource;
+	std::mutex      m_state;
+	std::thread::id m_resource_owner;
+	std::thread::id m_fault_owner;
+};
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_RESOURCEMUTEX_H_

src/graphics/host_gpu/renderer/cache/streamBuffer.cpp

@@ -73,12 +73,8 @@ Buffer::Buffer(GraphicContext& graphics, CommandScheduler& scheduler, MemoryUsag
 	buffer_info.usage       = flags;
 	buffer_info.sharingMode = vk::SharingMode::eExclusive;
 
-	const bool with_bda = bool(flags & vk::BufferUsageFlagBits::eShaderDeviceAddress);
-	const VmaAllocationCreateFlags bda_flag =
-	    with_bda ? VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT : 0;
 	VmaAllocationCreateInfo allocation_info {};
-	allocation_info.flags =
-	    VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | bda_flag | AllocationFlags(usage);
+	allocation_info.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | AllocationFlags(usage);
 	allocation_info.usage = AllocationUsage(usage);
 	allocation_info.preferredFlags = usage == MemoryUsage::DeviceLocal
 	                                     ? VkMemoryPropertyFlags {}
@@ -103,13 +99,6 @@ Buffer::Buffer(GraphicContext& graphics, CommandScheduler& scheduler, MemoryUsag
 	m_buffer->memory.type            = allocation_result.memoryType;
 	m_buffer->memory.unique_id       = VulkanNextMemoryUniqueId();
 	graphics.device.getBufferMemoryRequirements(m_buffer->buffer, &m_buffer->memory.requirements);
-	if (static_cast<bool>(flags & vk::BufferUsageFlagBits::eShaderDeviceAddress)) {
-		vk::BufferDeviceAddressInfo address_info {};
-		address_info.sType  = vk::StructureType::eBufferDeviceAddressInfo;
-		address_info.buffer = m_buffer->buffer;
-		m_device_address    = graphics.device.getBufferAddress(address_info);
-		EXIT_IF(m_device_address == 0);
-	}
 
 	VkMemoryPropertyFlags properties = 0;
 	vmaGetAllocationMemoryProperties(graphics.allocator, m_buffer->memory.allocation, &properties);
@@ -133,11 +122,6 @@ vk::Buffer Buffer::Handle() const noexcept {
 	return m_buffer->buffer;
 }
 
-vk::DeviceAddress Buffer::BufferDeviceAddress() const noexcept {
-	EXIT_IF(m_device_address == 0);
-	return m_device_address;
-}
-
 bool Buffer::IsInBounds(uint64_t address, uint64_t size) const noexcept {
 	return address >= m_cpu_address && size <= m_size && address - m_cpu_address <= m_size - size;
 }
@@ -157,15 +141,6 @@ void Buffer::Flush(uint64_t offset, uint64_t size) {
 	}
 }
 
-void Buffer::Invalidate(uint64_t offset, uint64_t size) {
-	EXIT_IF(m_usage != MemoryUsage::Download || offset > m_size || size > m_size - offset);
-	if (!m_is_coherent && size != 0) {
-		const auto result =
-		    vmaInvalidateAllocation(m_graphics->allocator, m_buffer->memory.allocation, offset, size);
-		EXIT_NOT_IMPLEMENTED(static_cast<vk::Result>(result) != vk::Result::eSuccess);
-	}
-}
-
 vk::BufferMemoryBarrier Buffer::Barrier(uint64_t offset, uint64_t size, vk::AccessFlags source,
                                         vk::AccessFlags destination) const {
 	if (Handle() == nullptr || size == 0 || offset > m_size || size > m_size - offset) {
@@ -335,6 +310,16 @@ void StreamBuffer::Commit() {
 	watch.tick        = tick;
 }
 
+void StreamBuffer::Invalidate(uint64_t offset, uint64_t size) {
+	EXIT_IF(Usage() != MemoryUsage::Download || offset > Size() || size > Size() - offset);
+	if (IsCoherent() || size == 0) {
+		return;
+	}
+	const auto result = vmaInvalidateAllocation(Graphics().allocator,
+	                                            NativeBuffer().memory.allocation, offset, size);
+	EXIT_NOT_IMPLEMENTED(static_cast<vk::Result>(result) != vk::Result::eSuccess);
+}
+
 uint64_t StreamBuffer::Copy(const void* source, uint64_t size, uint64_t alignment) {
 	EXIT_IF(source == nullptr);
 	const auto [data, offset] = Map(size, alignment);

src/graphics/host_gpu/renderer/cache/streamBuffer.h

@@ -48,14 +48,12 @@ public:
 	[[nodiscard]] bool               IsCoherent() const noexcept { return m_is_coherent; }
 	[[nodiscard]] MemoryUsage        Usage() const noexcept { return m_usage; }
 	[[nodiscard]] uint64_t           CpuAddress() const noexcept { return m_cpu_address; }
-	[[nodiscard]] vk::DeviceAddress BufferDeviceAddress() const noexcept;
 	[[nodiscard]] uint64_t           Offset(uint64_t address) const noexcept {
 		return address - m_cpu_address;
 	}
 	[[nodiscard]] bool IsInBounds(uint64_t address, uint64_t size) const noexcept;
 	void               Write(uint64_t offset, const void* source, uint64_t size);
 	void               Flush(uint64_t offset, uint64_t size);
-	void               Invalidate(uint64_t offset, uint64_t size);
 	void CopyFrom(CommandBuffer& command, const Buffer& source, uint64_t source_offset,
 	              uint64_t destination_offset, uint64_t size,
 	              vk::AccessFlags source_before      = vk::AccessFlagBits::eMemoryWrite,
@@ -67,10 +65,6 @@ public:
 	                                                   vk::AccessFlagBits::eMemoryWrite);
 	void Fill(uint64_t offset, uint64_t size, uint32_t value);
 
-	// BufferCache state lives directly on the resource.
-	bool   is_deleted = false;
-	size_t lru_id     = 0;
-
 protected:
 	[[nodiscard]] GraphicContext&   Graphics() const noexcept { return *m_graphics; }
 	[[nodiscard]] CommandScheduler& Scheduler() const noexcept { return *m_scheduler; }
@@ -86,7 +80,6 @@ private:
 	MemoryUsage                   m_usage       = MemoryUsage::DeviceLocal;
 	uint64_t                      m_cpu_address = 0;
 	uint64_t                      m_size        = 0;
-	vk::DeviceAddress             m_device_address = 0;
 	std::unique_ptr<VulkanBuffer> m_buffer;
 	std::span<uint8_t>            m_mapped;
 	bool                          m_is_coherent = false;
@@ -100,6 +93,9 @@ public:
 	[[nodiscard]] std::pair<uint8_t*, uint64_t> Map(uint64_t size, uint64_t alignment = 0,
 	                                                bool allow_wait = true);
 	void                                        Commit();
+	// Download mappings become visible to the CPU only after their GPU completion tick is free.
+	// Call this from the scheduler's deferred completion operation before reading Mapped().
+	void                   Invalidate(uint64_t offset, uint64_t size);
 	[[nodiscard]] uint64_t Copy(const void* source, uint64_t size, uint64_t alignment = 0);
 
 private:

src/graphics/host_gpu/renderer/cache/textureCache.h

@@ -4,17 +4,19 @@
 #include "common/abi.h"
 #include "common/common.h"
 #include "common/lruCache.h"
-#include "common/slotVector.h"
 #include "graphics/host_gpu/pageManager.h"
 #include "graphics/host_gpu/regionManager.h"
 #include "graphics/host_gpu/renderer/cache/multiLevelPageTable.h"
 #include "graphics/host_gpu/renderer/image/blitHelper.h"
 #include "graphics/host_gpu/renderer/image/image.h"
-#include "graphics/host_gpu/renderer/image/tiler.h"
 
+#include <compare>
 #include <map>
-#include <unordered_map>
-#include <unordered_set>
+#include <memory>
+#include <optional>
+#include <set>
+#include <span>
+#include <utility>
 #include <vector>
 
 namespace Libs::Graphics {
@@ -24,7 +26,10 @@ class Buffer;
 class BufferCache;
 class CommandBuffer;
 class CommandScheduler;
+class ResourceMutex;
 class RenderExecutor;
+class StreamBuffer;
+class TileManager;
 struct TextureCacheTestAccess;
 
 class TextureCache {
@@ -44,37 +49,31 @@ public:
 	};
 
 	TextureCache(GraphicContext& graphics, CommandScheduler& scheduler, PageManager& page_manager,
-	             BufferCache& buffer_cache);
+	             BufferCache& buffer_cache, ResourceMutex& resource_mutex);
 	~TextureCache();
 	KYTY_CLASS_NO_COPY(TextureCache);
 
 	[[nodiscard]] ImageId       FindImage(ImageDesc& desc, bool exact_format = false);
-	void                        UpdateImage(ImageId id);
 	[[nodiscard]] ImageId       FindImageFromRange(uint64_t address, uint64_t size,
 	                                               bool ensure_valid = true);
 	[[nodiscard]] vk::ImageView FindTexture(ImageId id, const ImageDesc& desc);
 	[[nodiscard]] vk::ImageView FindRenderTarget(ImageId id, const ImageDesc& desc);
 	[[nodiscard]] vk::ImageView FindDepthTarget(ImageId id, const ImageDesc& desc);
-	[[nodiscard]] Image&        GetImage(ImageId id) {
-		auto& image = m_slot_images[id];
-		TouchImage(image);
-		return image;
-	}
-	void MarkGpuWritten(ImageId id);
+	[[nodiscard]] Image&        GetImage(ImageId id);
+	[[nodiscard]] const Image&  GetImage(ImageId id) const;
+	void                        MarkGpuWritten(ImageId id);
 
 	[[nodiscard]] bool ClearImageFromBuffer(CommandBuffer& command, uint64_t address, uint64_t size,
 	                                        uint32_t packed_clear);
 	void               InvalidateMemory(uint64_t address, uint64_t size);
-	void               InvalidateMemoryFromGPU(uint64_t address, uint64_t size);
+	[[nodiscard]] bool SynchronizeImageToBuffer(uint64_t address, uint64_t size);
+	[[nodiscard]] bool InvalidateMemoryFromGPU(uint64_t address, uint64_t size,
+	                                           bool formatted_buffer_write = false);
 	[[nodiscard]] RegionInfo QueryRegion(uint64_t address, uint64_t size);
 
 	[[nodiscard]] bool IsMeta(uint64_t address);
-	[[nodiscard]] bool IsMetaCleared(uint64_t address, uint32_t slice,
-	                                 uint32_t* fill_value = nullptr);
+	[[nodiscard]] bool IsMetaCleared(uint64_t address, uint32_t slice);
 	[[nodiscard]] bool ClearMeta(uint64_t address);
-	// Returns true when registered DCC absorbed the fill and the caller may skip the dispatch.
-	// False may still record PendingDcc state, but the guest dispatch must execute.
-	[[nodiscard]] bool TryConsumeDccFill(uint64_t address, uint64_t size, uint32_t fill_value);
 	[[nodiscard]] bool TouchMeta(uint64_t address, uint32_t slice, bool is_clear);
 
 	void UnmapMemory(uint64_t address, uint64_t size);
@@ -86,18 +85,13 @@ private:
 	struct ColorTransferPlan;
 	struct DownloadPlan;
 
-	struct MetaDataInfo {
-		// A guest metadata-fill dispatch may initialize DCC before its render target is bound.
-		// PendingDcc retains that exact fill until FindRenderTarget classifies the address,
-		// without exposing an unconfirmed buffer address to the normal metadata heuristics.
-		// Keep all surface metadata in one entry so CMask/FMask can be
-		// registered beside HTile and DCC without introducing parallel tracking paths.
-		enum class Type : uint8_t { PendingDcc, CMask, FMask, HTile, Dcc };
+	struct Slot {
+		std::shared_ptr<Image> image;
+		uint32_t               generation = 1;
+	};
 
-		Type     type       = Type::PendingDcc;
+	struct MetaDataInfo {
 		uint32_t clear_mask = 0;
-		uint32_t fill_value = 0xffffffffu;
-		uint64_t fill_size  = 0;
 	};
 
 	struct OverlapResult {
@@ -106,32 +100,34 @@ private:
 		int32_t layer = -1;
 	};
 
-	using ImageIds       = InlinePageOwnerList<ImageId, 16>;
-	using ImagePageTable = MultiLevelPageTable<ImageIds, 20, 40, 10>;
+	using ImageOwnerIndex = MultiRangePageOwnerIndex<ImageId>;
 
-	[[nodiscard]] ImageId     InsertImage(const ImageInfo& info);
-	[[nodiscard]] ImageId     GetNullImage(const ImageDesc& desc);
-	void                      RegisterImage(ImageId id);
-	void                      UnregisterImage(ImageId id);
-	void                      DeleteImage(ImageId id);
-	void                      FreeImage(ImageId id);
-	void                      TouchImage(Image& image);
-	void                      TrackImage(ImageId id);
-	void                      TrackImageHead(ImageId id);
-	void                      TrackImageTail(ImageId id);
-	void                      UntrackImage(ImageId id);
-	void                      UntrackImageHead(ImageId id);
-	void                      UntrackImageTail(ImageId id);
-	void                      MarkAsMaybeDirty(ImageId id, Image& image);
-	void                      TrackImageDownload(ImageId id, Image& image);
+	[[nodiscard]] Image&                 ResolveImage(ImageId id);
+	[[nodiscard]] const Image&           ResolveImage(ImageId id) const;
+	[[nodiscard]] std::shared_ptr<Image> ResolveOwner(ImageId id) const;
+	[[nodiscard]] ImageId                InsertImage(const ImageInfo& info);
+	[[nodiscard]] ImageId                GetNullImage(const ImageDesc& desc);
+	void                                 RegisterImage(ImageId id);
+	void                                 UnregisterImage(ImageId id);
+	void                                 DeleteImage(ImageId id);
+	void DeleteImages(std::span<const ImageId> ids, std::optional<ImageId> native_source = {});
+	void RetainImage(CommandBuffer& command, ImageId id);
+	void TouchImage(Image& image);
+	void TrackImage(ImageId id);
+	void TrackImageHead(ImageId id);
+	void TrackImageTail(ImageId id);
+	void UntrackImage(ImageId id);
+	void UntrackImageHead(ImageId id);
+	void UntrackImageTail(ImageId id);
+	void TrackImageDownload(ImageId id);
+	void TrackImageDownloadLocked(ImageId id, Image& image);
 	[[nodiscard]] static bool SameBacking(const ImageInfo& cached, const ImageInfo& requested,
 	                                      bool exact_format);
 	[[nodiscard]] static BindingType UploadBinding(const Image& image);
 	[[nodiscard]] bool               SafeToDownload(const Image& image);
 
-	// Caller holds m_lock; it also serializes the per-image query epoch.
-	[[nodiscard]] ImageIds      FindImagesInRegion(uint64_t address, uint64_t size,
-	                                               bool page_overlap) const;
+	[[nodiscard]] std::vector<ImageId> FindImagesInRegion(uint64_t address, uint64_t size,
+	                                                      bool page_overlap) const;
 	[[nodiscard]] OverlapResult ResolveOverlap(const ImageInfo& requested, BindingType binding,
 	                                           ImageId cached, ImageId merged);
 	[[nodiscard]] ImageId       ResolveDepthOverlap(const ImageInfo& requested, BindingType binding,
@@ -144,7 +140,7 @@ private:
 	[[nodiscard]] DownloadPlan      BuildDownload(const Image& image) const;
 	void UploadImage(Image& image, const ImageDesc& desc, Buffer& source, uint64_t source_offset);
 	void DownloadImageData(Image& image, Buffer& destination, uint64_t destination_offset,
-	                       uint64_t destination_size, DownloadPlan plan);
+	                       DownloadPlan plan);
 	void DownloadDepth(Image& image, Buffer& destination, uint64_t destination_offset);
 	void CommitGpuWrite(Image& image);
 	void PrepareImageCopy(Image& image);
@@ -152,35 +148,42 @@ private:
 	[[nodiscard]] bool CopyD16(Image& destination, Image& source);
 	void               CopyImage(ImageId destination, ImageId source);
 	void               AssociateStencil(ImageId depth, GuestRange stencil);
+	void               AssociateStencilLocked(ImageId depth, GuestRange stencil);
 	void CopyImageMip(ImageId destination, ImageId source, uint32_t mip, uint32_t layer);
 	void ValidateImageDesc(const ImageDesc& desc) const;
 
-	void               InvalidateCpuAliases(uint64_t address, uint64_t size);
-	[[nodiscard]] bool TryDownloadImage(ImageId id);
+	void InvalidateCpuAliases(uint64_t address, uint64_t size);
+	void ClearGpuModified(ImageId id);
+
+	[[nodiscard]] bool                          SynchronizeImageToBuffer(ImageId id);
+	void                                        DownloadImage(ImageId id);
+	[[nodiscard]] bool                          TryDownloadImage(ImageId id);
+	[[nodiscard]] std::pair<uint8_t*, uint64_t> MapDownload(uint64_t size, uint64_t alignment);
+	void QueueDownload(GuestRange range, StreamBuffer& download, uint8_t* mapped, uint64_t offset);
 
 	GraphicContext&                                   m_graphics;
 	CommandScheduler&                                 m_scheduler;
 	TrackingSpinLock                                  m_lock;
 	PageManager&                                      m_page_manager;
 	BlitHelper                                        m_blit_helper;
-	TileManager                                       m_tiler;
+	std::unique_ptr<TileManager>                      m_tiler;
 	BufferCache&                                      m_buffer_cache;
-	Common::SlotVector<Image>                         m_slot_images;
-	ImagePageTable                                    m_image_page_table;
-	std::unordered_map<vk::Format, ImageId>           m_null_images;
+	ResourceMutex&                                    m_resource_mutex;
+	std::vector<Slot>                                 m_slots;
+	std::vector<uint32_t>                             m_free_slots;
+	ImageOwnerIndex                                   m_image_owner_index;
+	std::map<vk::Format, ImageId>                     m_null_images;
 	Common::LeastRecentlyUsedCache<ImageId, uint64_t> m_lru_cache;
-	std::unordered_set<ImageId>                       m_download_images;
+	std::set<ImageId>                                 m_download_images;
 	std::map<uint64_t, MetaDataInfo>                  m_surface_metas;
 	uint64_t                                          m_total_used_memory  = 0;
 	uint64_t                                          m_trigger_gc_memory  = 0;
 	uint64_t                                          m_pressure_gc_memory = 1536ull * 1024 * 1024;
-	uint64_t         m_critical_gc_memory     = 3ull * 1024 * 1024 * 1024;
-	uint64_t         m_gc_tick                = 0;
-	mutable uint32_t m_image_query_epoch      = 0;
-	bool             m_readback_linear_images = false;
+	uint64_t m_critical_gc_memory     = 3ull * 1024 * 1024 * 1024;
+	uint64_t m_gc_tick                = 0;
+	bool     m_readback_linear_images = false;
 
 	friend struct TextureCacheTestAccess;
-	friend class BufferCache;
 	friend class RenderExecutor;
 };
 

src/graphics/host_gpu/renderer/colorRenderTarget.cpp

@@ -9,42 +9,20 @@
 #include "graphics/host_gpu/graphicContext.h"
 #include "graphics/host_gpu/renderer/debug.h"
 #include "graphics/host_gpu/renderer/image/textureCommon.h"
+#include "graphics/host_gpu/renderer/pipeline/descriptorCache.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vulkanCommon.h"
 
 #include <algorithm>
-#include <array>
 #include <atomic>
 
 namespace Libs::Graphics {
 
 static std::atomic<uint32_t> g_render_color_log_count = 0;
 
-static void ResolveDccClearInfo(RenderColorInfo& info, vk::Format format, bool has_dcc,
-                                uint32_t packed_clear) {
-	// Register-backed DCC clears use the target's packed clear value. Decode one-word guest
-	// formats here; unsupported encodings remain tracked without unsafe materialization.
-	info.metadata_clear_supported =
-	    has_dcc && DecodePackedColorClear(format, packed_clear, info.color_clear_value);
-	switch (format) {
-		case vk::Format::eR8G8B8A8Unorm:
-		case vk::Format::eR8G8B8A8Srgb:
-		case vk::Format::eB8G8R8A8Unorm:
-		case vk::Format::eB8G8R8A8Srgb:
-		case vk::Format::eA2B10G10R10UnormPack32:
-		case vk::Format::eA2R10G10B10UnormPack32:
-			info.metadata_fixed_clear_supported = has_dcc;
-			break;
-		default: info.metadata_fixed_clear_supported = false; break;
-	}
-	if (!info.metadata_clear_supported) {
-		info.color_clear_value = {};
-	}
-}
-
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
-void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer& buffer,
+void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer,
                                               RenderColorInfo& r,
                                               uint32_t         render_target_slice_offset,
                                               uint32_t render_target_slot, bool ignore_target_mask,
@@ -77,22 +55,20 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 		}
 
 		// No color output
-		r.type                           = RenderColorType::NoColorOutput;
-		r.desc                           = {};
-		r.base_addr                      = 0;
-		r.image_id                       = {};
-		r.image_view                     = nullptr;
-		r.format                         = vk::Format::eUndefined;
-		r.extent                         = {};
-		r.base_mip_level                 = 0;
-		r.base_array_layer               = 0;
-		r.buffer_size                    = 0;
-		r.samples                        = 1;
-		r.export_mapping                 = {};
-		r.color_clear_enable             = false;
-		r.metadata_clear_supported       = false;
-		r.metadata_fixed_clear_supported = false;
-		r.color_clear_value              = {};
+		r.type               = RenderColorType::NoColorOutput;
+		r.desc               = {};
+		r.base_addr          = 0;
+		r.image_id           = {};
+		r.image_view         = nullptr;
+		r.format             = vk::Format::eUndefined;
+		r.extent             = {};
+		r.base_mip_level     = 0;
+		r.base_array_layer   = 0;
+		r.buffer_size        = 0;
+		r.samples            = 1;
+		r.export_mapping     = {};
+		r.color_clear_enable = false;
+		r.color_clear_value  = {};
 		return;
 	}
 	const auto samples = render_sample_count(rt.attrib.num_fragments);
@@ -125,15 +101,14 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 			     " attrib3_tile=0x%08" PRIx32 " attrib3_dim=0x%08" PRIx32 " fmt=0x%08" PRIx32
 			     " nfmt=0x%08" PRIx32 " order=0x%08" PRIx32 "\n",
 			     rt_slot, rt.base.addr, mask, rt.attrib2.width, rt.attrib2.height,
-			     static_cast<uint32_t>(rt.attrib3.tile_mode), rt.attrib3.dimension,
-			     static_cast<uint32_t>(rt.info.format), static_cast<uint32_t>(rt.info.channel_type),
-			     static_cast<uint32_t>(rt.info.channel_order));
+			     rt.attrib3.tile_mode, rt.attrib3.dimension, rt.info.format, rt.info.channel_type,
+			     rt.info.channel_order);
 		}
 	}
 
-	// Color-control state selects the color-buffer operation and logical blend operation.
-	// The normal copy operation is a regular color write, not an attachment clear.
-	// Nonlinear clear values are still stored as normalized components.
+	// CB_COLOR_CONTROL describes the color-buffer operation / ROP3 logic op.
+	// ROP3 Copy is the normal color write path, not a render-target clear.
+	// SRGB clear words are still encoded as normalized component values.
 	// Fast color clears are metadata driven and must be handled explicitly when
 	// that metadata path is implemented; render-pass load must preserve contents.
 	r.color_clear_enable = false;
@@ -144,42 +119,16 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 	uint32_t   pitch  = 0;
 	uint64_t   size   = 0;
 	bool       tile   = false;
-	static constexpr std::array image_types {Prospero::ImageType::kColor1D,
-	                                         Prospero::ImageType::kColor2D,
-	                                         Prospero::ImageType::kColor3D};
-	if (rt.attrib3.dimension >= image_types.size()) {
-		EXIT("unsupported render-target dimension: %u\n", rt.attrib3.dimension);
-	}
-	const auto image_type = image_types[rt.attrib3.dimension];
-	const bool is_1d      = image_type == Prospero::ImageType::kColor1D;
-	const bool volume     = image_type == Prospero::ImageType::kColor3D;
-	if (is_1d && rt.attrib2.height != 0) {
-		EXIT("1D render target has nonzero height: %u\n", rt.attrib2.height);
-	}
-	if (!volume && rt.attrib3.depth != 0) {
-		EXIT("non-3D render target has nonzero depth: %u\n", rt.attrib3.depth);
-	}
-	if (is_1d && samples != 1) {
-		EXIT("multisampled 1D render targets are unsupported\n");
-	}
-	if (volume && samples != 1) {
-		EXIT("multisampled 3D render targets are unsupported\n");
-	}
-	const uint32_t depth        = volume ? rt.attrib3.depth + 1u : 1u;
-	const bool     standard4    = rt.attrib3.tile_mode == Prospero::TileMode::kStandard4KB;
-	const bool     standard64   = rt.attrib3.tile_mode == Prospero::TileMode::kStandard64KB;
-	const bool     depth_tile   = rt.attrib3.tile_mode == Prospero::TileMode::kDepth;
-	const bool     texture_tile = standard4 || standard64 || depth_tile;
+	const bool standard64 =
+	    rt.attrib3.tile_mode == Prospero::GpuEnumValue(Prospero::TileMode::kStandard64KB);
 
 	switch (rt.attrib3.tile_mode) {
-		case Prospero::TileMode::kLinear:
-		case Prospero::TileMode::kStandard4KB:
-		case Prospero::TileMode::kStandard64KB:
-		case Prospero::TileMode::kDepth:
-		case Prospero::TileMode::kRenderTarget:
+		case Prospero::GpuEnumValue(Prospero::TileMode::kLinear):
+		case Prospero::GpuEnumValue(Prospero::TileMode::kStandard64KB):
+		case Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget):
 			tile = !RenderIsColorTileModeLinear(rt.attrib3.tile_mode);
 			break;
-		default: EXIT("unknown tile mode: %u\n", static_cast<uint32_t>(rt.attrib3.tile_mode));
+		default: EXIT("unknown tile mode: %u\n", rt.attrib3.tile_mode);
 	}
 	if (!tile && levels > 1) {
 		EXIT("linear mipmapped render targets are unsupported\n");
@@ -187,9 +136,6 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 	if (samples > 1 && (!tile || levels != 1)) {
 		EXIT("multisampled render targets require a single-mip tiled surface\n");
 	}
-	if (texture_tile && samples != 1) {
-		EXIT("texture-tiled color render targets do not support multisampling\n");
-	}
 
 	width  = rt.attrib2.width + 1;
 	height = rt.attrib2.height + 1;
@@ -199,39 +145,30 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 	if (bytes_per_element == 0) {
 		EXIT("render-target format has no valid element size\n");
 	}
-	const auto transfer_format = ImageOps::RenderTargetTransferFormat(bytes_per_element);
-	TileTextureBlockLayout texture_tile_layout {};
-	if (texture_tile &&
-	    (!TileGetTextureBlockLayout(transfer_format, rt.attrib3.tile_mode, volume,
-	                                texture_tile_layout) ||
-	     (rt.base.addr & (texture_tile_layout.block.block_size - 1u)) != 0 ||
-	     rt.info.fmask_compression_enable || rt.info.fmask_data_compression_disable ||
-	     rt.info.fmask_one_frag_mode || rt.info.cmask_fast_clear_enable ||
-	     rt.info.dcc_compression_enable || rt.cmask.addr != 0 || rt.fmask.addr != 0 ||
-	     rt.dcc_addr.addr != 0 || rt.dcc.data_write_on_dcc_clear_to_reg)) {
-		EXIT("unsupported texture-tiled render target: addr=0x%016" PRIx64 " tile=%u"
+	if (standard64 &&
+	    (rt.attrib3.dimension != 1 || rt.attrib3.depth != 0 || levels != 1 ||
+	     rt.view.current_mip_level != 0 || view.base_layer != 0 || view.image_layers != 1 ||
+	     samples != 1 || bytes_per_element != 4 || rt.pitch.pitch_div8_minus1 != 0 ||
+	     (rt.base.addr & 0xffffu) != 0 || rt.info.fmask_compression_enable ||
+	     rt.info.fmask_data_compression_disable || rt.info.fmask_one_frag_mode ||
+	     rt.info.cmask_fast_clear_enable || rt.info.dcc_compression_enable ||
+	     rt.info.cmask_is_linear != 0 || rt.info.cmask_addr_type != 0 || rt.info.alt_tile_mode ||
+	     rt.cmask.addr != 0 || rt.fmask.addr != 0 || rt.dcc_addr.addr != 0 ||
+	     rt.dcc.data_write_on_dcc_clear_to_reg)) {
+		EXIT("unsupported Standard64KB render target: addr=0x%016" PRIx64
 		     " dimension=%u depth=%u levels=%u layer=%u/%u samples=%u fragments=%u bpe=%u"
 		     " cmask=0x%016" PRIx64 " fmask=0x%016" PRIx64 " dcc=0x%016" PRIx64 "\n",
-		     rt.base.addr, static_cast<uint32_t>(rt.attrib3.tile_mode), rt.attrib3.dimension,
-		     rt.attrib3.depth, levels, view.base_layer, view.image_layers, rt.attrib.num_samples,
-		     rt.attrib.num_fragments, bytes_per_element, rt.cmask.addr, rt.fmask.addr,
-		     rt.dcc_addr.addr);
+		     rt.base.addr, rt.attrib3.dimension, rt.attrib3.depth, levels, view.base_layer,
+		     view.image_layers, rt.attrib.num_samples, rt.attrib.num_fragments, bytes_per_element,
+		     rt.cmask.addr, rt.fmask.addr, rt.dcc_addr.addr);
 	}
-	if ((standard64 || depth_tile) &&
-	    (rt.attrib3.dimension != 1 || rt.attrib3.depth != 0 ||
-	     (depth_tile && (view.base_layer != 0 || view.image_layers != 1)))) {
-		EXIT("unsupported 64KB texture-tiled render-target view: dimension=%u depth=%u"
-		     " layer=%u/%u\n",
-		     rt.attrib3.dimension, rt.attrib3.depth, view.base_layer, view.image_layers);
-	}
-	if (tile) {
-		if (volume) {
-			pitch = TileGetTexturePitch(transfer_format, width, rt.attrib3.tile_mode);
-		} else if (texture_tile) {
-			pitch = TileGetTexturePitch(transfer_format, width, rt.attrib3.tile_mode);
-		} else {
-			pitch = TileGetRenderTargetPitch(width, bytes_per_element, rt.attrib.num_fragments);
-		}
+	if (rt.pitch.pitch_div8_minus1 != 0) {
+		pitch = (rt.pitch.pitch_div8_minus1 + 1u) << 3u;
+	} else if (tile) {
+		pitch = standard64
+		            ? TileGetTexturePitch(Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float),
+		                                  width, levels, rt.attrib3.tile_mode)
+		            : TileGetRenderTargetPitch(width, bytes_per_element, rt.attrib.num_fragments);
 		if (pitch == 0) {
 			EXIT("unsupported render-target pitch: width=%u bytes=%u\n", width, bytes_per_element);
 		}
@@ -239,32 +176,16 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 		pitch = width;
 	}
 
-	TileSizeOffset    mip_sizes[16] {};
-	TilePaddedSize    mip_padded[16] {};
-	TileSurfaceLayout volume_layout {};
-	uint64_t          backing_size = 0;
-	if (volume) {
-		const TileSurfaceDescription description {transfer_format,
-		                                          rt.attrib3.tile_mode,
-		                                          TileSurfaceDimension::Dim3D,
-		                                          width,
-		                                          height,
-		                                          depth,
-		                                          levels,
-		                                          1};
-		if (!tile || !TileGetTiledTextureLayout(description, volume_layout)) {
-			EXIT("unsupported 3D render-target layout: %ux%ux%u levels=%u tile=%u\n", width, height,
-			     depth, levels, static_cast<uint32_t>(rt.attrib3.tile_mode));
-		}
-		size         = volume_layout.block_slice_size;
-		backing_size = volume_layout.total_size;
-	} else if (tile) {
+	TileSizeOffset mip_sizes[16] {};
+	TilePaddedSize mip_padded[16] {};
+	if (tile) {
 		TileSizeAlign layout {};
 		bool          valid_layout = false;
-		if (texture_tile) {
-			TileGetTextureSize(transfer_format, width, height, levels, rt.attrib3.tile_mode,
-			                   &layout, mip_sizes, mip_padded);
-			valid_layout = layout.size != 0 && layout.align == texture_tile_layout.block.block_size;
+		if (standard64) {
+			TileGetTextureSize(Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float), width,
+			                   height, pitch, levels, rt.attrib3.tile_mode, &layout, mip_sizes,
+			                   mip_padded);
+			valid_layout = layout.size != 0 && layout.align == 65536;
 		} else {
 			valid_layout =
 			    levels == 1 ? TileGetRenderTargetSize(width, height, pitch, bytes_per_element,
@@ -282,6 +203,12 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 			mip_sizes[0]  = {static_cast<uint32_t>(size), 0, 0, 0, 0, 0};
 			mip_padded[0] = {pitch, height};
 		}
+		if (rt.slice.slice_div64_minus1 != 0 &&
+		    (static_cast<uint64_t>(rt.slice.slice_div64_minus1) + 1u) * 64u != size) {
+			EXIT("render-target slice span mismatch: encoded=0x%016" PRIx64 " derived=0x%016" PRIx64
+			     "\n",
+			     (static_cast<uint64_t>(rt.slice.slice_div64_minus1) + 1u) * 64u, size);
+		}
 	} else {
 		size = static_cast<uint64_t>(pitch) * height * bytes_per_element * samples;
 		if (size > UINT32_MAX) {
@@ -290,69 +217,40 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 		mip_sizes[0]  = {static_cast<uint32_t>(size), 0, 0, 0, 0, 0};
 		mip_padded[0] = {pitch, height};
 	}
-	if (size == 0 || (!volume && size > UINT64_MAX / view.image_layers)) {
+	if (size == 0 || size > UINT64_MAX / view.image_layers) {
 		EXIT("render-target memory footprint is invalid\n");
 	}
-	if (!volume) {
-		backing_size = size * view.image_layers;
-	}
-	if (backing_size == 0) {
-		EXIT("render-target backing is empty\n");
-	}
-	if (!GuestRange {rt.base.addr, backing_size}.Valid()) {
+	const auto backing_size = size * view.image_layers;
+	if (backing_size > TRACKER_ADDRESS_SIZE - rt.base.addr) {
 		EXIT("render-target backing range is invalid\n");
 	}
 
 	const vk::Extent2D view_extent = {std::max(width >> rt.view.current_mip_level, 1u),
 	                                  std::max(height >> rt.view.current_mip_level, 1u)};
-	const uint32_t     view_depth  = std::max(depth >> rt.view.current_mip_level, 1u);
-	if (volume &&
-	    (view.base_layer >= view_depth || view.layer_count > view_depth - view.base_layer)) {
-		EXIT("3D render-target view exceeds mip depth: base=%u count=%u depth=%u mip=%u\n",
-		     view.base_layer, view.layer_count, view_depth, rt.view.current_mip_level);
-	}
 
 	auto decision_log_id = g_render_color_log_count.fetch_add(1);
 	if (decision_log_id < 128) {
 		LOGF("RenderColorTarget: slot=%" PRIu32 " addr=0x%010" PRIx64 " size=0x%016" PRIx64
-		     " extent=%ux%ux%u view_mip=%u view_extent=%ux%u levels=%u pitch=%u"
+		     " extent=%ux%u view_mip=%u view_extent=%ux%u levels=%u pitch=%u"
 		     " fmt=0x%08" PRIx32 " nfmt=0x%08" PRIx32 " order=0x%08" PRIx32 " samples=%u tile=%s\n",
-		     rt_slot, rt.base.addr, backing_size, width, height, depth, rt.view.current_mip_level,
-		     view_extent.width, view_extent.height, levels, pitch,
-		     static_cast<uint32_t>(rt.info.format), static_cast<uint32_t>(rt.info.channel_type),
-		     static_cast<uint32_t>(rt.info.channel_order), samples, tile ? "tiled" : "linear");
+		     rt_slot, rt.base.addr, backing_size, width, height, rt.view.current_mip_level,
+		     view_extent.width, view_extent.height, levels, pitch, rt.info.format,
+		     rt.info.channel_type, rt.info.channel_order, samples, tile ? "tiled" : "linear");
 	}
 
 	TextureCache::ImageDesc desc {};
-	desc.type              = TextureCache::BindingType::RenderTarget;
-	desc.info.data         = {rt.base.addr, backing_size};
-	desc.info.pixel_format = target_format.format;
-	desc.info.guest_format = transfer_format;
-	desc.info.type         = image_type;
-	desc.info.extent       = {width, height, depth};
-	desc.info.resources    = {levels, volume ? 1u : view.image_layers};
-	desc.info.pitch        = pitch;
+	desc.type                 = TextureCache::BindingType::RenderTarget;
+	desc.info.data            = {rt.base.addr, backing_size};
+	desc.info.pixel_format    = target_format.format;
+	desc.info.guest_format    = ImageOps::RenderTargetTransferFormat(bytes_per_element);
+	desc.info.type            = Prospero::ImageType::kColor2D;
+	desc.info.extent          = {width, height, 1};
+	desc.info.resources       = {levels, view.image_layers};
+	desc.info.pitch           = pitch;
 	desc.info.bytes_per_block = bytes_per_element;
 	desc.info.samples         = samples;
 	desc.info.tile_mode       = rt.attrib3.tile_mode;
-	const bool has_dcc        = rt.info.dcc_compression_enable && rt.dcc_addr.addr != 0;
-	if (has_dcc) {
-		// DCC uses a separate metadata allocation. Carry its address through ImageInfo so
-		// TextureCache can associate metadata fills observed before target registration.
-		desc.info.metadata.kind          = ImageMetadataKind::Dcc;
-		desc.info.metadata.range.address = rt.dcc_addr.addr;
-	}
 	for (uint32_t level = 0; level < levels; level++) {
-		if (volume) {
-			const auto& mip             = volume_layout.mips[level];
-			desc.info.mip_layout[level] = {
-			    mip.offset,
-			    mip.size,
-			    mip.padded_width,
-			    mip.padded_height,
-			};
-			continue;
-		}
 		const auto level_offset =
 		    mip_sizes[level].src_size != 0 ? mip_sizes[level].src_offset : mip_sizes[level].offset;
 		const auto level_size =
@@ -367,13 +265,8 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 		};
 	}
 	desc.view_info.format = target_format.format;
-	if (is_1d) {
-		desc.view_info.type =
-		    view.layer_count == 1 ? vk::ImageViewType::e1D : vk::ImageViewType::e1DArray;
-	} else {
-		desc.view_info.type =
-		    view.layer_count == 1 ? vk::ImageViewType::e2D : vk::ImageViewType::e2DArray;
-	}
+	desc.view_info.type =
+	    view.layer_count == 1 ? vk::ImageViewType::e2D : vk::ImageViewType::e2DArray;
 	desc.view_info.aspect      = vk::ImageAspectFlagBits::eColor;
 	desc.view_info.base_level  = rt.view.current_mip_level;
 	desc.view_info.level_count = 1;
@@ -393,7 +286,7 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 	r.samples                  = samples;
 	r.export_mapping           = target_format.export_mapping;
 	r.color_clear_enable       = false;
-	ResolveDccClearInfo(r, target_format.format, has_dcc, rt.clear_word0.word0);
+	r.color_clear_value        = {};
 	BindRenderTarget(r.image_id);
 }
 

src/graphics/host_gpu/renderer/colorRenderTarget.h

@@ -10,6 +10,8 @@
 
 namespace Libs::Graphics {
 
+class RenderCommandBuffer;
+
 enum class RenderColorType {
 	NoColorOutput,
 	RenderTexture,
@@ -29,9 +31,7 @@ struct RenderColorInfo {
 	uint32_t                        target_slot      = 0;
 	uint32_t                        samples          = 1;
 	Prospero::ColorComponentMapping export_mapping;
-	bool                            color_clear_enable             = false;
-	bool                            metadata_clear_supported       = false;
-	bool                            metadata_fixed_clear_supported = false;
+	bool                            color_clear_enable = false;
 	vk::ClearColorValue             color_clear_value {};
 };
 

src/graphics/host_gpu/renderer/commandScheduler.cpp

@@ -1,97 +1,96 @@
 #include "graphics/host_gpu/renderer/commandScheduler.h"
 
 #include "common/assert.h"
-#include "common/logging/log.h"
 #include "graphics/host_gpu/graphicContext.h"
 
 #include <algorithm>
-#include <cstdio>
-#include <optional>
 
 namespace Libs::Graphics {
 
 static thread_local CommandScheduler* g_deferred_callback_scheduler = nullptr;
 
-namespace {
-
-void ReportVulkanFatal(const char* what, vk::Result result, uint64_t tick, uint32_t debug_op,
-                       uint64_t debug_submit, uint32_t arg0, uint32_t arg1, uint32_t arg2,
-                       uint32_t arg3, uint64_t arg4) {
-	LOGF("%s failed: %s (%d), tick=%" PRIu64 " debug_op=%u debug_submit=%" PRIu64
-	     " args=%u,%u,%u,%u,0x%016" PRIx64 "\n",
-	     what, VulkanToString(result).c_str(), static_cast<int>(result), tick, debug_op,
-	     debug_submit, arg0, arg1, arg2, arg3, arg4);
-	std::printf("%s failed: %s (%d), tick=%" PRIu64 " debug_op=%u debug_submit=%" PRIu64
-	            " args=%u,%u,%u,%u,0x%016" PRIx64 "\n",
-	            what, VulkanToString(result).c_str(), static_cast<int>(result), tick, debug_op,
-	            debug_submit, arg0, arg1, arg2, arg3, arg4);
-	std::fflush(stdout);
+void CommandSlot::Reset() {
+	EXIT_IF(buffer == nullptr);
+	const auto result = buffer.reset(vk::CommandBufferResetFlagBits::eReleaseResources);
+	if (result != vk::Result::eSuccess) {
+		EXIT("failed to reset Vulkan command buffer: %s (%d)\n", VulkanToString(result).c_str(),
+		     static_cast<int>(result));
+	}
 }
 
-} // namespace
+CommandScheduler::CommandPool::~CommandPool() {
+	Destroy();
+}
+
+void CommandScheduler::CommandPool::Create(GraphicContext& graphics) {
+	EXIT_IF(m_pool != nullptr || m_graphics != nullptr ||
+	        graphics.queue_family == static_cast<uint32_t>(-1));
+	m_graphics = &graphics;
 
-CommandScheduler::CommandPool::CommandPool(GraphicContext& graphics, MasterSemaphore& master)
-    : m_graphics(graphics), m_master(master) {
-	EXIT_IF(graphics.queue_family == static_cast<uint32_t>(-1));
 	vk::CommandPoolCreateInfo create {};
 	create.sType            = vk::StructureType::eCommandPoolCreateInfo;
 	create.queueFamilyIndex = graphics.queue_family;
-	create.flags            = vk::CommandPoolCreateFlagBits::eTransient |
-	                          vk::CommandPoolCreateFlagBits::eResetCommandBuffer;
+	create.flags            = vk::CommandPoolCreateFlagBits::eResetCommandBuffer;
 	const auto result       = graphics.device.createCommandPool(&create, nullptr, &m_pool);
 	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess || m_pool == nullptr);
 }
 
-CommandScheduler::CommandPool::~CommandPool() {
-	m_graphics.device.destroyCommandPool(m_pool, nullptr);
-}
-
-size_t CommandScheduler::CommandPool::Grow() {
-	const auto first = m_ticks.size();
-	m_ticks.resize(first + GrowStep);
-	m_buffers.resize(first + GrowStep);
+CommandSlot* CommandScheduler::CommandPool::CreateSlot() {
+	EXIT_IF(m_graphics == nullptr);
+	auto& graphics = *m_graphics;
 
 	vk::CommandBufferAllocateInfo allocate {};
 	allocate.sType              = vk::StructureType::eCommandBufferAllocateInfo;
 	allocate.commandPool        = m_pool;
 	allocate.level              = vk::CommandBufferLevel::ePrimary;
-	allocate.commandBufferCount = static_cast<uint32_t>(GrowStep);
-	EXIT_IF(m_graphics.device.allocateCommandBuffers(&allocate, m_buffers.data() + first) !=
-	        vk::Result::eSuccess);
-	return first;
+	allocate.commandBufferCount = 1;
+	vk::CommandBuffer buffer    = nullptr;
+	EXIT_IF(graphics.device.allocateCommandBuffers(&allocate, &buffer) != vk::Result::eSuccess);
+
+	vk::FenceCreateInfo fence_create {};
+	fence_create.sType = vk::StructureType::eFenceCreateInfo;
+	fence_create.flags = vk::FenceCreateFlagBits::eSignaled;
+	vk::Fence fence    = nullptr;
+	if (graphics.device.createFence(&fence_create, nullptr, &fence) != vk::Result::eSuccess) {
+		graphics.device.freeCommandBuffers(m_pool, 1, &buffer);
+		EXIT("failed to create command-buffer fence\n");
+	}
+
+	auto& slot      = m_slots.emplace_back();
+	slot.pool_mutex = &m_mutex;
+	slot.id         = static_cast<uint32_t>(m_slots.size() - 1);
+	slot.buffer     = buffer;
+	slot.fence      = fence;
+	return &slot;
 }
 
-vk::CommandBuffer CommandScheduler::CommandPool::Commit() {
-	auto       gpu_tick = m_master.KnownGpuTick();
-	const auto search   = [this, &gpu_tick](size_t begin, size_t end) -> std::optional<size_t> {
-		for (size_t index = begin; index < end; ++index) {
-			if (gpu_tick >= m_ticks[index]) {
-				m_ticks[index] = m_master.CurrentTick();
-				return index;
-			}
-		}
-		return std::nullopt;
-	};
+CommandSlot* CommandScheduler::CommandPool::Allocate(GraphicContext& graphics) {
+	Common::LockGuard lock(m_mutex);
+	if (m_pool == nullptr) {
+		Create(graphics);
+	}
+	EXIT_IF(m_graphics != &graphics);
+	auto  found = std::ranges::find_if(m_slots, [](const auto& slot) { return !slot.busy; });
+	auto* slot  = found != m_slots.end() ? &*found : CreateSlot();
+	slot->busy  = true;
+	slot->Reset();
+	return slot;
+}
 
-	auto found = search(m_hint, m_ticks.size());
-	if (!found) {
-		m_master.Refresh();
-		gpu_tick = m_master.KnownGpuTick();
-		found    = search(m_hint, m_ticks.size());
+void CommandScheduler::CommandPool::Destroy() {
+	Common::LockGuard lock(m_mutex);
+	if (m_pool == nullptr) {
+		return;
 	}
-	if (!found) {
-		found = search(0, m_hint);
+	EXIT_IF(std::ranges::any_of(m_slots, [](const auto& slot) { return slot.busy; }));
+	EXIT_IF(m_graphics == nullptr);
+	for (const auto& slot: m_slots) {
+		m_graphics->device.destroyFence(slot.fence, nullptr);
 	}
-	if (!found) {
-		found           = Grow();
-		m_ticks[*found] = m_master.CurrentTick();
-	}
-
-	m_hint = *found + 1;
-	if (m_hint == m_ticks.size()) {
-		m_hint = 0;
-	}
-	return m_buffers[*found];
+	m_graphics->device.destroyCommandPool(m_pool, nullptr);
+	m_slots.clear();
+	m_pool     = nullptr;
+	m_graphics = nullptr;
 }
 
 bool CommandScheduler::InDeferredOperation() noexcept {
@@ -100,7 +99,6 @@ bool CommandScheduler::InDeferredOperation() noexcept {
 
 CommandScheduler::CommandScheduler(RenderContext& context, GraphicContext& graphics)
     : m_master(graphics), m_context(context), m_graphics(graphics),
-      m_command_pool(graphics, m_master), m_command(*this),
       m_priority_thread([this](std::stop_token stop) { PriorityOperationsThread(stop); }) {}
 
 CommandScheduler::~CommandScheduler() {
@@ -127,11 +125,9 @@ void CommandScheduler::Shutdown() {
 		}
 		m_operation_state = OperationState::Draining;
 	}
-	if (!m_command.IsInvalid()) {
-		Submit();
+	if (Active() && m_recording) {
+		Finish();
 	}
-	m_master.Wait(CurrentTick() - 1);
-	PopPendingOperations();
 	DrainPriorityOperations();
 	m_priority_thread.request_stop();
 	m_operation_available.notify_all();
@@ -157,10 +153,17 @@ void CommandScheduler::Begin(HW::Context& registers, HW::UserConfig& user_config
 	m_user_config = &user_config;
 	m_shaders     = &shaders;
 
-	if (m_command.IsInvalid()) {
-		BeginNext();
-	} else {
-		BindCurrent();
+	if (!Active()) {
+		for (auto& buffer: m_buffers) {
+			buffer = std::make_unique<RenderCommandBuffer>(*this);
+		}
+		m_current = 0;
+	}
+
+	BindCurrent();
+	if (!m_recording) {
+		Current().Begin();
+		m_recording = true;
 	}
 }
 
@@ -169,7 +172,7 @@ void CommandScheduler::BeginRendering(const RenderState& state) {
 }
 
 void CommandScheduler::EndRendering() {
-	if (Active() && !m_command.IsInvalid()) {
+	if (Active() && m_recording) {
 		Current().EndRendering();
 	}
 }
@@ -180,63 +183,71 @@ void CommandScheduler::Flush() {
 }
 
 void CommandScheduler::Flush(SubmitInfo& submit) {
-	Submit(submit);
+	SubmitCurrent(submit);
 	BeginNext();
 }
 
-void CommandScheduler::FlushAndWait() {
-	const auto tick = Submit();
-	m_master.Wait(tick);
+CommandBuffer& CommandScheduler::FlushAndGetSubmitted() {
+	SubmitInfo submit;
+	auto&      submitted = SubmitCurrent(submit);
 	BeginNext();
+	return submitted;
 }
 
 void CommandScheduler::Finish() {
 	CheckActive();
-	if (!m_command.IsInvalid()) {
-		Submit();
+	const auto tick = CurrentTick();
+	if (m_recording) {
+		SubmitInfo submit;
+		SubmitCurrent(submit);
 	}
-	m_master.Wait(CurrentTick() - 1);
-	BeginNext();
+	for (auto& buffer: m_buffers) {
+		buffer->WaitForFenceAndReset();
+	}
+	m_master.Wait(tick);
 	PopPendingOperations();
+	BindCurrent();
+	Current().Begin();
+	m_recording = true;
+}
+
+void CommandScheduler::FinishCurrent() {
+	SubmitInfo submit;
+	auto&      submitted = SubmitCurrent(submit);
+	submitted.WaitForFenceAndReset();
+	m_master.Refresh();
+	PopPendingOperations();
+	submitted.Begin();
+	m_recording = true;
 }
 
 void CommandScheduler::Wait(uint64_t tick) {
+	CheckActive();
 	EXIT_IF(tick > CurrentTick());
-	if (tick == CurrentTick()) {
-		CheckActive();
+	if (tick >= CurrentTick()) {
 		// A stream-buffer wrap can wait while a draw is being prepared through a reference to
-		// Current(). The wrapper stays stable while its pooled Vulkan buffer is retired. Deferred
-		// resources are released only at the next GPU operation boundary.
-		const auto submitted_tick = Submit();
-		EXIT_IF(submitted_tick != tick);
-		m_master.Wait(tick);
-		BeginNext();
-	} else {
-		m_master.Wait(tick);
+		// Current(). Recycle the same command object so that reference remains valid.
+		FinishCurrent();
+		return;
 	}
+	m_master.Wait(tick);
+	PopPendingOperations();
 }
 
 void CommandScheduler::PopPendingOperations() {
-	PopPendingOperations(true);
-}
-
-void CommandScheduler::PopPendingOperations(bool refresh_gpu_tick) {
-	if (refresh_gpu_tick) {
-		m_master.Refresh();
-	}
+	m_master.Refresh();
 	for (;;) {
-		PendingOperation operation;
+		Common::UniqueFunction<void> callback;
 		{
 			std::lock_guard lock(m_operation_mutex);
 			if (m_pending_operations.empty() ||
 			    !m_master.IsFree(m_pending_operations.front().tick)) {
 				return;
 			}
-			operation = std::move(m_pending_operations.front());
+			callback = std::move(m_pending_operations.front().callback);
 			m_pending_operations.pop();
 		}
-		WaitPriorityOperations(operation.tick);
-		RunOperation(std::move(operation.callback));
+		RunOperation(std::move(callback));
 	}
 }
 
@@ -342,81 +353,49 @@ bool CommandScheduler::IsFree(uint64_t tick) {
 	return m_master.IsFree(tick);
 }
 
+CommandSlot* CommandScheduler::AllocateCommandBuffer() {
+	return m_command_pool.Allocate(m_graphics);
+}
+
+uint64_t CommandScheduler::NextSubmitSequence() noexcept {
+	return m_submit_sequence.fetch_add(1, std::memory_order_relaxed) + 1;
+}
+
 void CommandScheduler::CheckActive() const {
-	EXIT_IF(!Active());
+	EXIT_IF(!Active() || m_current >= BufferCount);
 }
 
-CommandBuffer& CommandScheduler::Current() {
+RenderCommandBuffer& CommandScheduler::Current() const {
 	CheckActive();
-	return m_command;
+	EXIT_IF(m_buffers[m_current] == nullptr);
+	return *m_buffers[m_current];
 }
 
-void CommandScheduler::BindCurrent() {
+void CommandScheduler::BindCurrent() const {
 	EXIT_IF(m_registers == nullptr || m_user_config == nullptr || m_shaders == nullptr);
-	m_command.Bind(*m_registers, *m_user_config, *m_shaders);
+	Current().Bind(*m_registers, *m_user_config, *m_shaders);
 }
 
-CommandBuffer& CommandScheduler::BeginCommand() {
-	EXIT_IF(!m_command.IsInvalid());
-	m_command.m_buffer = m_command_pool.Commit();
-	m_command.Begin();
-	return m_command;
-}
-
-uint64_t CommandScheduler::Submit(SubmitInfo submit) {
-	EXIT_IF(m_command.IsInvalid());
-	EXIT_IF(submit.num_wait_semaphores > SubmitInfo::MaxSemaphores ||
-	        submit.num_signal_semaphores >= SubmitInfo::MaxSemaphores);
-
-	m_command.End();
-	const auto buffer   = m_command.m_buffer;
-	auto&      graphics = m_graphics;
-	EXIT_IF(graphics.queue == nullptr);
-
-	vk::Result result;
-	uint64_t   tick;
-	{
-		Common::LockGuard lock(graphics.queue_mutex);
-		tick = m_master.NextTick();
-		submit.AddSignal(m_master.Handle(), tick);
-
-		vk::TimelineSemaphoreSubmitInfo timeline_info {};
-		timeline_info.sType                     = vk::StructureType::eTimelineSemaphoreSubmitInfo;
-		timeline_info.waitSemaphoreValueCount   = submit.num_wait_semaphores;
-		timeline_info.pWaitSemaphoreValues      = submit.wait_ticks.data();
-		timeline_info.signalSemaphoreValueCount = submit.num_signal_semaphores;
-		timeline_info.pSignalSemaphoreValues    = submit.signal_ticks.data();
-
-		vk::SubmitInfo submit_info {};
-		submit_info.sType                = vk::StructureType::eSubmitInfo;
-		submit_info.pNext                = &timeline_info;
-		submit_info.waitSemaphoreCount   = submit.num_wait_semaphores;
-		submit_info.pWaitSemaphores      = submit.wait_semaphores.data();
-		submit_info.pWaitDstStageMask    = submit.wait_stages.data();
-		submit_info.commandBufferCount   = 1;
-		submit_info.pCommandBuffers      = &buffer;
-		submit_info.signalSemaphoreCount = submit.num_signal_semaphores;
-		submit_info.pSignalSemaphores    = submit.signal_semaphores.data();
-
-		result = graphics.queue.submit(1, &submit_info, nullptr);
-	}
-
-	if (result != vk::Result::eSuccess) {
-		ReportVulkanFatal("vkQueueSubmit", result, tick, m_command.m_debug_op,
-		                  m_command.m_debug_submit_id, m_command.m_debug_arg0,
-		                  m_command.m_debug_arg1, m_command.m_debug_arg2, m_command.m_debug_arg3,
-		                  m_command.m_debug_arg4);
-	}
-	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
-
-	m_command.m_buffer = nullptr;
-	return tick;
+CommandBuffer& CommandScheduler::SubmitCurrent(SubmitInfo& submit) {
+	CheckActive();
+	EXIT_IF(!m_recording);
+	auto& submitted = Current();
+	submitted.End();
+	const auto signal_tick = m_master.NextTick();
+	submit.AddSignal(m_master.Handle(), signal_tick);
+	submitted.Execute(submit);
+	m_recording = false;
+	return submitted;
 }
 
 void CommandScheduler::BeginNext() {
-	EXIT_IF(!m_command.IsInvalid());
+	EXIT_IF(m_recording);
+	m_current = (m_current + 1) % BufferCount;
+	Current().WaitForFenceAndReset();
+	PopPendingOperations();
 	BindCurrent();
-	BeginCommand();
+	Current().Begin();
+	m_recording = true;
 }
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/commandScheduler.h

@@ -6,18 +6,33 @@
 #include "graphics/host_gpu/renderer/masterSemaphore.h"
 #include "graphics/host_gpu/renderer/render.h"
 
+#include <array>
+#include <atomic>
 #include <condition_variable>
+#include <deque>
+#include <memory>
 #include <mutex>
 
 #include <queue>
 
 #include <thread>
-#include <vector>
 
 namespace Libs::Graphics {
 
+struct CommandSlot {
+	Common::Mutex*    pool_mutex = nullptr;
+	uint32_t          id         = 0;
+	vk::CommandBuffer buffer     = nullptr;
+	vk::Fence         fence      = nullptr;
+	bool              busy       = false;
+
+	void Reset();
+};
+
 class CommandScheduler {
 public:
+	static constexpr int BufferCount = 8;
+
 	CommandScheduler(RenderContext& context, GraphicContext& graphics);
 	~CommandScheduler();
 	KYTY_CLASS_NO_COPY(CommandScheduler);
@@ -27,10 +42,9 @@ public:
 	void           EndRendering();
 	void           Flush();
 	void           Flush(SubmitInfo& submit);
-	void           FlushAndWait();
+	CommandBuffer& FlushAndGetSubmitted();
 	void           Finish();
-	CommandBuffer& BeginCommand();
-	uint64_t       Submit(SubmitInfo submit = {});
+	void           FinishCurrent();
 	// Deferred callbacks can observe an externally owned drain, but cannot initiate shutdown:
 	// the priority runner cannot join itself.
 	void                      Shutdown();
@@ -42,35 +56,32 @@ public:
 	void                      DeferPriorityOperation(Common::UniqueFunction<void>&& operation);
 	[[nodiscard]] static bool InDeferredOperation() noexcept;
 
-	[[nodiscard]] bool             Active() const noexcept { return m_registers != nullptr; }
-	void                           CheckActive() const;
-	CommandBuffer&                 Current();
-	[[nodiscard]] uint64_t         CurrentTick() const noexcept { return m_master.CurrentTick(); }
-	[[nodiscard]] bool             IsFree(uint64_t tick);
-	[[nodiscard]] MasterSemaphore& GetMasterSemaphore() noexcept { return m_master; }
-	[[nodiscard]] RenderContext&   Context() const noexcept { return m_context; }
-	[[nodiscard]] GraphicContext&  Graphics() const noexcept { return m_graphics; }
+	[[nodiscard]] bool            Active() const noexcept { return m_current >= 0; }
+	void                          CheckActive() const;
+	RenderCommandBuffer&          Current() const;
+	[[nodiscard]] uint64_t        CurrentTick() const noexcept { return m_master.CurrentTick(); }
+	[[nodiscard]] bool            IsFree(uint64_t tick);
+	[[nodiscard]] RenderContext&  Context() const noexcept { return m_context; }
+	[[nodiscard]] GraphicContext& Graphics() const noexcept { return m_graphics; }
 
 private:
 	class CommandPool {
 	public:
-		CommandPool(GraphicContext& graphics, MasterSemaphore& master);
+		CommandPool() = default;
 		~CommandPool();
 		KYTY_CLASS_NO_COPY(CommandPool);
 
-		vk::CommandBuffer Commit();
+		CommandSlot* Allocate(GraphicContext& graphics);
 
 	private:
-		static constexpr size_t GrowStep = 4;
+		void         Create(GraphicContext& graphics);
+		CommandSlot* CreateSlot();
+		void         Destroy();
 
-		size_t Grow();
-
-		GraphicContext&                m_graphics;
-		MasterSemaphore&               m_master;
-		vk::CommandPool                m_pool = nullptr;
-		std::vector<vk::CommandBuffer> m_buffers;
-		std::vector<uint64_t>          m_ticks;
-		size_t                         m_hint = 0;
+		GraphicContext*         m_graphics = nullptr;
+		Common::Mutex           m_mutex;
+		vk::CommandPool         m_pool = nullptr;
+		std::deque<CommandSlot> m_slots;
 	};
 
 	enum class OperationState { Open, Draining, Closed };
@@ -80,28 +91,35 @@ private:
 		uint64_t                     tick = 0;
 	};
 
-	void BindCurrent();
-	void BeginNext();
-	void PopPendingOperations(bool refresh_gpu_tick);
-	void PriorityOperationsThread(std::stop_token stop);
-	void RunOperation(Common::UniqueFunction<void>&& operation);
+	void                       BindCurrent() const;
+	CommandBuffer&             SubmitCurrent(SubmitInfo& submit);
+	void                       BeginNext();
+	void                       PriorityOperationsThread(std::stop_token stop);
+	void                       RunOperation(Common::UniqueFunction<void>&& operation);
+	[[nodiscard]] CommandSlot* AllocateCommandBuffer();
+	[[nodiscard]] uint64_t     NextSubmitSequence() noexcept;
 
-	MasterSemaphore              m_master;
-	RenderContext&               m_context;
-	GraphicContext&              m_graphics;
-	CommandPool                  m_command_pool;
-	CommandBuffer                m_command;
-	std::queue<PendingOperation> m_pending_operations;
-	std::queue<PendingOperation> m_priority_operations;
-	std::mutex                   m_operation_mutex;
-	std::condition_variable      m_operation_available;
-	std::jthread                 m_priority_thread;
-	bool                         m_priority_active      = false;
-	uint64_t                     m_priority_active_tick = 0;
-	OperationState               m_operation_state      = OperationState::Open;
-	HW::Context*                 m_registers            = nullptr;
-	HW::UserConfig*              m_user_config          = nullptr;
-	HW::Shader*                  m_shaders              = nullptr;
+	MasterSemaphore                                               m_master;
+	RenderContext&                                                m_context;
+	GraphicContext&                                               m_graphics;
+	CommandPool                                                   m_command_pool;
+	std::array<std::unique_ptr<RenderCommandBuffer>, BufferCount> m_buffers;
+	std::queue<PendingOperation>                                  m_pending_operations;
+	std::queue<PendingOperation>                                  m_priority_operations;
+	std::mutex                                                    m_operation_mutex;
+	std::condition_variable                                       m_operation_available;
+	std::jthread                                                  m_priority_thread;
+	bool                                                          m_priority_active      = false;
+	uint64_t                                                      m_priority_active_tick = 0;
+	OperationState        m_operation_state = OperationState::Open;
+	int                   m_current         = -1;
+	bool                  m_recording       = false;
+	HW::Context*          m_registers       = nullptr;
+	HW::UserConfig*       m_user_config     = nullptr;
+	HW::Shader*           m_shaders         = nullptr;
+	std::atomic<uint64_t> m_submit_sequence = 0;
+
+	friend class CommandBuffer;
 };
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/context.cpp

@@ -1,5 +1,7 @@
 #include "common/assert.h"
 #include "common/common.h"
+#include "common/emulatorConfig.h"
+#include "common/logging/log.h"
 #include "common/profiler.h"
 #include "common/threads.h"
 #include "graphics/host_gpu/graphicContext.h"
@@ -7,6 +9,7 @@
 #include "graphics/host_gpu/renderer/debug.h"
 #include "graphics/host_gpu/renderer/depthRenderTarget.h"
 #include "graphics/host_gpu/renderer/image/imageView.h"
+#include "graphics/host_gpu/renderer/pipeline/descriptorCache.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vma.h"
@@ -15,28 +18,98 @@
 #include <algorithm>
 #include <bit>
 #include <cstring>
+#include <memory>
 namespace Libs::Graphics {
 
+FenceResourceRetainer::~FenceResourceRetainer() {
+	if (!m_resources.empty()) {
+		EXIT("fence resource retainer destroyed before release\n");
+	}
+}
+
+void FenceResourceRetainer::Retain(std::shared_ptr<void> resource) {
+	if (resource == nullptr) {
+		EXIT("cannot retain a null fence resource\n");
+	}
+	if (std::ranges::none_of(m_resources, [&resource](const auto& retained) {
+		    return retained.get() == resource.get();
+	    })) {
+		m_resources.push_back(std::move(resource));
+	}
+}
+
+void FenceResourceRetainer::ReleaseAfterFence() noexcept {
+	m_resources.clear();
+}
+
 CommandBuffer::CommandBuffer(CommandScheduler& scheduler)
-    : m_context(scheduler.Context()), m_graphics(scheduler.Graphics()) {}
+    : m_context(scheduler.Context()), m_scheduler(scheduler), m_graphics(scheduler.Graphics()),
+      m_slot(scheduler.AllocateCommandBuffer()) {}
+
+CommandBuffer::~CommandBuffer() {
+	Release();
+}
 
 bool CommandBuffer::IsInvalid() const {
-	return m_buffer == nullptr;
+	return m_slot == nullptr;
 }
 
 vk::CommandBuffer CommandBuffer::Handle() const {
 	EXIT_IF(IsInvalid());
-	return m_buffer;
+
+	const auto handle = m_slot->buffer;
+	EXIT_IF(handle == nullptr);
+	return handle;
 }
 
-void CommandBuffer::Begin() {
-	EXIT_IF(m_rendering || IsInvalid());
+void CommandBuffer::Release() {
+	EXIT_IF(IsInvalid());
+
+	Common::LockGuard lock(*m_slot->pool_mutex);
+
+	WaitForFence();
+
+	m_slot->busy = false;
+	m_slot->Reset();
+	ReleaseResourcesAfterFence();
+	m_slot = nullptr;
+
+	EXIT_NOT_IMPLEMENTED(!IsInvalid());
+}
+
+void CommandBuffer::RetireBufferAfterFence(std::unique_ptr<VulkanBuffer> buffer) {
+	if (IsInvalid() || m_execute || buffer == nullptr || buffer->buffer == nullptr) {
+		EXIT("cannot retire a buffer on an invalid or submitted command buffer\n");
+	}
+	m_retired_buffers.push_back(std::move(buffer));
+}
+
+void CommandBuffer::RetainResourceUntilFence(std::shared_ptr<void> resource) {
+	if (IsInvalid() || m_execute) {
+		EXIT("cannot retain a resource on an invalid or submitted command buffer\n");
+	}
+	m_fence_resources.Retain(std::move(resource));
+}
+
+void CommandBuffer::RecycleDescriptorAfterFence(VulkanDescriptorSet& set) {
+	m_descriptor_sets_after_fence.push_back(&set);
+}
+
+void CommandBuffer::RecycleDescriptorsAfterFence() {
+	for (auto* set: m_descriptor_sets_after_fence) {
+		m_context.GetDescriptorCache().Recycle(*set);
+	}
+	m_descriptor_sets_after_fence.clear();
+}
+
+void CommandBuffer::Begin() const {
+	EXIT_IF(m_rendering);
 	auto buffer = Handle();
 
 	vk::CommandBufferBeginInfo begin_info {};
 	begin_info.sType            = vk::StructureType::eCommandBufferBeginInfo;
 	begin_info.pNext            = nullptr;
-	begin_info.flags            = vk::CommandBufferUsageFlagBits::eOneTimeSubmit;
+	begin_info.flags            = {};
 	begin_info.pInheritanceInfo = nullptr;
 
 	auto result = buffer.begin(&begin_info);
@@ -64,6 +137,125 @@ void CommandBuffer::SetDebugInfo(uint32_t op, uint64_t submit_id, uint32_t arg0,
 	m_debug_arg4      = arg4;
 }
 
+void CommandBuffer::Execute(const SubmitInfo& submit) {
+	EXIT_IF(IsInvalid());
+	EXIT_IF(m_execute);
+	EXIT_IF(submit.num_wait_semaphores > SubmitInfo::MaxSemaphores ||
+	        submit.num_signal_semaphores > SubmitInfo::MaxSemaphores);
+
+	auto buffer = Handle();
+	auto fence  = m_slot->fence;
+
+	vk::TimelineSemaphoreSubmitInfo timeline_info {};
+	timeline_info.sType                     = vk::StructureType::eTimelineSemaphoreSubmitInfo;
+	timeline_info.waitSemaphoreValueCount   = submit.num_wait_semaphores;
+	timeline_info.pWaitSemaphoreValues      = submit.wait_ticks.data();
+	timeline_info.signalSemaphoreValueCount = submit.num_signal_semaphores;
+	timeline_info.pSignalSemaphoreValues    = submit.signal_ticks.data();
+
+	vk::SubmitInfo submit_info {};
+	submit_info.sType                = vk::StructureType::eSubmitInfo;
+	submit_info.pNext                = &timeline_info;
+	submit_info.waitSemaphoreCount   = submit.num_wait_semaphores;
+	submit_info.pWaitSemaphores      = submit.wait_semaphores.data();
+	submit_info.pWaitDstStageMask    = submit.wait_stages.data();
+	submit_info.commandBufferCount   = 1;
+	submit_info.pCommandBuffers      = &buffer;
+	submit_info.signalSemaphoreCount = submit.num_signal_semaphores;
+	submit_info.pSignalSemaphores    = submit.signal_semaphores.data();
+
+	auto& graphics = m_graphics;
+	EXIT_IF(graphics.queue == nullptr);
+
+	auto result = graphics.device.resetFences(1, &fence);
+	if (result != vk::Result::eSuccess) {
+		LOGF("vkResetFences failed before submit: %s (%d)\n", VulkanToString(result).c_str(),
+		     static_cast<int>(result));
+	}
+	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
+
+	if (Config::GraphicsDebugDumpEnabled()) {
+		LOGF("vkQueueSubmit begin: slot=%u waits=%u signals=%u debug_op=%u debug_submit=%" PRIu64
+		     " args=%u,%u,%u,%u,0x%016" PRIx64 "\n",
+		     m_slot->id, submit.num_wait_semaphores, submit.num_signal_semaphores, m_debug_op,
+		     m_debug_submit_id, m_debug_arg0, m_debug_arg1, m_debug_arg2, m_debug_arg3,
+		     m_debug_arg4);
+	}
+
+	{
+		Common::LockGuard lock(graphics.queue_mutex);
+		m_submit_seq = m_scheduler.NextSubmitSequence();
+		result       = graphics.queue.submit(1, &submit_info, fence);
+	}
+
+	m_execute      = true;
+	m_fence_waited = false;
+
+	if (result != vk::Result::eSuccess) {
+		LOGF("vkQueueSubmit failed: %s (%d), slot=%u submit_seq=%" PRIu64
+		     " debug_op=%u debug_submit=%" PRIu64 " args=%u,%u,%u,%u,0x%016" PRIx64 "\n",
+		     VulkanToString(result).c_str(), static_cast<int>(result), m_slot->id, m_submit_seq,
+		     m_debug_op, m_debug_submit_id, m_debug_arg0, m_debug_arg1, m_debug_arg2, m_debug_arg3,
+		     m_debug_arg4);
+	}
+	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
+}
+
+void CommandBuffer::WaitForFence() {
+	FinalizeFence(false);
+}
+
+void CommandBuffer::WaitForFenceOnly() {
+	EXIT_IF(IsInvalid());
+	if (!m_execute || m_fence_waited) {
+		return;
+	}
+	auto device = m_graphics.device;
+	auto result = device.waitForFences(1, &m_slot->fence, VK_TRUE, UINT64_MAX);
+	if (result != vk::Result::eSuccess) {
+		LOGF("vkWaitForFences failed: %s (%d), slot=%u submit_seq=%" PRIu64
+		     " debug_op=%u debug_submit=%" PRIu64 " args=%u,%u,%u,%u,0x%016" PRIx64 "\n",
+		     VulkanToString(result).c_str(), static_cast<int>(result), m_slot->id, m_submit_seq,
+		     m_debug_op, m_debug_submit_id, m_debug_arg0, m_debug_arg1, m_debug_arg2, m_debug_arg3,
+		     m_debug_arg4);
+	}
+	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
+	m_fence_waited = true;
+}
+
+void CommandBuffer::WaitForFenceAndReset() {
+	FinalizeFence(true);
+}
+
+void CommandBuffer::FinalizeFence(bool reset_recording) {
+	const bool was_executed = m_execute;
+	WaitForFenceOnly();
+	if (was_executed) {
+		m_execute      = false;
+		m_fence_waited = false;
+		if (reset_recording) {
+			Common::LockGuard lock(*m_slot->pool_mutex);
+			m_slot->Reset();
+		}
+	}
+	if (was_executed) {
+		ReleaseResourcesAfterFence();
+	}
+	DeleteBuffersAfterFence();
+}
+
+void CommandBuffer::ReleaseResourcesAfterFence() {
+	RecycleDescriptorsAfterFence();
+	m_fence_resources.ReleaseAfterFence();
+}
+
+void CommandBuffer::DeleteBuffersAfterFence() {
+	for (const auto& buffer: m_retired_buffers) {
+		m_graphics.DeleteBuffer(*buffer);
+	}
+	m_retired_buffers.clear();
+}
+
 void CommandBuffer::BeginRendering(const RenderState& state) const {
 	EXIT_IF(state.width == 0 || state.height == 0 || state.num_layers == 0 ||
 	        state.num_color_attachments > RENDER_COLOR_ATTACHMENTS_MAX);

src/graphics/host_gpu/renderer/debug.cpp

@@ -10,7 +10,6 @@
 #include "graphics/host_gpu/renderer/render.h"
 
 #include <algorithm>
-#include <array>
 #include <atomic>
 #include <cmath>
 #include <fmt/format.h>
@@ -27,7 +26,7 @@ static bool RenderTargetMaskHasMrt(uint32_t mask) {
 	return (mask & ~0x0fu) != 0;
 }
 
-static bool RenderTargetMaskHasBoundMrt(const CommandBuffer& buffer) {
+static bool RenderTargetMaskHasBoundMrt(const RenderCommandBuffer& buffer) {
 	const auto& hw   = buffer.GetRegisters();
 	const auto  mask = hw.GetRenderTargetMask();
 
@@ -45,7 +44,7 @@ static bool RenderTargetMaskHasBoundMrt(const CommandBuffer& buffer) {
 	return bound_targets > 1;
 }
 
-uint32_t render_target_first_bound_slot(const CommandBuffer& buffer) {
+uint32_t render_target_first_bound_slot(const RenderCommandBuffer& buffer) {
 	const auto& hw   = buffer.GetRegisters();
 	const auto  mask = hw.GetRenderTargetMask();
 	for (uint32_t i = 0; i < 8; i++) {
@@ -71,21 +70,28 @@ void uc_print(const char* func, const HW::UserConfig& uc) {
 	LOGF("\t GetPrimType()         = 0x%08" PRIx32 "\n"
 	     "\t GetIndexOffset()      = 0x%08" PRIx32 "\n"
 	     "\t GetObjectId()         = 0x%08" PRIx32 "\n"
-	     "\t primitive_reset       = 0x%08" PRIx32 "\n"
 	     "\t primitive_group_size  = 0x%04" PRIx16 "\n"
 	     "\t vertex_group_size     = 0x%04" PRIx16 "\n"
 	     "\t en_user_vgpr1         = %s\n"
 	     "\t en_user_vgpr2         = %s\n"
 	     "\t en_user_vgpr3         = %s\n",
-	     static_cast<uint32_t>(uc.GetPrimType()), uc.GetIndexOffset(), uc.GetObjectId(),
-	     uc.GetPrimitiveResetControl(), ge_cntl.primitive_group_size, ge_cntl.vertex_group_size,
-	     user_en.vgpr1 ? "true" : "false", user_en.vgpr2 ? "true" : "false",
-	     user_en.vgpr3 ? "true" : "false");
+	     uc.GetPrimType(), uc.GetIndexOffset(), uc.GetObjectId(), ge_cntl.primitive_group_size,
+	     ge_cntl.vertex_group_size, user_en.vgpr1 ? "true" : "false",
+	     user_en.vgpr2 ? "true" : "false", user_en.vgpr3 ? "true" : "false");
 }
 
 void uc_check(const HW::UserConfig& uc) {
+	const auto& ge_cntl = uc.GetGeControl();
 	const auto& user_en = uc.GetGeUserVgprEn();
 
+	if (ge_cntl.primitive_group_size > 0x0040) {
+		LOGF("\t warning: unsupported GE_CNTL primitive_group_size = 0x%04" PRIx16 "\n",
+		     ge_cntl.primitive_group_size);
+	}
+	if (ge_cntl.vertex_group_size > 0x0040) {
+		LOGF("\t warning: unsupported GE_CNTL vertex_group_size = 0x%04" PRIx16 "\n",
+		     ge_cntl.vertex_group_size);
+	}
 	EXIT_NOT_IMPLEMENTED(user_en.vgpr1 != false);
 	EXIT_NOT_IMPLEMENTED(user_en.vgpr2 != false);
 	EXIT_NOT_IMPLEMENTED(user_en.vgpr3 != false);
@@ -97,11 +103,17 @@ void sh_print(const char* func, const HW::Shader& /*uc*/) {
 
 std::vector<std::string> rt_print(const char* func, const HW::RenderTarget& rt) {
 	std::vector<std::string> dst;
-	dst.reserve(40);
+	dst.reserve(53);
 
 	dst.push_back(fmt::format("{}\n", func));
 
 	dst.push_back(fmt::format("\t base.addr                       = 0x{:016x}\n", rt.base.addr));
+	dst.push_back(
+	    fmt::format("\t pitch.pitch_div8_minus1         = 0x{:08x}\n", rt.pitch.pitch_div8_minus1));
+	dst.push_back(fmt::format("\t pitch.fmask_pitch_div8_minus1   = 0x{:08x}\n",
+	                          rt.pitch.fmask_pitch_div8_minus1));
+	dst.push_back(fmt::format("\t slice.slice_div64_minus1        = 0x{:08x}\n",
+	                          rt.slice.slice_div64_minus1));
 	dst.push_back(fmt::format("\t view.base_array_slice_index     = 0x{:08x}\n",
 	                          rt.view.base_array_slice_index));
 	dst.push_back(fmt::format("\t view.last_array_slice_index     = 0x{:08x}\n",
@@ -122,12 +134,17 @@ std::vector<std::string> rt_print(const char* func, const HW::RenderTarget& rt)
 	                          rt.info.cmask_fast_clear_enable ? "true" : "false"));
 	dst.push_back(fmt::format("\t info.dcc_compression_enable     = {}\n",
 	                          rt.info.dcc_compression_enable ? "true" : "false"));
-	dst.push_back(fmt::format("\t info.format                     = 0x{:08x}\n",
-	                          static_cast<uint32_t>(rt.info.format)));
-	dst.push_back(fmt::format("\t info.channel_type               = 0x{:08x}\n",
-	                          static_cast<uint32_t>(rt.info.channel_type)));
-	dst.push_back(fmt::format("\t info.channel_order              = 0x{:08x}\n",
-	                          static_cast<uint32_t>(rt.info.channel_order)));
+	dst.push_back(
+	    fmt::format("\t info.cmask_is_linear            = 0x{:08x}\n", rt.info.cmask_is_linear));
+	dst.push_back(
+	    fmt::format("\t info.cmask_addr_type            = 0x{:08x}\n", rt.info.cmask_addr_type));
+	dst.push_back(fmt::format("\t info.alt_tile_mode              = {}\n",
+	                          rt.info.alt_tile_mode ? "true" : "false"));
+	dst.push_back(fmt::format("\t info.format                     = 0x{:08x}\n", rt.info.format));
+	dst.push_back(
+	    fmt::format("\t info.channel_type               = 0x{:08x}\n", rt.info.channel_type));
+	dst.push_back(
+	    fmt::format("\t info.channel_order              = 0x{:08x}\n", rt.info.channel_order));
 	dst.push_back(fmt::format("\t info.blend_bypa                 = {}\n",
 	                          rt.info.blend_bypass ? "true" : "false"));
 	dst.push_back(fmt::format("\t info.blend_clamp                = {}\n",
@@ -136,6 +153,10 @@ std::vector<std::string> rt_print(const char* func, const HW::RenderTarget& rt)
 	                          rt.info.round_mode ? "true" : "false"));
 	dst.push_back(fmt::format("\t attrib.force_dest_alpha_to_one  = {}\n",
 	                          rt.attrib.force_dest_alpha_to_one ? "true" : "false"));
+	dst.push_back(
+	    fmt::format("\t attrib.tile_mode                = 0x{:08x}\n", rt.attrib.tile_mode));
+	dst.push_back(
+	    fmt::format("\t attrib.fmask_tile_mode          = 0x{:08x}\n", rt.attrib.fmask_tile_mode));
 	dst.push_back(
 	    fmt::format("\t attrib.num_samples              = 0x{:08x}\n", rt.attrib.num_samples));
 	dst.push_back(
@@ -146,56 +167,66 @@ std::vector<std::string> rt_print(const char* func, const HW::RenderTarget& rt)
 	dst.push_back(
 	    fmt::format("\t attrib2.num_mip_levels          = 0x{:08x}\n", rt.attrib2.num_mip_levels));
 	dst.push_back(fmt::format("\t attrib3.depth                   = 0x{:08x}\n", rt.attrib3.depth));
-	dst.push_back(fmt::format("\t attrib3.tile_mode               = 0x{:08x}\n",
-	                          static_cast<uint32_t>(rt.attrib3.tile_mode)));
+	dst.push_back(
+	    fmt::format("\t attrib3.tile_mode               = 0x{:08x}\n", rt.attrib3.tile_mode));
 	dst.push_back(
 	    fmt::format("\t attrib3.dimension               = 0x{:08x}\n", rt.attrib3.dimension));
-	dst.push_back(fmt::format("\t attrib3.metadata_pipe_aligned   = {}\n",
-	                          rt.attrib3.metadata_pipe_aligned ? "true" : "false"));
-	dst.push_back(fmt::format("\t attrib3.write_vrs_rate_hint_to_cmask = {}\n",
-	                          rt.attrib3.write_vrs_rate_hint_to_cmask ? "true" : "false"));
+	dst.push_back(fmt::format("\t attrib3.cmask_pipe_aligned      = {}\n",
+	                          rt.attrib3.cmask_pipe_aligned ? "true" : "false"));
+	dst.push_back(fmt::format("\t attrib3.dcc_pipe_aligned        = {}\n",
+	                          rt.attrib3.dcc_pipe_aligned ? "true" : "false"));
 	dst.push_back(fmt::format("\t dcc.max_uncompressed_block_size = 0x{:08x}\n",
 	                          rt.dcc.max_uncompressed_block_size));
 	dst.push_back(fmt::format("\t dcc.max_compressed_block_size   = 0x{:08x}\n",
 	                          rt.dcc.max_compressed_block_size));
+	dst.push_back(fmt::format("\t dcc.min_compressed_block_size   = 0x{:08x}\n",
+	                          rt.dcc.min_compressed_block_size));
 	dst.push_back(
 	    fmt::format("\t dcc.color_transform             = 0x{:08x}\n", rt.dcc.color_transform));
 	dst.push_back(fmt::format("\t dcc.overwrite_combiner_disable  = {}\n",
 	                          rt.dcc.overwrite_combiner_disable ? "true" : "false"));
-	dst.push_back(fmt::format("\t dcc.independent_block_size      = 0x{:02x}\n",
-	                          static_cast<uint8_t>(rt.dcc.independent_block_size)));
+	dst.push_back(fmt::format("\t dcc.independent_64b_blocks      = {}\n",
+	                          rt.dcc.independent_64b_blocks ? "true" : "false"));
+	dst.push_back(fmt::format("\t dcc.independent_128b_blocks     = {}\n",
+	                          rt.dcc.independent_128b_blocks ? "true" : "false"));
 	dst.push_back(fmt::format("\t data_write_on_dcc_clear_to_reg  = {}\n",
 	                          rt.dcc.data_write_on_dcc_clear_to_reg ? "true" : "false"));
 	dst.push_back(fmt::format("\t dcc.dcc_clear_key_enable        = {}\n",
 	                          rt.dcc.dcc_clear_key_enable ? "true" : "false"));
 	dst.push_back(fmt::format("\t cmask.addr                      = 0x{:016x}\n", rt.cmask.addr));
+	dst.push_back(fmt::format("\t cmask_slice.slice_minus1        = 0x{:08x}\n",
+	                          rt.cmask_slice.slice_minus1));
 	dst.push_back(fmt::format("\t fmask.addr                      = 0x{:016x}\n", rt.fmask.addr));
+	dst.push_back(fmt::format("\t fmask_slice.slice_minus1        = 0x{:08x}\n",
+	                          rt.fmask_slice.slice_minus1));
 	dst.push_back(
 	    fmt::format("\t clear_word0.word0               = 0x{:08x}\n", rt.clear_word0.word0));
 	dst.push_back(
 	    fmt::format("\t clear_word1.word1               = 0x{:08x}\n", rt.clear_word1.word1));
 	dst.push_back(
 	    fmt::format("\t dcc_addr.addr                   = 0x{:016x}\n", rt.dcc_addr.addr));
+	dst.push_back(fmt::format("\t size.width                      = 0x{:08x}\n", rt.size.width));
+	dst.push_back(fmt::format("\t size.height                     = 0x{:08x}\n", rt.size.height));
 
 	return dst;
 }
 
-static bool RenderIsColorTileMode(Prospero::TileMode tile_mode) {
+static bool RenderIsColorTileMode(uint32_t tile_mode) {
 	// AGC CxRenderTarget::TileMode shifted by CB_COLOR*_ATTRIB3.COLOR_SW_MODE.
 	switch (tile_mode) {
-		case Prospero::TileMode::kLinear:
-		case Prospero::TileMode::kStandard256B:
-		case Prospero::TileMode::kStandard4KB:
-		case Prospero::TileMode::kStandard64KB:
-		case Prospero::TileMode::kPrt:
-		case Prospero::TileMode::kDepth:
-		case Prospero::TileMode::kRenderTarget: return true;
+		case Prospero::GpuEnumValue(Prospero::TileMode::kLinear):
+		case Prospero::GpuEnumValue(Prospero::TileMode::kStandard256B):
+		case Prospero::GpuEnumValue(Prospero::TileMode::kStandard4KB):
+		case Prospero::GpuEnumValue(Prospero::TileMode::kStandard64KB):
+		case Prospero::GpuEnumValue(Prospero::TileMode::kPrt):
+		case Prospero::GpuEnumValue(Prospero::TileMode::kDepth):
+		case Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget): return true;
 		default: return false;
 	}
 }
 
-bool RenderIsColorTileModeLinear(Prospero::TileMode tile_mode) {
-	return tile_mode == Prospero::TileMode::kLinear;
+bool RenderIsColorTileModeLinear(uint32_t tile_mode) {
+	return tile_mode == Prospero::GpuEnumValue(Prospero::TileMode::kLinear);
 }
 
 static bool RenderIsColorDimension(uint32_t dimension) {
@@ -205,8 +236,13 @@ static bool RenderIsColorDimension(uint32_t dimension) {
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
 static void RtCheck(const HW::RenderTarget& rt) {
 	if (rt.base.addr != 0) {
+		// bool render_to_texture = (rt.attrib.tile_mode == 0x0d);
 		//  EXIT_NOT_IMPLEMENTED(rt.base_addr == 0);
 
+		EXIT_NOT_IMPLEMENTED(rt.pitch.pitch_div8_minus1 != 0);
+		EXIT_NOT_IMPLEMENTED(rt.pitch.fmask_pitch_div8_minus1 != 0);
+		EXIT_NOT_IMPLEMENTED(rt.slice.slice_div64_minus1 != 0);
+
 		EXIT_NOT_IMPLEMENTED(rt.view.base_array_slice_index > rt.view.last_array_slice_index);
 		if (rt.view.base_array_slice_index != 0x00000000 ||
 		    rt.view.last_array_slice_index != 0x00000000) {
@@ -230,14 +266,16 @@ static void RtCheck(const HW::RenderTarget& rt) {
 			EXIT_NOT_IMPLEMENTED(rt.attrib.num_samples == 0 && rt.attrib.num_fragments == 0);
 			static bool logged = false;
 			if (!logged) {
-				LOGF("RenderTarget: using native Vulkan MSAA without guest FMASK metadata, "
-				     "fmask=0x%016" PRIx64 "\n",
+				LOGF("RenderTarget: temporary: ignoring PS5 FMASK metadata for single-sample MSAA "
+				     "fallback, fmask=0x%016" PRIx64 "\n",
 				     rt.fmask.addr);
 				logged = true;
 			}
 		}
 
+		// EXIT_NOT_IMPLEMENTED(rt.info.fmask_compression_mode != 0x00000000);
 		EXIT_NOT_IMPLEMENTED(rt.info.fmask_data_compression_disable != false);
+		EXIT_NOT_IMPLEMENTED(rt.info.fmask_one_frag_mode != false);
 
 		if (rt.info.cmask_fast_clear_enable || rt.info.dcc_compression_enable) {
 			static bool logged = false;
@@ -250,6 +288,22 @@ static void RtCheck(const HW::RenderTarget& rt) {
 				logged = true;
 			}
 		}
+		if (rt.info.cmask_is_linear != 0x00000000 || rt.info.cmask_addr_type != 0x00000000) {
+			static bool logged = false;
+			if (!logged) {
+				LOGF("RenderTarget: temporary: ignoring PS5 CMASK metadata fields "
+				     "is_linear=%u addr_type=%u\n",
+				     rt.info.cmask_is_linear, rt.info.cmask_addr_type);
+				logged = true;
+			}
+		}
+		if (rt.info.alt_tile_mode) {
+			static bool logged = false;
+			if (!logged) {
+				LOGF("RenderTarget: temporary: ignoring alternate tile mode flag\n");
+				logged = true;
+			}
+		}
 		if (rt.info.blend_bypass) {
 			static bool logged = false;
 			if (!logged) {
@@ -276,6 +330,8 @@ static void RtCheck(const HW::RenderTarget& rt) {
 				logged = true;
 			}
 		}
+		// EXIT_NOT_IMPLEMENTED(rt.tile_mode != 0x0000000a);
+		// EXIT_NOT_IMPLEMENTED(rt.fmask_tile_mode != 0x0000000a);
 		if (rt.attrib.num_samples != 0x00000000 || rt.attrib.num_fragments != 0x00000000) {
 			static bool logged = false;
 			if (!logged) {
@@ -303,29 +359,58 @@ static void RtCheck(const HW::RenderTarget& rt) {
 				logged = true;
 			}
 		}
+		if (rt.attrib3.depth != 0x00000000) {
+			static bool logged = false;
+			if (!logged) {
+				LOGF("RenderTarget: temporary: ignoring PS5 color target depth_minus1=0x%08" PRIx32
+				     "\n",
+				     rt.attrib3.depth);
+				logged = true;
+			}
+		}
 		if (!RenderIsColorTileMode(rt.attrib3.tile_mode)) {
-			EXIT("unknown PS5 render-target tile mode: 0x%08" PRIx32 "\n",
-			     static_cast<uint32_t>(rt.attrib3.tile_mode));
+			EXIT("unknown PS5 render-target tile mode: 0x%08" PRIx32 "\n", rt.attrib3.tile_mode);
 		}
 		if (!RenderIsColorDimension(rt.attrib3.dimension)) {
 			EXIT("unknown PS5 render-target dimension: 0x%08" PRIx32 "\n", rt.attrib3.dimension);
 		}
-		if (!rt.attrib3.metadata_pipe_aligned) {
+		if (rt.attrib3.dimension != 0x00000001) {
 			static bool logged = false;
 			if (!logged) {
-				LOGF("RenderTarget: temporary: accepting unaligned PS5 metadata pipe flag\n");
+				LOGF("RenderTarget: temporary: using 2D fallback for PS5 color "
+				     "dimension=0x%08" PRIx32 "\n",
+				     rt.attrib3.dimension);
+				logged = true;
+			}
+		}
+		if (!rt.attrib3.cmask_pipe_aligned) {
+			static bool logged = false;
+			if (!logged) {
+				LOGF("RenderTarget: temporary: accepting unaligned PS5 CMASK pipe flag\n");
+				logged = true;
+			}
+		}
+		if (!rt.attrib3.dcc_pipe_aligned) {
+			static bool logged = false;
+			if (!logged) {
+				LOGF("RenderTarget: temporary: accepting unaligned PS5 DCC pipe flag\n");
 				logged = true;
 			}
 		}
-		EXIT_NOT_IMPLEMENTED(rt.attrib3.write_vrs_rate_hint_to_cmask);
 
 		// EXIT_NOT_IMPLEMENTED(rt.dcc_max_uncompressed_block_size != 0x00000002);
 		// EXIT_NOT_IMPLEMENTED(rt.dcc.max_compressed_block_size != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(rt.dcc.min_compressed_block_size != 0x00000000);
 		// EXIT_NOT_IMPLEMENTED(rt.dcc.color_transform != 0x00000000);
 		EXIT_NOT_IMPLEMENTED(rt.dcc.overwrite_combiner_disable != false);
+		// EXIT_NOT_IMPLEMENTED(rt.dcc.force_independent_blocks != false);
+		// EXIT_NOT_IMPLEMENTED(rt.dcc.independent_128b_blocks != false);
 		// EXIT_NOT_IMPLEMENTED(rt.dcc.data_write_on_dcc_clear_to_reg != false);
 		EXIT_NOT_IMPLEMENTED(rt.dcc.dcc_clear_key_enable != false);
-		if (rt.cmask.addr != 0x0000000000000000 || rt.fmask.addr != 0x0000000000000000 ||
+		if (rt.cmask.addr != 0x0000000000000000 || rt.cmask_slice.slice_minus1 != 0x00000000 ||
+		    rt.fmask.addr != 0x0000000000000000 ||
+		    (rt.fmask_slice.slice_minus1 != 0x00000000 &&
+		     rt.fmask_slice.slice_minus1 != rt.slice.slice_div64_minus1) ||
 		    rt.dcc_addr.addr != 0x0000000000000000) {
 			static bool logged = false;
 			if (!logged) {
@@ -335,6 +420,9 @@ static void RtCheck(const HW::RenderTarget& rt) {
 				logged = true;
 			}
 		}
+
+		EXIT_NOT_IMPLEMENTED(rt.size.width != 0);
+		EXIT_NOT_IMPLEMENTED(rt.size.height != 0);
 	}
 }
 
@@ -354,63 +442,81 @@ static void ZPrint(const char* func, const HW::DepthRenderTarget& z) {
 	     "\t stencil_info.htile_stencil_disabled   = %s\n"
 	     "\t stencil_info.expclear_enabled         = %s\n"
 	     "\t stencil_info.partially_resident       = %s\n"
+	     "\t depth_info.addr5_swizzle_mask         = 0x%08" PRIx32 "\n"
+	     "\t depth_info.array_mode                 = 0x%08" PRIx32 "\n"
+	     "\t depth_info.pipe_config                = 0x%08" PRIx32 "\n"
+	     "\t depth_info.bank_width                 = 0x%08" PRIx32 "\n"
+	     "\t depth_info.bank_height                = 0x%08" PRIx32 "\n"
+	     "\t depth_info.macro_tile_aspect          = 0x%08" PRIx32 "\n"
+	     "\t depth_info.num_banks                  = 0x%08" PRIx32 "\n"
 	     "\t depth_view.slice_start                = 0x%08" PRIx32 "\n"
 	     "\t depth_view.slice_max                  = 0x%08" PRIx32 "\n"
 	     "\t depth_view.current_mip_level          = 0x%02" PRIx8 "\n"
 	     "\t depth_view.depth_write_disable        = %s\n"
 	     "\t depth_view.stencil_write_disable      = %s\n"
+	     "\t htile_surface.linear                  = 0x%08" PRIx32 "\n"
+	     "\t htile_surface.full_cache              = 0x%08" PRIx32 "\n"
+	     "\t htile_surface.htile_uses_preload_win  = 0x%08" PRIx32 "\n"
+	     "\t htile_surface.preload                 = 0x%08" PRIx32 "\n"
+	     "\t htile_surface.prefetch_width          = 0x%08" PRIx32 "\n"
+	     "\t htile_surface.prefetch_height         = 0x%08" PRIx32 "\n"
+	     "\t htile_surface.dst_outside_zero_to_one = 0x%08" PRIx32 "\n"
 	     "\t z_read_base_addr                      = 0x%016" PRIx64 "\n"
 	     "\t stencil_read_base_addr                = 0x%016" PRIx64 "\n"
 	     "\t z_write_base_addr                     = 0x%016" PRIx64 "\n"
 	     "\t stencil_write_base_addr               = 0x%016" PRIx64 "\n"
+	     "\t pitch_div8_minus1                     = 0x%08" PRIx32 "\n"
+	     "\t height_div8_minus1                    = 0x%08" PRIx32 "\n"
+	     "\t slice_div64_minus1                    = 0x%08" PRIx32 "\n"
 	     "\t htile_data_base_addr                  = 0x%016" PRIx64 "\n"
-	     "\t shading_rate_encoding                 = 0x%02" PRIx8 "\n"
+	     "\t width                                 = 0x%08" PRIx32 "\n"
+	     "\t height                                = 0x%08" PRIx32 "\n"
 	     "\t size.x_max                            = 0x%04" PRIx16 "\n"
-	     "\t size.y_max                            = 0x%04" PRIx16 "\n"
-	     "\t size.valid                            = %s\n",
-	     static_cast<uint32_t>(z.z_info.format), z.z_info.num_samples,
-	     static_cast<uint32_t>(z.z_info.texture_compatibility),
+	     "\t size.y_max                            = 0x%04" PRIx16 "\n",
+	     z.z_info.format, z.z_info.num_samples,
+	     Prospero::GpuEnumValue(z.z_info.texture_compatibility),
 	     z.z_info.htile_acceleration ? "true" : "false",
 	     z.z_info.expclear_enabled ? "true" : "false",
-	     static_cast<uint32_t>(z.z_info.z_compare_base),
+	     Prospero::GpuEnumValue(z.z_info.z_compare_base),
 	     z.z_info.partially_resident ? "true" : "false", z.z_info.max_mip_level,
-	     static_cast<uint32_t>(z.stencil_info.format),
-	     static_cast<uint32_t>(z.stencil_info.texture_compatibility),
+	     z.stencil_info.format, Prospero::GpuEnumValue(z.stencil_info.texture_compatibility),
 	     z.stencil_info.htile_stencil_disabled ? "true" : "false",
 	     z.stencil_info.expclear_enabled ? "true" : "false",
-	     z.stencil_info.partially_resident ? "true" : "false", z.depth_view.slice_start,
-	     z.depth_view.slice_max, z.depth_view.current_mip_level,
+	     z.stencil_info.partially_resident ? "true" : "false", z.depth_info.addr5_swizzle_mask,
+	     z.depth_info.array_mode, z.depth_info.pipe_config, z.depth_info.bank_width,
+	     z.depth_info.bank_height, z.depth_info.macro_tile_aspect, z.depth_info.num_banks,
+	     z.depth_view.slice_start, z.depth_view.slice_max, z.depth_view.current_mip_level,
 	     z.depth_view.depth_write_disable ? "true" : "false",
-	     z.depth_view.stencil_write_disable ? "true" : "false", z.z_read_base_addr,
-	     z.stencil_read_base_addr, z.z_write_base_addr, z.stencil_write_base_addr,
-	     z.htile_data_base_addr, z.shading_rate_encoding, z.size.x_max, z.size.y_max,
-	     z.size.valid ? "true" : "false");
+	     z.depth_view.stencil_write_disable ? "true" : "false", z.htile_surface.linear,
+	     z.htile_surface.full_cache, z.htile_surface.htile_uses_preload_win,
+	     z.htile_surface.preload, z.htile_surface.prefetch_width, z.htile_surface.prefetch_height,
+	     z.htile_surface.dst_outside_zero_to_one, z.z_read_base_addr, z.stencil_read_base_addr,
+	     z.z_write_base_addr, z.stencil_write_base_addr, z.pitch_div8_minus1, z.height_div8_minus1,
+	     z.slice_div64_minus1, z.htile_data_base_addr, z.width, z.height, z.size.x_max,
+	     z.size.y_max);
 }
 
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
 static void ZCheck(const HW::DepthRenderTarget& z, const HW::DepthControl& dc,
                    const HW::RenderControl& rc) {
-	const bool depth_active = dc.z_enable || dc.z_write_enable || dc.depth_bounds_enable ||
-	                          rc.depth_clear_enable || rc.copy_depth_to_color;
-	const bool stencil_active =
-	    dc.stencil_enable || rc.stencil_clear_enable || rc.copy_stencil_to_color;
+	const bool depth_active =
+	    dc.z_enable || dc.z_write_enable || dc.depth_bounds_enable || rc.depth_clear_enable;
+	const bool stencil_active = dc.stencil_enable || rc.stencil_clear_enable;
 	if (!depth_active && !stencil_active) {
 		return;
 	}
 
-	EXIT_NOT_IMPLEMENTED(rc.copy_depth_to_color || rc.copy_stencil_to_color);
 	EXIT_NOT_IMPLEMENTED(!z.z_info.HasValidTextureCompatibility());
 	EXIT_NOT_IMPLEMENTED(!z.stencil_info.HasValidTextureCompatibility());
-	if (z.z_info.format == Prospero::DepthFormat::kInvalid) {
-		EXIT_NOT_IMPLEMENTED(z.z_info.format != Prospero::DepthFormat::kInvalid);
+	if (z.z_info.format == 0) {
+		EXIT_NOT_IMPLEMENTED(z.z_info.format != 0);
 		EXIT_NOT_IMPLEMENTED(z.z_info.num_samples != 0);
 		EXIT_NOT_IMPLEMENTED(z.z_info.htile_acceleration != false);
 		EXIT_NOT_IMPLEMENTED(z.z_info.expclear_enabled != false);
 		EXIT_NOT_IMPLEMENTED(z.z_info.partially_resident != false);
 		EXIT_NOT_IMPLEMENTED(z.z_info.max_mip_level != 0);
 	} else {
-		EXIT_NOT_IMPLEMENTED(z.z_info.format != Prospero::DepthFormat::kZ16 &&
-		                     z.z_info.format != Prospero::DepthFormat::kZ32F);
+		EXIT_NOT_IMPLEMENTED(z.z_info.format != 0x00000001 && z.z_info.format != 0x00000003);
 		if (z.z_info.num_samples != 0x00000000) {
 			static bool logged = false;
 			if (!logged) {
@@ -424,18 +530,31 @@ static void ZCheck(const HW::DepthRenderTarget& z, const HW::DepthControl& dc,
 		EXIT_NOT_IMPLEMENTED(z.z_info.max_mip_level != 0);
 	}
 
-	if (z.stencil_info.format == Prospero::StencilFormat::kInvalid) {
+	if (z.stencil_info.format == 0) {
 		EXIT_NOT_IMPLEMENTED(z.stencil_info.expclear_enabled != false);
 		EXIT_NOT_IMPLEMENTED(z.stencil_info.partially_resident != false);
 	} else {
-		EXIT_NOT_IMPLEMENTED(z.stencil_info.format != Prospero::StencilFormat::k8UInt);
+		EXIT_NOT_IMPLEMENTED(z.stencil_info.format != 0x00000001);
 		EXIT_NOT_IMPLEMENTED(z.stencil_info.expclear_enabled != false);
 		EXIT_NOT_IMPLEMENTED(z.stencil_info.partially_resident != false);
 	}
 
-	if (z.z_info.format != Prospero::DepthFormat::kInvalid ||
-	    z.stencil_info.format != Prospero::StencilFormat::kInvalid) {
-		EXIT_NOT_IMPLEMENTED(z.shading_rate_encoding != 0);
+	if (z.z_info.format != 0 || z.stencil_info.format != 0) {
+
+		EXIT_NOT_IMPLEMENTED(z.depth_info.addr5_swizzle_mask != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.depth_info.array_mode != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.depth_info.pipe_config != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.depth_info.bank_width != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.depth_info.bank_height != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.depth_info.macro_tile_aspect != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.depth_info.num_banks != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.htile_surface.linear != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.htile_surface.full_cache != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.htile_surface.htile_uses_preload_win != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.htile_surface.preload != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.htile_surface.prefetch_width != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.htile_surface.prefetch_height != 0x00000000);
+		EXIT_NOT_IMPLEMENTED(z.htile_surface.dst_outside_zero_to_one != 0x00000000);
 
 		if (z.depth_view.current_mip_level != 0x00000000) {
 			static std::atomic<uint32_t> log_count {0};
@@ -452,13 +571,30 @@ static void ZCheck(const HW::DepthRenderTarget& z, const HW::DepthControl& dc,
 				     z.depth_view.stencil_write_disable ? "true" : "false");
 			}
 		}
-		EXIT_NOT_IMPLEMENTED(!z.depth_view.depth_write_disable &&
-		                     z.z_read_base_addr != z.z_write_base_addr);
-		EXIT_NOT_IMPLEMENTED(!z.depth_view.stencil_write_disable &&
-		                     z.stencil_read_base_addr != z.stencil_write_base_addr);
-		EXIT_NOT_IMPLEMENTED(!z.depth_view.depth_write_disable && z.z_write_base_addr == 0);
+		EXIT_NOT_IMPLEMENTED(z.z_read_base_addr != z.z_write_base_addr);
+		EXIT_NOT_IMPLEMENTED(z.stencil_read_base_addr != z.stencil_write_base_addr);
+		EXIT_NOT_IMPLEMENTED(z.z_write_base_addr == 0);
+		if (z.stencil_info.format != 0 && z.stencil_write_base_addr == 0) {
+			LOGF("\t warning: stencil format is set without a stencil base address, continuing "
+			     "without stencil attachment\n");
+		}
+		// EXIT_NOT_IMPLEMENTED(z.pitch_div8_minus1 != 0x000000ff);
+		// EXIT_NOT_IMPLEMENTED(z.height_div8_minus1 != 0x0000008f);
+		// EXIT_NOT_IMPLEMENTED(z.slice_div64_minus1 != 0x00008fff);
 		// EXIT_NOT_IMPLEMENTED(z.htile_data_base_addr == 0);
-		EXIT_NOT_IMPLEMENTED(!z.size.valid);
+		// EXIT_NOT_IMPLEMENTED(z.width != 0x00000780);
+		// EXIT_NOT_IMPLEMENTED(z.height != 0x00000438);
+
+		EXIT_NOT_IMPLEMENTED(z.width != 0);
+		EXIT_NOT_IMPLEMENTED(z.height != 0);
+		if (z.size.x_max == 0 || z.size.y_max == 0) {
+			static std::atomic<uint32_t> log_count {0};
+			if (log_count.fetch_add(1) < 16) {
+				LOGF("DepthTarget: temporary: inferring PS5 default depth extent x_max=0x%04" PRIx16
+				     ", y_max=0x%04" PRIx16 "\n",
+				     z.size.x_max, z.size.y_max);
+			}
+		}
 	}
 }
 
@@ -490,7 +626,8 @@ static void ClipCheck(const HW::ClipControl& c) {
 	// dx_linear_attr_clip_enable preserves linear (noperspective) attributes at clip-generated
 	// vertices, which Vulkan provides as part of clipping and interpolation.
 	EXIT_NOT_IMPLEMENTED(c.user_clip_planes != 0 || c.user_clip_plane_mode != 0 ||
-	                     c.vertex_kill_any || c.user_clip_plane_negate_y ||
+	                     c.vertex_kill_any || !c.IsZClipModeRepresentable() ||
+	                     c.user_clip_plane_negate_y || c.clip_disable ||
 	                     c.user_clip_plane_cull_only || c.cull_on_clipping_error_disable ||
 	                     c.force_viewport_index_from_vs_enable);
 }
@@ -514,6 +651,17 @@ static void RcPrint(const char* func, const HW::RenderControl& c) {
 static void RcCheck(const HW::RenderControl& c) {
 	// EXIT_NOT_IMPLEMENTED(c.depth_clear_enable != false);
 	// EXIT_NOT_IMPLEMENTED(c.stencil_clear_enable != false);
+	if ((c.resummarize_enable || c.copy_centroid || c.copy_sample != 0)) {
+		static std::atomic<uint32_t> log_count {0};
+		if (log_count.fetch_add(1) < 16) {
+			LOGF("\t warning: unsupported PS5 render-control metadata state, continuing: "
+			     "resummarize=%s copy_centroid=%s copy_sample=%" PRIu8 "\n",
+			     c.resummarize_enable ? "true" : "false", c.copy_centroid ? "true" : "false",
+			     c.copy_sample);
+		}
+		return;
+	}
+	EXIT_NOT_IMPLEMENTED(c.resummarize_enable != false);
 	// EXIT_NOT_IMPLEMENTED(c.stencil_compress_disable != false);
 	// EXIT_NOT_IMPLEMENTED(c.depth_compress_disable != false);
 	EXIT_NOT_IMPLEMENTED(c.copy_centroid != false);
@@ -556,6 +704,14 @@ static void McCheck(const HW::ModeControl& c) {
 	}
 	EXIT_NOT_IMPLEMENTED(c.polymode_front_ptype != 0 && c.polymode_front_ptype != 2);
 	EXIT_NOT_IMPLEMENTED(c.polymode_back_ptype != 0 && c.polymode_back_ptype != 2);
+	if (c.poly_offset_front_enable || c.poly_offset_back_enable) {
+		static bool logged = false;
+		if (!logged) {
+			LOGF("\t temporary: PA_SU_SC_MODE_CNTL.POLY_OFFSET_*_ENABLE is not implemented; "
+			     "continuing without depth bias\n");
+			logged = true;
+		}
+	}
 	if (c.vtx_window_offset_enable) {
 		static bool logged = false;
 		if (!logged) {
@@ -641,6 +797,8 @@ static void DPrint(const char* func, const HW::DepthControl& c, const HW::Stenci
 	     "\t backface_enable      = %s\n"
 	     "\t stencilfunc          = %" PRIu8 "\n"
 	     "\t stencilfunc_bf       = %" PRIu8 "\n"
+	     "\t color_writes_on_depth_fail_enable  = %s\n"
+	     "\t color_writes_on_depth_pass_disable = %s\n"
 	     "\t stencil_fail         = %" PRIu8 "\n"
 	     "\t stencil_zpass        = %" PRIu8 "\n"
 	     "\t stencil_zfail        = %" PRIu8 "\n"
@@ -657,11 +815,12 @@ static void DPrint(const char* func, const HW::DepthControl& c, const HW::Stenci
 	     "\t stencil_opval_bf     = %" PRIu8 "\n",
 	     c.stencil_enable ? "true" : "false", c.z_enable ? "true" : "false",
 	     c.z_write_enable ? "true" : "false", c.depth_bounds_enable ? "true" : "false", c.zfunc,
-	     c.backface_enable ? "true" : "false", c.stencilfunc, c.stencilfunc_bf, s.stencil_fail,
-	     s.stencil_zpass, s.stencil_zfail, s.stencil_fail_bf, s.stencil_zpass_bf,
-	     s.stencil_zfail_bf, sm.stencil_testval, sm.stencil_mask, sm.stencil_writemask,
-	     sm.stencil_opval, sm.stencil_testval_bf, sm.stencil_mask_bf, sm.stencil_writemask_bf,
-	     sm.stencil_opval_bf);
+	     c.backface_enable ? "true" : "false", c.stencilfunc, c.stencilfunc_bf,
+	     c.color_writes_on_depth_fail_enable ? "true" : "false",
+	     c.color_writes_on_depth_pass_disable ? "true" : "false", s.stencil_fail, s.stencil_zpass,
+	     s.stencil_zfail, s.stencil_fail_bf, s.stencil_zpass_bf, s.stencil_zfail_bf,
+	     sm.stencil_testval, sm.stencil_mask, sm.stencil_writemask, sm.stencil_opval,
+	     sm.stencil_testval_bf, sm.stencil_mask_bf, sm.stencil_writemask_bf, sm.stencil_opval_bf);
 }
 
 static void DCheck(const HW::DepthControl& c, const HW::StencilControl& s,
@@ -673,6 +832,8 @@ static void DCheck(const HW::DepthControl& c, const HW::StencilControl& s,
 	// Back-face stencil state is handled separately when enabled.
 	// EXIT_NOT_IMPLEMENTED(c.stencilfunc != 0);
 	// EXIT_NOT_IMPLEMENTED(c.stencilfunc_bf != 0);
+	EXIT_NOT_IMPLEMENTED(c.color_writes_on_depth_fail_enable != false);
+	EXIT_NOT_IMPLEMENTED(c.color_writes_on_depth_pass_disable != false);
 	// EXIT_NOT_IMPLEMENTED(s.stencil_fail != 0);
 	// EXIT_NOT_IMPLEMENTED(s.stencil_zpass != 0);
 	// EXIT_NOT_IMPLEMENTED(s.stencil_zfail != 0);
@@ -704,12 +865,7 @@ static void EqaaPrint(const char* func, const HW::EqaaControl& c) {
 	     c.static_anchor_associations ? "true" : "false");
 }
 
-static void EqaaCheck(const HW::EqaaControl& c, const HW::AaConfig& cf) {
-	// The EQAA controls only take effect while multisampling is on, so a single-sample
-	// target leaves them inert and has nothing to warn about.
-	if (cf.msaa_num_samples == 0) {
-		return;
-	}
+static void EqaaCheck(const HW::EqaaControl& c) {
 	if (c.max_anchor_samples != 0 || c.ps_iter_samples != 0 || c.mask_export_num_samples != 0 ||
 	    c.alpha_to_mask_num_samples != 0 || c.high_quality_intersections ||
 	    c.incoherent_eqaa_reads || c.interpolate_comp_z || c.static_anchor_associations) {
@@ -761,10 +917,12 @@ void LogDrawPhase(const char* draw_name, const char* phase) {
 	}
 }
 
-void LogPipelineTrace(const char* phase, uint64_t vertex_program_id, uint64_t pixel_program_id) {
+void LogPipelineTrace(const char* phase, uint32_t vs_hash0, uint32_t vs_crc32, uint32_t ps_hash0,
+                      uint32_t ps_crc32) {
 	if (graphics_debug_dump_enabled()) {
-		LOGF("PipelineTrace: %s VS=%" PRIu64 " PS=%" PRIu64 "\n", phase, vertex_program_id,
-		     pixel_program_id);
+		LOGF("PipelineTrace: %s VS=0x%08" PRIx32 "/0x%08" PRIx32 " PS=0x%08" PRIx32 "/0x%08" PRIx32
+		     "\n",
+		     phase, vs_hash0, vs_crc32, ps_hash0, ps_crc32);
 	}
 }
 
@@ -927,24 +1085,18 @@ static ScissorRect ScissorRectClamp(ScissorRect r, uint32_t width, uint32_t heig
 	return r;
 }
 
-static constexpr std::array<uint16_t, 16> MakeScissorIntersectionRules() {
-	std::array<uint16_t, 16> rules {};
-	for (uint32_t candidate = 0; candidate < rules.size(); candidate++) {
-		for (uint32_t combination = 0; combination < 16; combination++) {
-			if ((combination & candidate) == candidate) {
-				rules[candidate] |= static_cast<uint16_t>(1u << combination);
-			}
-		}
-	}
-	return rules;
-}
-
 static bool ScissorClipRuleToIntersectionMask(uint16_t rule, uint8_t* mask) {
 	EXIT_IF(mask == nullptr);
 
-	static constexpr auto rules = MakeScissorIntersectionRules();
-	for (uint32_t candidate = 0; candidate < rules.size(); candidate++) {
-		if (rules[candidate] == rule) {
+	for (uint32_t candidate = 0; candidate < 16; candidate++) {
+		uint16_t expected = 0;
+		for (uint32_t combination = 0; combination < 16; combination++) {
+			if ((combination & candidate) == candidate) {
+				expected |= static_cast<uint16_t>(1u << combination);
+			}
+		}
+
+		if (expected == rule) {
 			*mask = static_cast<uint8_t>(candidate);
 			return true;
 		}
@@ -1028,7 +1180,7 @@ ScissorRect calc_final_scissor(const HW::ScreenViewport& vp, const HW::ScanModeC
 	return ScissorRectClamp(final, extent.width, extent.height);
 }
 
-void hw_check(const CommandBuffer& buffer) {
+void hw_check(const RenderCommandBuffer& buffer) {
 	const auto& hw      = buffer.GetRegisters();
 	const auto  rt_slot = render_target_first_bound_slot(buffer);
 	const auto& rt      = hw.GetRenderTarget(rt_slot);
@@ -1074,20 +1226,19 @@ void hw_check(const CommandBuffer& buffer) {
 	log_phase("blend");
 	BcCheck(bc, bclr, cc);
 	log_phase("eqaa");
-	EqaaCheck(eqaa, ac);
+	EqaaCheck(eqaa);
 	log_phase("aa");
 	AaCheck(aa, ac);
 	log_phase("done");
 
-	if (graphics_debug_dump_enabled() && RenderTargetMaskHasBoundMrt(buffer)) {
+	if (RenderTargetMaskHasBoundMrt(buffer)) {
 		LOGF("MRT render target mask: 0x%08" PRIx32 "\n", hw.GetRenderTargetMask());
 		for (uint32_t i = 0; i < 8; i++) {
 			const auto& mrt = hw.GetRenderTarget(i);
 			LOGF("\t RT%u addr=0x%010" PRIx64 " mask=0x%x fmt=0x%08" PRIx32
 			     " width=%u height=%u tile=%u\n",
-			     i, mrt.base.addr, (hw.GetRenderTargetMask() >> (i * 4u)) & 0x0fu,
-			     static_cast<uint32_t>(mrt.info.format), mrt.attrib2.width + 1,
-			     mrt.attrib2.height + 1, static_cast<uint32_t>(mrt.attrib3.tile_mode));
+			     i, mrt.base.addr, (hw.GetRenderTargetMask() >> (i * 4u)) & 0x0fu, mrt.info.format,
+			     mrt.attrib2.width + 1, mrt.attrib2.height + 1, mrt.attrib3.tile_mode);
 		}
 	}
 	if (rc.depth_clear_enable && hw.GetDepthClearValue() != 0.0f &&
@@ -1101,7 +1252,7 @@ void hw_check(const CommandBuffer& buffer) {
 	// EXIT_NOT_IMPLEMENTED(hw.GetStencilClearValue() != 0);
 }
 
-void hw_print(const CommandBuffer& buffer) {
+void hw_print(const RenderCommandBuffer& buffer) {
 	const auto& hw      = buffer.GetRegisters();
 	const auto  rt_slot = render_target_first_bound_slot(buffer);
 	const auto& rt      = hw.GetRenderTarget(rt_slot);
@@ -1126,10 +1277,9 @@ void hw_print(const CommandBuffer& buffer) {
 		     "\t GetRenderTargetMask()   = 0x%08" PRIx32 "\n"
 		     "\t GetDepthClearValue()    = %f\n"
 		     "\t GetStencilClearValue()  = %" PRIu8 "\n"
-		     "\t GetLineWidth()          = %f\n"
-		     "\t primitive_reset_index   = 0x%08" PRIx32 "\n",
+		     "\t GetLineWidth()          = %f\n",
 		     hw.GetRenderTargetMask(), hw.GetDepthClearValue(), hw.GetStencilClearValue(),
-		     hw.GetLineWidth(), hw.GetPrimitiveResetIndex());
+		     hw.GetLineWidth());
 
 		LOGF("%s", Common::Concat(rt_print("RenderTraget:", rt), "").c_str());
 

src/graphics/host_gpu/renderer/debug.h

@@ -9,7 +9,7 @@
 
 namespace Libs::Graphics {
 
-class CommandBuffer;
+class RenderCommandBuffer;
 
 namespace HW {
 class Context;
@@ -28,15 +28,15 @@ struct ScissorRect {
 };
 
 uint32_t                 render_target_mask_slot(uint32_t mask, uint32_t slot);
-uint32_t                 render_target_first_bound_slot(const CommandBuffer& buffer);
+uint32_t                 render_target_first_bound_slot(const RenderCommandBuffer& buffer);
 bool                     graphics_debug_dump_enabled();
 void                     uc_print(const char* func, const HW::UserConfig& uc);
 void                     uc_check(const HW::UserConfig& uc);
 void                     sh_print(const char* func, const HW::Shader& uc);
 std::vector<std::string> rt_print(const char* func, const HW::RenderTarget& rt);
-bool                     RenderIsColorTileModeLinear(Prospero::TileMode tile_mode);
-void                     hw_print(const CommandBuffer& buffer);
-void                     hw_check(const CommandBuffer& buffer);
+bool                     RenderIsColorTileModeLinear(uint32_t tile_mode);
+void                     hw_print(const RenderCommandBuffer& buffer);
+void                     hw_check(const RenderCommandBuffer& buffer);
 void                     LogDrawPhase(const char* draw_name, const char* phase);
 ScissorRect calc_final_scissor(const HW::ScreenViewport& vp, const HW::ScanModeControl& smc,
                                vk::Extent2D extent);

src/graphics/host_gpu/renderer/depthRenderTarget.cpp

@@ -13,6 +13,7 @@
 #include "graphics/host_gpu/renderer/debug.h"
 #include "graphics/host_gpu/renderer/image/imageView.h"
 #include "graphics/host_gpu/renderer/image/textureCommon.h"
+#include "graphics/host_gpu/renderer/pipeline/descriptorCache.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vulkanCommon.h"
@@ -37,10 +38,7 @@ namespace Libs::Graphics {
 	EXIT("unsupported render state; details were printed above\n");
 }
 
-static vk::StencilOp ConvertStencilOp(uint8_t value, uint8_t write_mask, uint8_t op_value) {
-	if (write_mask == 0) {
-		return vk::StencilOp::eKeep;
-	}
+static vk::StencilOp ConvertStencilOp(uint8_t value) {
 	switch (static_cast<Prospero::StencilOp>(value)) {
 		case Prospero::StencilOp::kKeep: return vk::StencilOp::eKeep;
 		case Prospero::StencilOp::kZero: return vk::StencilOp::eZero;
@@ -51,27 +49,18 @@ static vk::StencilOp ConvertStencilOp(uint8_t value, uint8_t write_mask, uint8_t
 		case Prospero::StencilOp::kInvert: return vk::StencilOp::eInvert;
 		case Prospero::StencilOp::kAddWrap: return vk::StencilOp::eIncrementAndWrap;
 		case Prospero::StencilOp::kSubWrap: return vk::StencilOp::eDecrementAndWrap;
-		case Prospero::StencilOp::kXor:
-			if ((write_mask & op_value) == 0) {
-				return vk::StencilOp::eKeep;
-			}
-			if ((write_mask & ~op_value) != 0) {
-				DepthFatal("unsupported stencil XOR operands: write mask=0x%02" PRIx8
-				           ", operation value=0x%02" PRIx8,
-				           write_mask, op_value);
-			}
-			return vk::StencilOp::eInvert;
-		default: DepthFatal("unsupported stencil operation: 0x%02" PRIx8, value);
+		default: DepthFatal("unsupported stencil operation");
 	}
 }
 
 static bool UsesStencilOpValue(uint8_t fail, uint8_t pass, uint8_t depth_fail) {
-	constexpr auto replace_op = static_cast<uint8_t>(Prospero::StencilOp::kReplaceOp);
-	return fail == replace_op || pass == replace_op || depth_fail == replace_op;
+	return fail == Prospero::GpuEnumValue(Prospero::StencilOp::kReplaceOp) ||
+	       pass == Prospero::GpuEnumValue(Prospero::StencilOp::kReplaceOp) ||
+	       depth_fail == Prospero::GpuEnumValue(Prospero::StencilOp::kReplaceOp);
 }
 
-[[nodiscard]] static vk::Format ResolveHostDepthAttachmentFormat(const CommandBuffer&     buffer,
-                                                                 const DepthFormatPolicy& policy,
+[[nodiscard]] static vk::Format ResolveHostDepthAttachmentFormat(const RenderCommandBuffer& buffer,
+                                                                 const DepthFormatPolicy&   policy,
                                                                  bool     has_stencil,
                                                                  uint32_t samples) {
 	auto&      graphics         = buffer.GetGraphics();
@@ -97,21 +86,19 @@ static bool UsesStencilOpValue(uint8_t fail, uint8_t pass, uint8_t depth_fail) {
 }
 
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
-void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer& buffer,
+void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer,
                                               RenderDepthInfo& r) {
 	KYTY_PROFILER_FUNCTION();
 	(void)submit_id;
-	const auto& hw          = buffer.GetRegisters();
-	const auto& z           = hw.GetDepthRenderTarget();
-	const auto& rc          = hw.GetRenderControl();
-	const auto& dc          = hw.GetDepthControl();
-	const auto& sc          = hw.GetStencilControl();
-	const auto& sm          = hw.GetStencilMask();
-	const bool  has_stencil = z.stencil_info.format != Prospero::StencilFormat::kInvalid;
-	const bool depth_active = dc.z_enable || dc.z_write_enable || dc.depth_bounds_enable ||
-	                          rc.depth_clear_enable || rc.copy_depth_to_color;
-	const bool stencil_active =
-	    has_stencil && (dc.stencil_enable || rc.stencil_clear_enable || rc.copy_stencil_to_color);
+	const auto& hw = buffer.GetRegisters();
+	const auto& z  = hw.GetDepthRenderTarget();
+	const auto& rc = hw.GetRenderControl();
+	const auto& dc = hw.GetDepthControl();
+	const auto& sc = hw.GetStencilControl();
+	const auto& sm = hw.GetStencilMask();
+	const bool  depth_active =
+	    dc.z_enable || dc.z_write_enable || dc.depth_bounds_enable || rc.depth_clear_enable;
+	const bool stencil_active = dc.stencil_enable || rc.stencil_clear_enable;
 	if (!depth_active && !stencil_active) {
 		return;
 	}
@@ -120,22 +107,31 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer&
 		DepthFatal("invalid PS5 depth texture-compatibility encoding");
 	}
 	const bool attachment_unbound =
-	    z.z_info.format == Prospero::DepthFormat::kInvalid &&
-	    z.stencil_info.format == Prospero::StencilFormat::kInvalid && z.z_info.num_samples == 0 &&
+	    z.z_info.format == Prospero::GpuEnumValue(Prospero::DepthFormat::kInvalid) &&
+	    z.stencil_info.format == Prospero::GpuEnumValue(Prospero::StencilFormat::kInvalid) &&
+	    z.z_info.num_samples == 0 &&
 	    z.z_info.texture_compatibility == Prospero::TextureCompatiblePlaneCompression::kDisable &&
 	    !z.z_info.expclear_enabled && !z.z_info.partially_resident && z.z_info.max_mip_level == 0 &&
 	    z.stencil_info.texture_compatibility == Prospero::TextureCompatibleStencil::kDisable &&
 	    !z.stencil_info.expclear_enabled && !z.stencil_info.partially_resident &&
 	    z.depth_view.slice_start == 0 && z.depth_view.slice_max == 0 &&
 	    z.depth_view.current_mip_level == 0 && !z.depth_view.depth_write_disable &&
-	    !z.depth_view.stencil_write_disable && z.z_read_base_addr == 0 && z.z_write_base_addr == 0 &&
-	    z.stencil_read_base_addr == 0 && z.stencil_write_base_addr == 0 &&
-	    z.htile_data_base_addr == 0 &&
+	    !z.depth_view.stencil_write_disable && z.depth_info.addr5_swizzle_mask == 0 &&
+	    z.depth_info.array_mode == 0 && z.depth_info.pipe_config == 0 &&
+	    z.depth_info.bank_width == 0 && z.depth_info.bank_height == 0 &&
+	    z.depth_info.macro_tile_aspect == 0 && z.depth_info.num_banks == 0 &&
+	    z.htile_surface.linear == 0 && z.htile_surface.full_cache == 0 &&
+	    z.htile_surface.htile_uses_preload_win == 0 && z.htile_surface.preload == 0 &&
+	    z.htile_surface.prefetch_width == 0 && z.htile_surface.prefetch_height == 0 &&
+	    z.htile_surface.dst_outside_zero_to_one == 0 && z.z_read_base_addr == 0 &&
+	    z.z_write_base_addr == 0 && z.stencil_read_base_addr == 0 &&
+	    z.stencil_write_base_addr == 0 && z.htile_data_base_addr == 0 &&
 	    // DB_DEPTH_SIZE_XY is independent state and may remain programmed after the attachment
 	    // formats and addresses are unbound. A zero encoding is the valid 1x1 value, so its
 	    // presence alone must not manufacture a depth attachment.
-	    !z.z_info.htile_acceleration && z.shading_rate_encoding == 0 && z.size.x_max == 0 &&
-	    z.size.y_max == 0;
+	    !z.z_info.htile_acceleration && !z.width_height_valid && !z.pitch_height_valid &&
+	    z.size.x_max == 0 && z.size.y_max == 0 && z.pitch_div8_minus1 == 0 &&
+	    z.height_div8_minus1 == 0 && z.slice_div64_minus1 == 0 && z.width == 0 && z.height == 0;
 	if (attachment_unbound) {
 		static std::atomic_bool logged = false;
 		if (!logged.exchange(true, std::memory_order_relaxed)) {
@@ -143,6 +139,8 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer&
 		}
 		return;
 	}
+	const bool has_stencil =
+	    z.stencil_info.format != Prospero::GpuEnumValue(Prospero::StencilFormat::kInvalid);
 	const bool has_htile = z.z_info.htile_acceleration;
 	const auto samples   = render_sample_count(z.z_info.num_samples);
 	if (samples == 0) {
@@ -158,26 +156,33 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer&
 			DepthFatal("invalid depth view: base=%u last=%u", z.depth_view.slice_start,
 			           z.depth_view.slice_max);
 	}
-	if (rc.copy_depth_to_color || rc.copy_stencil_to_color || rc.copy_centroid ||
-	    rc.copy_sample != 0 || z.z_info.expclear_enabled ||
-	    z.stencil_info.expclear_enabled || z.z_info.partially_resident ||
-	    z.stencil_info.partially_resident || z.z_info.max_mip_level != 0 ||
-	    z.depth_view.current_mip_level != 0 || z.shading_rate_encoding != 0 ||
-	    z.z_read_base_addr == 0 ||
-	    (!z.depth_view.depth_write_disable && z.z_write_base_addr != z.z_read_base_addr) ||
+	if ((stencil_active && !has_stencil) || rc.resummarize_enable || rc.copy_centroid ||
+	    rc.copy_sample != 0 || z.z_info.expclear_enabled || z.stencil_info.expclear_enabled ||
+	    z.z_info.partially_resident || z.stencil_info.partially_resident ||
+	    z.z_info.max_mip_level != 0 || z.depth_view.current_mip_level != 0 ||
+	    z.depth_info.addr5_swizzle_mask != 0 || z.depth_info.array_mode != 0 ||
+	    z.depth_info.pipe_config != 0 || z.depth_info.bank_width != 0 ||
+	    z.depth_info.bank_height != 0 || z.depth_info.macro_tile_aspect != 0 ||
+	    z.depth_info.num_banks != 0 || z.htile_surface.linear != 0 ||
+	    z.htile_surface.full_cache != 0 || z.htile_surface.htile_uses_preload_win != 0 ||
+	    z.htile_surface.preload != 0 || z.htile_surface.prefetch_width != 0 ||
+	    z.htile_surface.prefetch_height != 0 || z.htile_surface.dst_outside_zero_to_one != 0 ||
+	    z.z_read_base_addr == 0 || z.z_write_base_addr != z.z_read_base_addr ||
 	    (z.z_read_base_addr & 0xffffu) != 0 ||
 	    dc.zfunc > static_cast<uint8_t>(vk::CompareOp::eAlways)) {
 		DepthFatal("unsupported depth register state");
 	}
 	if (has_stencil) {
-		if (z.stencil_info.format != Prospero::StencilFormat::k8UInt || !htile_stencil_compat ||
-		    z.stencil_read_base_addr == 0 ||
-		    (!z.depth_view.stencil_write_disable &&
-		     z.stencil_write_base_addr != z.stencil_read_base_addr) ||
-		    (z.stencil_read_base_addr & 0xffffu) != 0) {
+		if (z.stencil_info.format != Prospero::GpuEnumValue(Prospero::StencilFormat::k8UInt) ||
+		    !htile_stencil_compat || z.stencil_read_base_addr == 0 ||
+		    z.stencil_write_base_addr != z.stencil_read_base_addr ||
+		    (z.stencil_read_base_addr & 0xffffu) != 0 || z.depth_view.stencil_write_disable) {
 			DepthFatal("unsupported stencil attachment state");
 		}
-	} else if (z.stencil_read_base_addr != 0 || z.stencil_write_base_addr != 0) {
+	} else if (z.stencil_read_base_addr != 0 || z.stencil_write_base_addr != 0 ||
+	           !htile_stencil_compat ||
+	           z.stencil_info.texture_compatibility !=
+	               Prospero::TextureCompatibleStencil::kDisable) {
 		DepthFatal("stencil state without an active stencil attachment");
 	}
 	if (has_htile) {
@@ -187,14 +192,21 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer&
 		if (z.depth_view.slice_max >= 32) {
 			DepthFatal("HTile clear tracking supports at most 32 slices");
 		}
+	} else if (z.htile_data_base_addr != 0) {
+		DepthFatal("HTile address without an enabled tile surface");
 	}
-	if (!z.size.valid) {
+	const bool size_xy_valid = z.size.valid;
+	const bool wh_valid      = z.width_height_valid && z.width != 0 && z.height != 0;
+	if (!size_xy_valid && !wh_valid) {
 		DepthFatal("missing depth extent");
 	}
-	const uint32_t width  = static_cast<uint32_t>(z.size.x_max) + 1u;
-	const uint32_t height = static_cast<uint32_t>(z.size.y_max) + 1u;
-	if (width > 16384 || height > 16384) {
-		DepthFatal("invalid depth extent");
+	const uint32_t width  = size_xy_valid ? static_cast<uint32_t>(z.size.x_max) + 1u : z.width;
+	const uint32_t height = size_xy_valid ? static_cast<uint32_t>(z.size.y_max) + 1u : z.height;
+	if (width > 16384 || height > 16384 ||
+	    (size_xy_valid && wh_valid && (width != z.width || height != z.height)) ||
+	    (!z.pitch_height_valid &&
+	     (z.pitch_div8_minus1 != 0 || z.height_div8_minus1 != 0 || z.slice_div64_minus1 != 0))) {
+		DepthFatal("inconsistent depth extent or encoded layout");
 	}
 	const auto* policy = FindDepthFormatPolicy(z.z_info.format);
 	if (policy == nullptr) {
@@ -206,9 +218,14 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer&
 		DepthFatal("no host depth/stencil format supports required usage for %s",
 		           VulkanToString(ideal_format).c_str());
 	}
-	const auto     guest_format = policy->guest_format;
+	const uint32_t guest_format = Prospero::GpuEnumValue(policy->guest_format);
 	const uint32_t bytes        = policy->bytes_per_element;
 	const auto     pitch        = TileGetDepthPitch(width, bytes, z.z_info.num_samples);
+	if (z.pitch_height_valid && ((static_cast<uint64_t>(z.pitch_div8_minus1) + 1u) * 8u != pitch ||
+	                             (static_cast<uint64_t>(z.height_div8_minus1) + 1u) * 8u !=
+	                                 ((static_cast<uint64_t>(height) + 7u) & ~7ull))) {
+		DepthFatal("encoded depth pitch or height mismatch");
+	}
 	TileSizeAlign depth_size {};
 	TileSizeAlign stencil_size {};
 	TileSizeAlign htile_size {};
@@ -219,6 +236,14 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer&
 	    (has_htile != (htile_size.align == 32768 && htile_size.size != 0))) {
 		DepthFatal("unsupported depth/stencil/HTile footprint");
 	}
+	if (z.pitch_height_valid &&
+	    (static_cast<uint64_t>(z.slice_div64_minus1) + 1u) * 64u != depth_size.size) {
+		DepthFatal("depth footprint mismatch: extent=%ux%u pitch=%u expected=0x%016" PRIx64
+		           " align=0x%016" PRIx64 " encoded_valid=%u encoded=0x%016" PRIx64,
+		           width, height, pitch, depth_size.size, depth_size.align,
+		           z.pitch_height_valid ? 1u : 0u,
+		           (static_cast<uint64_t>(z.slice_div64_minus1) + 1u) * 64u);
+	}
 	if (depth_size.size > UINT64_MAX / view.image_layers ||
 	    stencil_size.size > UINT64_MAX / view.image_layers ||
 	    htile_size.size > UINT64_MAX / view.image_layers) {
@@ -227,9 +252,9 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer&
 	const auto depth_backing_size   = depth_size.size * view.image_layers;
 	const auto stencil_backing_size = stencil_size.size * view.image_layers;
 	const auto htile_backing_size   = htile_size.size * view.image_layers;
-	if (!GuestRange {z.z_read_base_addr, depth_backing_size}.Valid() ||
-	    (has_stencil && !GuestRange {z.stencil_read_base_addr, stencil_backing_size}.Valid()) ||
-	    (has_htile && !GuestRange {z.htile_data_base_addr, htile_backing_size}.Valid())) {
+	if (depth_backing_size > TRACKER_ADDRESS_SIZE - z.z_read_base_addr ||
+	    (has_stencil && stencil_backing_size > TRACKER_ADDRESS_SIZE - z.stencil_read_base_addr) ||
+	    (has_htile && htile_backing_size > TRACKER_ADDRESS_SIZE - z.htile_data_base_addr)) {
 		DepthFatal("layered depth backing range is invalid");
 	}
 	r.htile                   = has_htile;
@@ -254,39 +279,34 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer&
 	r.depth_min_bounds         = hw.GetDepthBoundsMin();
 	r.depth_max_bounds         = hw.GetDepthBoundsMax();
 
-	r.stencil_clear_enable =
-	    has_stencil && rc.stencil_clear_enable && !z.depth_view.stencil_write_disable;
-	r.stencil_clear_value = hw.GetStencilClearValue();
-	r.stencil_test_enable = has_stencil && dc.stencil_enable;
-	if (r.stencil_test_enable) {
-		const bool stencil_ops_disabled =
-		    rc.stencil_clear_enable || z.depth_view.stencil_write_disable;
-		const uint8_t front_write_mask = stencil_ops_disabled ? 0 : sm.stencil_writemask;
-		const uint8_t back_write_mask  = stencil_ops_disabled ? 0 : sm.stencil_writemask_bf;
+	r.stencil_clear_enable = rc.stencil_clear_enable;
+	r.stencil_clear_value  = hw.GetStencilClearValue();
+	r.stencil_test_enable  = dc.stencil_enable;
+	if (dc.stencil_enable) {
 		if (dc.stencilfunc > static_cast<uint8_t>(vk::CompareOp::eAlways) ||
 		    (dc.backface_enable &&
 		     dc.stencilfunc_bf > static_cast<uint8_t>(vk::CompareOp::eAlways)) ||
-		    (front_write_mask != 0 &&
-		     UsesStencilOpValue(sc.stencil_fail, sc.stencil_zpass, sc.stencil_zfail) &&
+		    (UsesStencilOpValue(sc.stencil_fail, sc.stencil_zpass, sc.stencil_zfail) &&
 		     sm.stencil_opval != sm.stencil_testval) ||
-		    (dc.backface_enable && back_write_mask != 0 &&
+		    (dc.backface_enable &&
 		     UsesStencilOpValue(sc.stencil_fail_bf, sc.stencil_zpass_bf, sc.stencil_zfail_bf) &&
 		     sm.stencil_opval_bf != sm.stencil_testval_bf)) {
 			DepthFatal("unsupported stencil compare or replacement state");
 		}
 		r.stencil_static_front = {
-		    ConvertStencilOp(sc.stencil_fail, front_write_mask, sm.stencil_opval),
-		    ConvertStencilOp(sc.stencil_zpass, front_write_mask, sm.stencil_opval),
-		    ConvertStencilOp(sc.stencil_zfail, front_write_mask, sm.stencil_opval),
-		    static_cast<vk::CompareOp>(dc.stencilfunc)};
-		r.stencil_dynamic_front = {sm.stencil_mask, front_write_mask, sm.stencil_testval};
+		    ConvertStencilOp(sc.stencil_fail), ConvertStencilOp(sc.stencil_zpass),
+		    ConvertStencilOp(sc.stencil_zfail), static_cast<vk::CompareOp>(dc.stencilfunc)};
+		r.stencil_dynamic_front = {sm.stencil_mask,
+		                           rc.stencil_clear_enable ? 0u : sm.stencil_writemask,
+		                           sm.stencil_testval};
 		if (dc.backface_enable) {
-			r.stencil_static_back = {
-			    ConvertStencilOp(sc.stencil_fail_bf, back_write_mask, sm.stencil_opval_bf),
-			    ConvertStencilOp(sc.stencil_zpass_bf, back_write_mask, sm.stencil_opval_bf),
-			    ConvertStencilOp(sc.stencil_zfail_bf, back_write_mask, sm.stencil_opval_bf),
-			    static_cast<vk::CompareOp>(dc.stencilfunc_bf)};
-			r.stencil_dynamic_back = {sm.stencil_mask_bf, back_write_mask, sm.stencil_testval_bf};
+			r.stencil_static_back  = {ConvertStencilOp(sc.stencil_fail_bf),
+			                          ConvertStencilOp(sc.stencil_zpass_bf),
+			                          ConvertStencilOp(sc.stencil_zfail_bf),
+			                          static_cast<vk::CompareOp>(dc.stencilfunc_bf)};
+			r.stencil_dynamic_back = {sm.stencil_mask_bf,
+			                          rc.stencil_clear_enable ? 0u : sm.stencil_writemask_bf,
+			                          sm.stencil_testval_bf};
 		} else {
 			r.stencil_static_back  = r.stencil_static_front;
 			r.stencil_dynamic_back = r.stencil_dynamic_front;
@@ -311,7 +331,7 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, CommandBuffer&
 	desc.info.pitch           = pitch;
 	desc.info.bytes_per_block = bytes;
 	desc.info.samples         = samples;
-	desc.info.tile_mode       = Prospero::TileMode::kDepth;
+	desc.info.tile_mode       = Prospero::GpuEnumValue(Prospero::TileMode::kDepth);
 	desc.info.mip_layout[0]   = {0, r.depth_buffer_size, pitch, height};
 	desc.info.metadata.range  = {r.htile_buffer_vaddr, r.htile_buffer_size};
 	desc.info.metadata.kind   = has_htile ? ImageMetadataKind::Htile : ImageMetadataKind::None;

src/graphics/host_gpu/renderer/depthRenderTarget.h

@@ -11,11 +11,11 @@
 
 namespace Libs::Graphics {
 
-// Without a stencil plane, Hi-Stencil fields are inactive. An active plane is compatible when
-// Hi-Stencil is disabled or HTile backing is present.
+class RenderCommandBuffer;
+
 inline constexpr bool depth_htile_stencil_acceleration_compatible(bool has_stencil, bool has_htile,
                                                                   bool htile_stencil_disabled) {
-	return !has_stencil || htile_stencil_disabled || has_htile;
+	return htile_stencil_disabled || (has_stencil && has_htile);
 }
 
 struct RenderDepthInfo {

src/graphics/host_gpu/renderer/image/image.cpp

@@ -59,14 +59,24 @@ namespace {
 	if (HasFormatFeature(properties, vk::FormatFeatureFlagBits::eColorAttachment)) {
 		usage |= vk::ImageUsageFlagBits::eColorAttachment;
 	}
-	if (info.samples == 1) {
+	if (info.samples == 1 &&
+	    HasFormatFeature(properties, vk::FormatFeatureFlagBits::eStorageImage)) {
 		usage |= vk::ImageUsageFlagBits::eStorage;
+	} else if (info.samples == 1) {
+		const auto compatible = SrgbStorageViewFormat(info.pixel_format);
+		if (compatible != vk::Format::eUndefined &&
+		    HasFormatFeature(graphics.GetFormatProperties(compatible),
+		                     vk::FormatFeatureFlagBits::eStorageImage)) {
+			usage |= vk::ImageUsageFlagBits::eStorage;
+		}
 	}
 	return usage;
 }
 
-void ValidateOptionalRange(GuestRange range, const char* name) {
-	if (!range.ValidOrEmpty()) {
+void ValidateRange(GuestRange range, const char* name) {
+	if ((range.address == 0) != (range.size == 0) ||
+	    (range.address != 0 && (range.address >= TRACKER_ADDRESS_SIZE ||
+	                            range.size > TRACKER_ADDRESS_SIZE - range.address))) {
 		EXIT("invalid %s image range: address=0x%016llx size=0x%016llx\n", name,
 		     static_cast<unsigned long long>(range.address),
 		     static_cast<unsigned long long>(range.size));
@@ -95,10 +105,6 @@ Image::Barriers Image::GetBarriers(vk::ImageLayout                      destinat
                                    std::optional<ImageSubresourceRange> range) {
 	auto& state              = backing.state;
 	auto& subresource_states = backing.subresource_states;
-	if (range && info.IsVolume()) {
-		range->base_layer  = 0;
-		range->layer_count = 1;
-	}
 
 	const bool partial =
 	    range && (range->base_level != 0 || range->level_count != info.resources.levels ||
@@ -557,13 +563,13 @@ void Image::CopyMip(Image& source, uint32_t mip, uint32_t layer) {
 namespace ImageOps {
 
 void Validate(const ImageInfo& info) {
-	ValidateOptionalRange(info.data, "data");
-	ValidateOptionalRange(info.stencil, "stencil");
+	ValidateRange(info.data, "data");
+	ValidateRange(info.stencil, "stencil");
 
 	if (info.pixel_format == vk::Format::eUndefined) {
 		const bool metadata_empty =
-		    info.metadata.range.Empty() && info.metadata.kind == ImageMetadataKind::None &&
-		    info.metadata.control == 0 &&
+		    info.metadata.range.address == 0 && info.metadata.range.size == 0 &&
+		    info.metadata.kind == ImageMetadataKind::None && info.metadata.control == 0 &&
 		    info.metadata.compression == VideoOutCompression::Uncompressed &&
 		    !info.metadata.stencil_compressed;
 		if (info.data.Empty() || info.HasStencil() || !metadata_empty || info.extent.width == 0 ||
@@ -610,14 +616,16 @@ void Validate(const ImageInfo& info) {
 	}
 	switch (info.metadata.kind) {
 		case ImageMetadataKind::None:
-			if (!info.metadata.range.Empty() || info.metadata.control != 0 ||
+			if (info.metadata.range.address != 0 || info.metadata.range.size != 0 ||
+			    info.metadata.control != 0 ||
 			    info.metadata.compression != VideoOutCompression::Uncompressed ||
 			    info.metadata.stencil_compressed) {
 				EXIT("metadata-free image has metadata state\n");
 			}
 			break;
 		case ImageMetadataKind::Htile:
-			if (!info.metadata.range.Valid() ||
+			ValidateRange(info.metadata.range, "HTILE");
+			if (info.metadata.range.Empty() ||
 			    info.metadata.compression != VideoOutCompression::Uncompressed) {
 				EXIT("invalid HTILE metadata\n");
 			}
@@ -634,13 +642,13 @@ void Validate(const ImageInfo& info) {
 	}
 }
 
-Prospero::BufferFormat RenderTargetTransferFormat(uint32_t bytes_per_element) {
+uint32_t RenderTargetTransferFormat(uint32_t bytes_per_element) {
 	switch (bytes_per_element) {
-		case 1: return Prospero::BufferFormat::k8UNorm;
-		case 2: return Prospero::BufferFormat::k16UNorm;
-		case 4: return Prospero::BufferFormat::k32Float;
-		case 8: return Prospero::BufferFormat::k16_16_16_16Float;
-		case 16: return Prospero::BufferFormat::k32_32_32_32Float;
+		case 1: return Prospero::GpuEnumValue(Prospero::BufferFormat::k8UNorm);
+		case 2: return Prospero::GpuEnumValue(Prospero::BufferFormat::k16UNorm);
+		case 4: return Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float);
+		case 8: return Prospero::GpuEnumValue(Prospero::BufferFormat::k16_16_16_16Float);
+		case 16: return Prospero::GpuEnumValue(Prospero::BufferFormat::k32_32_32_32Float);
 		default: EXIT("unsupported render-target element size: %u\n", bytes_per_element);
 	}
 }
@@ -651,8 +659,7 @@ Image::Image(GraphicContext& graphics, CommandScheduler& scheduler, const ImageI
     : info(image_info), m_graphics(&graphics), m_scheduler(&scheduler) {
 	KYTY_PROFILER_FUNCTION();
 	ImageOps::Validate(info);
-	m_cpu_dirty =
-	    !info.data.Empty() && info.metadata.compression == VideoOutCompression::Uncompressed;
+	m_cpu_dirty = !info.data.Empty();
 	if (info.pixel_format == vk::Format::eUndefined) {
 		return;
 	}
@@ -724,10 +731,15 @@ Image::~Image() {
 	if (m_graphics == nullptr) {
 		return;
 	}
-	for (const auto& cached: views) {
-		if (cached.view != nullptr) {
-			m_graphics->device.destroyImageView(cached.view, nullptr);
+	{
+		std::lock_guard lock(views.mutex);
+		for (auto& cached: views.views) {
+			if (cached.view != nullptr) {
+				m_graphics->device.destroyImageView(cached.view, nullptr);
+				cached.view = nullptr;
+			}
 		}
+		views.views.clear();
 	}
 	if (backing.image != nullptr) {
 		m_graphics->DeleteImage(backing);

src/graphics/host_gpu/renderer/image/image.h

@@ -2,12 +2,12 @@
 #define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_IMAGE_H_
 
 #include "common/assert.h"
-#include "common/slotVector.h"
 #include "graphics/host_gpu/graphicContext.h"
 #include "graphics/host_gpu/renderer/image/imageInfo.h"
 
 #include <compare>
 #include <limits>
+#include <mutex>
 #include <optional>
 #include <span>
 #include <utility>
@@ -19,13 +19,29 @@ class Buffer;
 class CommandScheduler;
 struct ImageTestAccess;
 
-using ImageId = Common::SlotId;
+struct ImageId {
+	uint32_t index      = std::numeric_limits<uint32_t>::max();
+	uint32_t generation = 0;
+
+	[[nodiscard]] explicit operator bool() const noexcept {
+		return index != std::numeric_limits<uint32_t>::max();
+	}
+	auto operator<=>(const ImageId&) const = default;
+};
 
 struct CachedImageView {
 	ImageViewInfo info;
 	vk::ImageView view = nullptr;
 };
 
+struct ImageViewCache {
+	ImageViewCache() = default;
+	KYTY_CLASS_NO_COPY(ImageViewCache);
+
+	std::mutex                   mutex;
+	std::vector<CachedImageView> views;
+};
+
 struct ImageUsage {
 	bool texture       = false;
 	bool storage       = false;
@@ -39,7 +55,6 @@ struct ImageBinding {
 	bool is_target     = false;
 	bool needs_rebind  = false;
 	bool force_general = false;
-	bool shader_write  = false;
 };
 
 class Image final {
@@ -139,18 +154,17 @@ public:
 	}
 	[[nodiscard]] uint64_t HashGuestEdges() const;
 
-	ImageInfo        info;
-	VulkanImage      backing;
-	std::vector<CachedImageView> views;
-	ImageUsage       usage;
-	ImageBinding     binding;
-	bool             registered     = false;
-	mutable uint32_t query_epoch    = 0;
-	uint64_t         track_addr     = 0;
-	uint64_t         track_addr_end = 0;
-	ImageId          depth_id {};
-	uint64_t         tick_accessed_last = 0;
-	size_t           lru_id             = 0;
+	ImageInfo      info;
+	VulkanImage    backing;
+	ImageViewCache views;
+	ImageUsage     usage;
+	ImageBinding   binding;
+	bool           registered     = false;
+	uint64_t       track_addr     = 0;
+	uint64_t       track_addr_end = 0;
+	ImageId        depth_id {};
+	uint64_t       tick_accessed_last = 0;
+	size_t         lru_id             = 0;
 
 private:
 	friend struct ImageTestAccess;
@@ -173,8 +187,8 @@ private:
 
 namespace ImageOps {
 
-void                                 Validate(const ImageInfo& info);
-[[nodiscard]] Prospero::BufferFormat RenderTargetTransferFormat(uint32_t bytes_per_element);
+void                   Validate(const ImageInfo& info);
+[[nodiscard]] uint32_t RenderTargetTransferFormat(uint32_t bytes_per_element);
 
 } // namespace ImageOps
 

src/graphics/host_gpu/renderer/image/imageInfo.h

@@ -15,6 +15,18 @@
 
 namespace Libs::Graphics {
 
+struct GuestRange {
+	uint64_t address = 0;
+	uint64_t size    = 0;
+
+	[[nodiscard]] constexpr bool Empty() const noexcept { return address == 0 || size == 0; }
+	[[nodiscard]] constexpr bool Valid() const noexcept {
+		return !Empty() && address < TRACKER_ADDRESS_SIZE && size <= TRACKER_ADDRESS_SIZE - address;
+	}
+	[[nodiscard]] constexpr uint64_t End() const noexcept { return address + size; }
+	auto                             operator<=>(const GuestRange&) const = default;
+};
+
 enum class VideoOutCompression : uint8_t { Uncompressed, Dcc256_256_0, Dcc256_64_64, Unsupported };
 
 enum class ImageMetadataKind : uint8_t { None, Htile, Dcc };
@@ -55,14 +67,14 @@ struct ImageInfo {
 	ImageMetadataInfo            metadata;
 	uint32_t                     htile_clear_mask = UINT32_MAX;
 	vk::Format                   pixel_format     = vk::Format::eUndefined;
-	Prospero::BufferFormat       guest_format     = Prospero::BufferFormat::kInvalid;
+	uint32_t                     guest_format     = 0;
 	Prospero::ImageType          type             = Prospero::ImageType::kColor2D;
 	vk::Extent3D                 extent           = {1, 1, 1};
 	ImageSubresources            resources;
 	uint32_t                     pitch           = 0;
 	uint32_t                     bytes_per_block = 0;
 	uint32_t                     samples         = 1;
-	Prospero::TileMode           tile_mode       = Prospero::TileMode::kLinear;
+	uint32_t                     tile_mode       = 0;
 	bool                         bgra16          = false;
 	std::array<ImageMipInfo, 16> mip_layout {};
 
@@ -74,7 +86,9 @@ struct ImageInfo {
 	[[nodiscard]] bool IsBlock() const noexcept {
 		return Prospero::BlockCompressedBytesPerBlock(guest_format) != 0;
 	}
-	[[nodiscard]] bool IsTiled() const noexcept { return tile_mode != Prospero::TileMode::kLinear; }
+	[[nodiscard]] bool IsTiled() const noexcept {
+		return tile_mode != Prospero::GpuEnumValue(Prospero::TileMode::kLinear);
+	}
 	[[nodiscard]] constexpr bool IsVolume() const noexcept {
 		return type == Prospero::ImageType::kColor3D;
 	}
@@ -200,6 +214,7 @@ struct DepthFormatPolicy {
 	Prospero::DepthFormat     depth_format;
 	Prospero::BufferFormat    guest_format;
 	uint32_t                  bytes_per_element;
+	vk::Format                sampled_view_format;
 	vk::Format                depth_attachment_format;
 	std::array<vk::Format, 3> stencil_attachment_formats;
 };
@@ -208,19 +223,21 @@ inline constexpr std::array<DepthFormatPolicy, 2> DEPTH_FORMAT_POLICIES {{
     {Prospero::DepthFormat::kZ16,
      Prospero::BufferFormat::k16UNorm,
      2,
+     vk::Format::eR16Unorm,
      vk::Format::eD16Unorm,
      {vk::Format::eD16UnormS8Uint, vk::Format::eD24UnormS8Uint, vk::Format::eD32SfloatS8Uint}},
     {Prospero::DepthFormat::kZ32F,
      Prospero::BufferFormat::k32Float,
      4,
+     vk::Format::eR32Sfloat,
      vk::Format::eD32Sfloat,
      {vk::Format::eD32SfloatS8Uint, vk::Format::eUndefined, vk::Format::eUndefined}},
 }};
 
 [[nodiscard]] inline constexpr const DepthFormatPolicy*
-FindDepthFormatPolicy(Prospero::DepthFormat depth_format) noexcept {
+FindDepthFormatPolicy(uint32_t depth_format) noexcept {
 	for (const auto& policy: DEPTH_FORMAT_POLICIES) {
-		if (policy.depth_format == depth_format) {
+		if (Prospero::GpuEnumValue(policy.depth_format) == depth_format) {
 			return &policy;
 		}
 	}
@@ -228,9 +245,9 @@ FindDepthFormatPolicy(Prospero::DepthFormat depth_format) noexcept {
 }
 
 [[nodiscard]] inline constexpr const DepthFormatPolicy*
-FindGuestDepthFormatPolicy(Prospero::BufferFormat guest_format) noexcept {
+FindGuestDepthFormatPolicy(uint32_t guest_format) noexcept {
 	for (const auto& policy: DEPTH_FORMAT_POLICIES) {
-		if (policy.guest_format == guest_format) {
+		if (Prospero::GpuEnumValue(policy.guest_format) == guest_format) {
 			return &policy;
 		}
 	}
@@ -252,11 +269,10 @@ FindGuestDepthFormatPolicy(Prospero::BufferFormat guest_format) noexcept {
 	return has_stencil ? policy.stencil_attachment_formats.front() : policy.depth_attachment_format;
 }
 
-[[nodiscard]] inline constexpr vk::Format
-DepthAttachmentFormat(Prospero::DepthFormat   depth_format,
-                      Prospero::StencilFormat stencil_format) noexcept {
+[[nodiscard]] inline constexpr vk::Format DepthAttachmentFormat(uint32_t depth_format,
+                                                                uint32_t stencil_format) noexcept {
 	bool has_stencil = false;
-	switch (stencil_format) {
+	switch (static_cast<Prospero::StencilFormat>(stencil_format)) {
 		case Prospero::StencilFormat::kInvalid: break;
 		case Prospero::StencilFormat::k8UInt: has_stencil = true; break;
 		default: return vk::Format::eUndefined;
@@ -302,6 +318,26 @@ inline bool ImageInfo::IsDepth() const noexcept {
 	return std::bit_cast<uint32_t>(static_cast<float>(value) / 65535.0f);
 }
 
+[[nodiscard]] inline constexpr bool IsSupportedSampledDepthFormat(vk::Format image_format,
+                                                                  uint32_t   guest_format,
+                                                                  vk::Format view_format) noexcept {
+	const auto* policy = FindGuestDepthFormatPolicy(guest_format);
+	return policy != nullptr && view_format == policy->sampled_view_format &&
+	       (image_format == policy->depth_attachment_format ||
+	        IsStencilAttachmentFormat(*policy, image_format));
+}
+
+[[nodiscard]] inline constexpr bool IsSupportedSampledDepthFormat(vk::Format image_format,
+                                                                  vk::Format view_format) noexcept {
+	for (const auto& policy: DEPTH_FORMAT_POLICIES) {
+		if (IsSupportedSampledDepthFormat(image_format, Prospero::GpuEnumValue(policy.guest_format),
+		                                  view_format)) {
+			return true;
+		}
+	}
+	return false;
+}
+
 [[nodiscard]] inline constexpr bool IsSupportedDepthTargetFormat(const ImageInfo& info) {
 	const auto* policy = FindGuestDepthFormatPolicy(info.guest_format);
 	return policy != nullptr && info.bytes_per_block == policy->bytes_per_element &&
@@ -347,10 +383,10 @@ CanUseVideoOutNativeWithoutUpload(VideoOutCompression compression, bool render_t
 }
 
 struct VideoOutPixelFormatInfo {
-	vk::Format             format            = vk::Format::eUndefined;
-	Prospero::BufferFormat guest_format      = Prospero::BufferFormat::kInvalid;
-	uint32_t               bytes_per_element = 0;
-	bool                   bgra16            = false;
+	vk::Format format            = vk::Format::eUndefined;
+	uint32_t   guest_format      = 0;
+	uint32_t   bytes_per_element = 0;
+	bool       bgra16            = false;
 };
 
 struct VideoOutFormatPolicy {
@@ -360,17 +396,23 @@ struct VideoOutFormatPolicy {
 
 inline constexpr std::array<VideoOutFormatPolicy, 6> VIDEO_OUT_FORMAT_POLICIES {{
     {0x8000000022000000ull,
-     {vk::Format::eR8G8B8A8Srgb, Prospero::BufferFormat::k8_8_8_8Srgb, 4, false}},
+     {vk::Format::eR8G8B8A8Srgb, Prospero::GpuEnumValue(Prospero::BufferFormat::k8_8_8_8Srgb), 4,
+      false}},
     {0x8000000000000000ull,
-     {vk::Format::eB8G8R8A8Srgb, Prospero::BufferFormat::k8_8_8_8Srgb, 4, false}},
+     {vk::Format::eB8G8R8A8Srgb, Prospero::GpuEnumValue(Prospero::BufferFormat::k8_8_8_8Srgb), 4,
+      false}},
     {0x8100000022000000ull,
-     {vk::Format::eA2B10G10R10UnormPack32, Prospero::BufferFormat::k10_10_10_2UNorm, 4, false}},
+     {vk::Format::eA2B10G10R10UnormPack32,
+      Prospero::GpuEnumValue(Prospero::BufferFormat::k10_10_10_2UNorm), 4, false}},
     {0x8100000000000000ull,
-     {vk::Format::eA2R10G10B10UnormPack32, Prospero::BufferFormat::k10_10_10_2UNorm, 4, false}},
+     {vk::Format::eA2R10G10B10UnormPack32,
+      Prospero::GpuEnumValue(Prospero::BufferFormat::k10_10_10_2UNorm), 4, false}},
     {0xc001000622000000ull,
-     {vk::Format::eR16G16B16A16Sfloat, Prospero::BufferFormat::k16_16_16_16Float, 8, false}},
+     {vk::Format::eR16G16B16A16Sfloat,
+      Prospero::GpuEnumValue(Prospero::BufferFormat::k16_16_16_16Float), 8, false}},
     {0xc001000600000000ull,
-     {vk::Format::eR16G16B16A16Sfloat, Prospero::BufferFormat::k16_16_16_16Float, 8, true}},
+     {vk::Format::eR16G16B16A16Sfloat,
+      Prospero::GpuEnumValue(Prospero::BufferFormat::k16_16_16_16Float), 8, true}},
 }};
 
 [[nodiscard]] inline bool DecodeVideoOutPixelFormat(uint64_t                 pixel_format,
@@ -397,15 +439,15 @@ inline constexpr std::array<VideoOutFormatPolicy, 6> VIDEO_OUT_FORMAT_POLICIES {
 }
 
 [[nodiscard]] inline constexpr bool
-IsSupportedDisplayRenderTargetTileMode(Prospero::TileMode tile_mode) noexcept {
-	return tile_mode == Prospero::TileMode::kRenderTarget;
+IsSupportedDisplayRenderTargetTileMode(uint32_t tile_mode) noexcept {
+	return tile_mode == Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget);
 }
 
 [[nodiscard]] inline constexpr bool IsSupportedStandard64RenderTarget(const ImageInfo& info) {
-	if (info.tile_mode != Prospero::TileMode::kStandard64KB || info.data.address == 0 ||
-	    (info.data.address & 0xffffu) != 0 || info.extent.width == 0 || info.extent.height == 0 ||
-	    info.bytes_per_block != 4 || info.resources.levels != 1 || info.resources.layers != 1 ||
-	    info.samples != 1) {
+	if (info.tile_mode != Prospero::GpuEnumValue(Prospero::TileMode::kStandard64KB) ||
+	    info.data.address == 0 || (info.data.address & 0xffffu) != 0 || info.extent.width == 0 ||
+	    info.extent.height == 0 || info.bytes_per_block != 4 || info.resources.levels != 1 ||
+	    info.resources.layers != 1 || info.samples != 1) {
 		return false;
 	}
 	const auto expected_pitch =
@@ -418,7 +460,7 @@ IsSupportedDisplayRenderTargetTileMode(Prospero::TileMode tile_mode) noexcept {
 }
 
 [[nodiscard]] inline constexpr bool IsTiledRenderTarget(const ImageInfo& info) noexcept {
-	return info.tile_mode == Prospero::TileMode::kRenderTarget ||
+	return info.tile_mode == Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget) ||
 	       IsSupportedStandard64RenderTarget(info);
 }
 
@@ -431,10 +473,6 @@ IsSupportedDisplayRenderTargetTileMode(Prospero::TileMode tile_mode) noexcept {
 		return encoded <= 0.04045f ? encoded / 12.92f : std::pow((encoded + 0.055f) / 1.055f, 2.4f);
 	};
 	switch (format) {
-		// A single-plane float target carries its clear as raw float bits, the same encoding the
-		// depth decoder below uses. Without this the clear is discarded and the target keeps stale
-		// contents.
-		case vk::Format::eR32Sfloat: next.float32[0] = std::bit_cast<float>(packed); break;
 		case vk::Format::eR32Uint: next.uint32[0] = packed; break;
 		case vk::Format::eR32Sint: next.int32[0] = static_cast<int32_t>(packed); break;
 		case vk::Format::eR8G8B8A8Srgb:

src/graphics/host_gpu/renderer/image/imageView.cpp

@@ -4,6 +4,8 @@
 #include "graphics/host_gpu/graphicContext.h"
 #include "graphics/host_gpu/renderer/image/image.h"
 
+#include <mutex>
+
 namespace Libs::Graphics {
 
 namespace {
@@ -34,6 +36,17 @@ namespace {
 	}
 }
 
+[[nodiscard]] bool IsDepthViewFormat(vk::Format format) {
+	switch (format) {
+		case vk::Format::eD16Unorm:
+		case vk::Format::eR16Unorm:
+		case vk::Format::eD32Sfloat:
+		case vk::Format::eR32Sfloat:
+		case vk::Format::eR32Uint: return true;
+		default: return false;
+	}
+}
+
 [[nodiscard]] bool IsValidViewType(const VulkanImage& image, const ImageViewInfo& info) {
 	switch (image.image_type) {
 		case vk::ImageType::e1D:
@@ -314,13 +327,13 @@ vk::ImageView Image::FindView(const ImageViewInfo& view_info) {
 	const auto& image      = backing;
 	auto        normalized = view_info;
 	const bool  is_storage = static_cast<bool>(normalized.usage & vk::ImageUsageFlagBits::eStorage);
-	const auto  image_aspect = FullAspectMask(image.format);
-	if (image_aspect & vk::ImageAspectFlagBits::eDepth &&
-	    ImageViewOps::IsFormatDepthCompatible(normalized.format)) {
+	normalized.aspect      = FullAspectMask(image.format);
+	if (normalized.aspect & vk::ImageAspectFlagBits::eDepth &&
+	    IsDepthViewFormat(normalized.format)) {
 		normalized.format = image.format;
 		normalized.aspect = vk::ImageAspectFlagBits::eDepth;
 	}
-	if (image_aspect & vk::ImageAspectFlagBits::eStencil &&
+	if (normalized.aspect & vk::ImageAspectFlagBits::eStencil &&
 	    IsStencilViewFormat(normalized.format)) {
 		normalized.format = image.format;
 		normalized.aspect = vk::ImageAspectFlagBits::eStencil;
@@ -355,7 +368,8 @@ vk::ImageView Image::FindView(const ImageViewInfo& view_info) {
 		     image.layers);
 	}
 
-	for (const auto& cached: views) {
+	std::lock_guard lock(views.mutex);
+	for (const auto& cached: views.views) {
 		if (cached.info == normalized) {
 			return cached.view;
 		}
@@ -391,7 +405,7 @@ vk::ImageView Image::FindView(const ImageViewInfo& view_info) {
 		     view_info.level_count, view_info.base_layer, view_info.layer_count,
 		     static_cast<vk::ImageUsageFlags::MaskType>(view_info.usage));
 	}
-	views.push_back({normalized, view});
+	views.views.push_back({normalized, view});
 	return view;
 }
 

src/graphics/host_gpu/renderer/image/imageView.h

@@ -12,25 +12,8 @@ namespace ImageViewOps {
 
 [[nodiscard]] vk::ImageAspectFlags DepthAspectMask(vk::Format format);
 [[nodiscard]] bool                 FormatsCompatible(vk::Format base, vk::Format view) noexcept;
-
-[[nodiscard]] inline bool IsFormatDepthCompatible(vk::Format format) noexcept {
-	switch (format) {
-		case vk::Format::eD32Sfloat:
-		case vk::Format::eR32Sfloat:
-		case vk::Format::eR32Uint:
-		case vk::Format::eD16Unorm:
-		case vk::Format::eR16Unorm: return true;
-		default: return false;
-	}
-}
 } // namespace ImageViewOps
 
-[[nodiscard]] inline bool IsSupportedSampledDepthFormat(vk::Format image_format,
-                                                        vk::Format view_format) noexcept {
-	return DepthAspectTransferFormat(image_format) != vk::Format::eUndefined &&
-	       ImageViewOps::IsFormatDepthCompatible(view_format);
-}
-
 [[nodiscard]] inline bool IsValidImageSwizzle(uint32_t swizzle) noexcept {
 	if ((swizzle & ~0xfffu) != 0) {
 		return false;
@@ -103,16 +86,8 @@ SelectSampledDepthView(vk::Format image_format, vk::Format view_format, uint32_t
 
 [[nodiscard]] inline bool
 IsSupportedSampledDepthResource(const ShaderRecompiler::IR::ImageResource& resource) noexcept {
-	if (resource.resource_class != ShaderRecompiler::IR::ImageResourceClass::Sampled) {
-		return false;
-	}
-	if (resource.numeric_class == Prospero::TextureNumericClass::Unsupported) {
-		return false;
-	}
-	if (resource.numeric_class != Prospero::TextureNumericClass::Float && resource.depth_compare) {
-		return false;
-	}
-	return (resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D ||
+	return resource.kind == ShaderRecompiler::IR::ResourceKind::Image &&
+	       (resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D ||
 	        resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2DArray ||
 	        resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2DMsaa ||
 	        resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2DMsaaArray) &&
@@ -120,6 +95,14 @@ IsSupportedSampledDepthResource(const ShaderRecompiler::IR::ImageResource& resou
 	       !resource.written && !resource.atomic;
 }
 
+[[nodiscard]] inline bool
+IsSupportedSampledDepthUintResource(const ShaderRecompiler::IR::ImageResource& resource) noexcept {
+	return resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint &&
+	       resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D &&
+	       resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::None && resource.read &&
+	       !resource.written && !resource.atomic && !resource.depth_compare;
+}
+
 inline void ValidateStorageColorView(vk::Format image_format, vk::Format view_format,
                                      uint32_t swizzle) noexcept {
 	if (!ImageViewOps::FormatsCompatible(image_format, view_format) ||
@@ -130,33 +113,28 @@ inline void ValidateStorageColorView(vk::Format image_format, vk::Format view_fo
 
 [[nodiscard]] inline bool
 IsSupportedStorageImageResource(const ShaderRecompiler::IR::ImageResource& resource) noexcept {
-	return resource.resource_class == ShaderRecompiler::IR::ImageResourceClass::Storage &&
-	       (resource.numeric_class == Prospero::TextureNumericClass::Float ||
-	        resource.numeric_class == Prospero::TextureNumericClass::Uint) &&
+	return (resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImage ||
+	        resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint) &&
 	       (resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim1D ||
 	        resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim1DArray ||
 	        resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D ||
 	        resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim3D ||
 	        resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2DArray) &&
-	       ((resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::None &&
-	         resource.mip_count == 1u) ||
-	        (resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::DynamicStorage &&
-	         resource.mip_count != 0u)) &&
-	       resource.written &&
+	       resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::None && resource.written &&
 	       (!resource.atomic ||
-	        (resource.numeric_class == Prospero::TextureNumericClass::Uint && resource.read)) &&
+	        (resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint &&
+	         resource.read)) &&
 	       !resource.depth_compare;
 }
 
 inline void
 ValidateStorageImageResource(const ShaderRecompiler::IR::ImageResource& resource) noexcept {
 	if (!IsSupportedStorageImageResource(resource)) {
-		EXIT("unsupported storage color image resource: class=%u numeric=%u dimension=%u mip=%u "
+		EXIT("unsupported storage color image resource: kind=%u dimension=%u mip=%u "
 		     "read=%d written=%d atomic=%d depth_compare=%d\n",
-		     static_cast<uint32_t>(resource.resource_class),
-		     static_cast<uint32_t>(resource.numeric_class),
-		     static_cast<uint32_t>(resource.dimension), static_cast<uint32_t>(resource.mip_mode),
-		     resource.read, resource.written, resource.atomic, resource.depth_compare);
+		     static_cast<uint32_t>(resource.kind), static_cast<uint32_t>(resource.dimension),
+		     static_cast<uint32_t>(resource.mip_mode), resource.read, resource.written,
+		     resource.atomic, resource.depth_compare);
 	}
 }
 

src/graphics/host_gpu/renderer/image/textureCommon.cpp

@@ -14,71 +14,164 @@
 namespace Libs::Graphics {
 namespace {
 
-// Rows are channel order; columns are the number of physical components minus one. Unused
-// selectors complete each entry to a permutation so logical write masks can be inverted.
-constexpr Prospero::ColorComponentMapping kRenderTargetColorMappings[4][4] = {
-    {Prospero::ColorMappingRgba, Prospero::ColorMappingRgba, Prospero::ColorMappingRgba,
-     Prospero::ColorMappingRgba},
-    {Prospero::ColorMappingGr, Prospero::ColorMappingRabg, Prospero::ColorMappingRgab,
-     Prospero::ColorMappingBgra},
-    {Prospero::ColorMappingBgra, Prospero::ColorMappingGr, Prospero::ColorMappingBgra,
-     Prospero::ColorMappingAbgr},
-    {Prospero::ColorMappingAgba, Prospero::ColorMappingArbg, Prospero::ColorMappingAgbr,
-     Prospero::ColorMappingArgb},
+struct RenderTargetFormatMapping {
+	Prospero::ChannelLayout layout;
+	Prospero::ChannelType   type;
+	Prospero::ChannelOrder  order;
+	RenderTargetFormatInfo  info;
 };
 
-struct RenderTargetHostFormatInfo {
-	vk::Format                      format = vk::Format::eUndefined;
-	Prospero::ColorComponentMapping host_to_storage;
+constexpr RenderTargetFormatMapping kRenderTargetFormats[] = {
+    {Prospero::ChannelLayout::k8_8,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR8G8Unorm, 2}},
+    {Prospero::ChannelLayout::k8_8_8_8,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR8G8B8A8Unorm, 4}},
+    {Prospero::ChannelLayout::k8_8_8_8,
+     Prospero::ChannelType::kSNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR8G8B8A8Snorm, 4}},
+    {Prospero::ChannelLayout::k8_8_8_8,
+     Prospero::ChannelType::kSrgb,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR8G8B8A8Srgb, 4}},
+    {Prospero::ChannelLayout::k8_8_8_8,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kAlt,
+     {vk::Format::eB8G8R8A8Unorm, 4}},
+    {Prospero::ChannelLayout::k8_8_8_8,
+     Prospero::ChannelType::kSNorm,
+     Prospero::ChannelOrder::kAlt,
+     {vk::Format::eB8G8R8A8Snorm, 4}},
+    {Prospero::ChannelLayout::k8_8_8_8,
+     Prospero::ChannelType::kSrgb,
+     Prospero::ChannelOrder::kAlt,
+     {vk::Format::eB8G8R8A8Srgb, 4}},
+    {Prospero::ChannelLayout::k5_5_5_1,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR5G5B5A1UnormPack16, 2}},
+    {Prospero::ChannelLayout::k4_4_4_4,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kReversed,
+     {vk::Format::eB4G4R4A4UnormPack16, 2}},
+    {Prospero::ChannelLayout::k10_10_10_2,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eA2B10G10R10UnormPack32, 4}},
+    {Prospero::ChannelLayout::k10_10_10_2,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kAlt,
+     {vk::Format::eA2R10G10B10UnormPack32, 4}},
+    {Prospero::ChannelLayout::k11_11_10,
+     Prospero::ChannelType::kFloat,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eB10G11R11UfloatPack32, 4}},
+    {Prospero::ChannelLayout::k5_6_5,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eB5G6R5UnormPack16, 2}},
+    {Prospero::ChannelLayout::k16,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16Unorm, 2}},
+    {Prospero::ChannelLayout::k16,
+     Prospero::ChannelType::kUInt,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16Uint, 2}},
+    {Prospero::ChannelLayout::k16,
+     Prospero::ChannelType::kFloat,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16Sfloat, 2}},
+    {Prospero::ChannelLayout::k16_16,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16G16Unorm, 4}},
+    {Prospero::ChannelLayout::k16_16,
+     Prospero::ChannelType::kSNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16G16Snorm, 4}},
+    {Prospero::ChannelLayout::k16_16,
+     Prospero::ChannelType::kUInt,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16G16Uint, 4}},
+    {Prospero::ChannelLayout::k16_16,
+     Prospero::ChannelType::kFloat,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16G16Sfloat, 4}},
+    {Prospero::ChannelLayout::k16_16_16_16,
+     Prospero::ChannelType::kUNorm,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16G16B16A16Unorm, 8}},
+    {Prospero::ChannelLayout::k16_16_16_16,
+     Prospero::ChannelType::kUInt,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16G16B16A16Uint, 8}},
+    {Prospero::ChannelLayout::k16_16_16_16,
+     Prospero::ChannelType::kFloat,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR16G16B16A16Sfloat, 8}},
+    {Prospero::ChannelLayout::k16_16_16_16,
+     Prospero::ChannelType::kFloat,
+     Prospero::ChannelOrder::kAlt,
+     {vk::Format::eR16G16B16A16Sfloat, 8, Prospero::ColorMappingBgra}},
+    {Prospero::ChannelLayout::k16_16_16_16,
+     Prospero::ChannelType::kFloat,
+     Prospero::ChannelOrder::kReversed,
+     {vk::Format::eR16G16B16A16Sfloat, 8, Prospero::ColorMappingAbgr}},
+    {Prospero::ChannelLayout::k32,
+     Prospero::ChannelType::kFloat,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR32Sfloat, 4}},
+    {Prospero::ChannelLayout::k32_32,
+     Prospero::ChannelType::kUInt,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR32G32Uint, 8}},
+    {Prospero::ChannelLayout::k32_32,
+     Prospero::ChannelType::kFloat,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR32G32Sfloat, 8}},
+    {Prospero::ChannelLayout::k32_32_32_32,
+     Prospero::ChannelType::kFloat,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR32G32B32A32Sfloat, 16}},
 };
 
-RenderTargetHostFormatInfo ResolveRenderTargetHostFormat(Prospero::BufferFormat guest_format,
-                                                         Prospero::ChannelOrder order) {
-	if (order == Prospero::ChannelOrder::kAlt) {
-		switch (guest_format) {
-			case Prospero::BufferFormat::k8_8_8_8UNorm:
-				return {vk::Format::eB8G8R8A8Unorm, Prospero::ColorMappingBgra};
-			case Prospero::BufferFormat::k8_8_8_8SNorm:
-				return {vk::Format::eB8G8R8A8Snorm, Prospero::ColorMappingBgra};
-			case Prospero::BufferFormat::k8_8_8_8Srgb:
-				return {vk::Format::eB8G8R8A8Srgb, Prospero::ColorMappingBgra};
-			case Prospero::BufferFormat::k10_10_10_2UNorm:
-				return {vk::Format::eA2R10G10B10UnormPack32, Prospero::ColorMappingBgra};
-			default: break;
-		}
-	}
-	switch (guest_format) {
-		case Prospero::BufferFormat::k5_5_5_1UNorm:
-			return {vk::Format::eA1R5G5B5UnormPack16, Prospero::ColorMappingBgra};
-		case Prospero::BufferFormat::k1_5_5_5UNorm:
-			return {vk::Format::eR5G5B5A1UnormPack16, Prospero::ColorMappingAbgr};
-		case Prospero::BufferFormat::k4_4_4_4UNorm:
-			return {vk::Format::eR4G4B4A4UnormPack16, Prospero::ColorMappingAbgr};
-		default: return {VulkanFormat(guest_format), {}};
-	}
-}
-
 } // namespace
 
-RenderTargetFormatInfo TextureGetRenderTargetFormat(Prospero::ChannelLayout layout,
-                                                    Prospero::ChannelType   type,
-                                                    Prospero::ChannelOrder  order) {
-	const auto encoding = Prospero::ResolveRenderTargetFormat(layout, type);
-	if (encoding.IsValid() && encoding.SupportsOrder(order)) {
-		const auto host  = ResolveRenderTargetHostFormat(encoding.buffer_format, order);
-		const auto bytes = Prospero::RenderTargetBytesPerElement(encoding.buffer_format);
-		if (host.format != vk::Format::eUndefined && bytes != 0) {
-			const auto order_mapping =
-			    kRenderTargetColorMappings[static_cast<size_t>(order)][encoding.components - 1u];
-			return {host.format, bytes, host.host_to_storage.Then(order_mapping)};
+// TODO: cleanup!
+RenderTargetFormatInfo TextureGetRenderTargetFormat(uint32_t raw_layout, uint32_t raw_type,
+                                                    uint32_t raw_order) {
+	const auto layout = static_cast<Prospero::ChannelLayout>(raw_layout);
+	const auto type   = static_cast<Prospero::ChannelType>(raw_type);
+	const auto order  = static_cast<Prospero::ChannelOrder>(raw_order);
+
+	if (layout == Prospero::ChannelLayout::k8 && type == Prospero::ChannelType::kUNorm &&
+	    raw_order <= Prospero::GpuEnumValue(Prospero::ChannelOrder::kAltReversed)) {
+		return {vk::Format::eR8Unorm, 1};
+	}
+	for (const auto& mapping: kRenderTargetFormats) {
+		if (mapping.layout == layout && mapping.type == type && mapping.order == order) {
+			return mapping.info;
 		}
 	}
-	EXIT("unsupported render-target format combination: layout=%u type=%u order=%u\n",
-	     static_cast<uint32_t>(layout), static_cast<uint32_t>(type), static_cast<uint32_t>(order));
+	EXIT("unsupported render-target format combination: layout=%u type=%u order=%u\n", raw_layout,
+	     raw_type, raw_order);
 }
 
 namespace {
 
+static uint64_t GetLevelSrcOffset(const TileSizeOffset& level_size) {
+	return (level_size.src_size != 0 ? level_size.src_offset : level_size.offset);
+}
+
+static uint64_t GetLevelSrcSize(const TileSizeOffset& level_size) {
+	return (level_size.src_size != 0 ? level_size.src_size : level_size.size);
+}
+
 static uint32_t GetTextureLevelDepth(uint32_t depth, uint32_t level, bool volume_texture) {
 	return volume_texture ? std::max(depth >> level, 1u) : depth;
 }
@@ -91,6 +184,20 @@ static size_t GetTextureRegionCount(uint32_t depth, uint64_t levels, bool volume
 	return count;
 }
 
+uint64_t TextureUploadSliceSourceOffset(const TextureUploadLayout& layout, uint32_t level,
+                                        uint32_t slice) {
+	if (level >= 16 || layout.level_sizes[level].size == 0) {
+		EXIT("invalid texture upload slice source, level=%u slice=%u\n", level, slice);
+	}
+	const auto level_offset = GetLevelSrcOffset(layout.level_sizes[level]);
+	const auto slice_stride =
+	    layout.source_slice_stride != 0 ? layout.source_slice_stride : layout.slice_stride;
+	if (slice_stride != 0 && slice > (UINT64_MAX - level_offset) / slice_stride) {
+		EXIT("texture upload slice source offset overflow, level=%u slice=%u\n", level, slice);
+	}
+	return level_offset + static_cast<uint64_t>(slice) * slice_stride;
+}
+
 vk::ComponentSwizzle TextureGetComponentSwizzle(uint8_t s) {
 	switch (static_cast<Prospero::CompSwizzle>(s)) {
 		case Prospero::CompSwizzle::kZero: return vk::ComponentSwizzle::eZero;
@@ -119,25 +226,23 @@ vk::ComponentMapping TextureGetComponentMapping(uint32_t swizzle) {
 	return components;
 }
 
-SurfaceFormatInfo TextureGetSurfaceFormatInfo(Prospero::BufferFormat format) {
-	const auto backing_format    = Prospero::RemapTextureFormat(format);
-	const auto vk_format         = VulkanFormat(backing_format);
-	const auto conversion_format =
-	    backing_format != format ? format : Prospero::BufferFormat::kInvalid;
+vk::Format TextureGetFormat(uint32_t fmt) {
+	const auto vk_format = VulkanFormat(fmt);
 	if (vk_format != vk::Format::eUndefined) {
-		return SurfaceFormatInfo(vk_format, conversion_format);
+		return vk_format;
 	}
-	EXIT("unknown format: fmt = %u\n", static_cast<uint32_t>(format));
-	return SurfaceFormatInfo(vk::Format::eUndefined, Prospero::BufferFormat::kInvalid);
+	EXIT("unknown format: fmt = %u\n", fmt);
+	return vk::Format::eUndefined;
 }
 
 namespace {
 
-uint64_t CalcTextureSliceStride(const TextureUploadMipLayout* mips, uint64_t levels,
+uint64_t CalcTextureSliceStride(const TileSizeOffset* level_sizes, uint64_t levels,
                                 uint64_t total_size, uint32_t depth) {
 	uint64_t stride = 0;
 	for (uint32_t i = 0; i < levels; i++) {
-		stride = std::max(stride, mips[i].offset + mips[i].size);
+		stride =
+		    std::max(stride, static_cast<uint64_t>(level_sizes[i].offset) + level_sizes[i].size);
 	}
 
 	if (depth > 1 && total_size != 0 && total_size % depth == 0) {
@@ -150,26 +255,39 @@ uint64_t CalcTextureSliceStride(const TextureUploadMipLayout* mips, uint64_t lev
 	return stride;
 }
 
-uint64_t CalcLinearUploadLevelSize(const TileTextureElementLayout& element, uint32_t pitch,
-                                   uint32_t height) {
-	const uint32_t elements_w =
-	    std::max((pitch + element.texel_width - 1u) / element.texel_width, 1u);
-	const uint32_t elements_h =
-	    std::max((height + element.texel_height - 1u) / element.texel_height, 1u);
-	return static_cast<uint64_t>(elements_w) * elements_h * element.bytes;
+uint64_t CalcLinearUploadLevelSize(uint32_t fmt, uint32_t pitch, uint32_t height) {
+	if (const uint32_t bytes_per_element = Prospero::NumBytesPerElement(fmt);
+	    bytes_per_element != 0) {
+		return static_cast<uint64_t>(pitch) * height * bytes_per_element;
+	}
+
+	if (const uint32_t bytes_per_block = Prospero::BlockCompressedBytesPerBlock(fmt);
+	    bytes_per_block != 0) {
+		const uint32_t blocks_w = std::max((pitch + 3u) / 4u, 1u);
+		const uint32_t blocks_h = std::max((height + 3u) / 4u, 1u);
+		return static_cast<uint64_t>(blocks_w) * blocks_h * bytes_per_block;
+	}
+
+	return 0;
 }
 
-uint64_t SetLinearUploadLevels(TextureUploadMipLayout*         mips,
-                               const TileTextureElementLayout& element, uint64_t height,
+uint64_t SetLinearUploadLevels(TileSizeOffset* level_sizes, uint32_t fmt, uint64_t height,
                                uint64_t levels, uint32_t base_pitch) {
 	uint64_t offset = 0;
 	auto     pitch  = base_pitch;
 	auto     h      = static_cast<uint32_t>(height);
 
 	for (uint32_t i = 0; i < levels; i++) {
-		const auto size = CalcLinearUploadLevelSize(element, pitch, h);
-		mips[i].size    = size;
-		mips[i].offset  = offset;
+		const auto size = CalcLinearUploadLevelSize(fmt, pitch, h);
+		EXIT_NOT_IMPLEMENTED(size > 0xffffffffull);
+		EXIT_NOT_IMPLEMENTED(offset > 0xffffffffull);
+
+		level_sizes[i].size       = static_cast<uint32_t>(size);
+		level_sizes[i].offset     = static_cast<uint32_t>(offset);
+		level_sizes[i].src_size   = 0;
+		level_sizes[i].src_offset = 0;
+		level_sizes[i].x          = 0;
+		level_sizes[i].y          = 0;
 
 		offset += size;
 		if (pitch > 1) {
@@ -185,126 +303,141 @@ uint64_t SetLinearUploadLevels(TextureUploadMipLayout*         mips,
 
 } // namespace
 
-TextureUploadLayout TextureCalcUploadLayout(Prospero::BufferFormat format, uint32_t width,
-                                            uint32_t height, uint32_t levels, uint32_t depth,
-                                            Prospero::TileMode tile, uint64_t upload_size,
+TextureUploadLayout TextureCalcUploadLayout(uint32_t fmt, uint64_t width, uint64_t height,
+                                            uint64_t levels, uint32_t depth, uint64_t pitch,
+                                            uint64_t tile, uint64_t upload_size,
                                             bool allow_depth_tile, bool volume_texture,
                                             const char* owner) {
 	TextureUploadLayout layout {};
-	layout.surface.description = {
-	    format,
-	    tile,
-	    volume_texture ? TileSurfaceDimension::Dim3D : TileSurfaceDimension::Dim2D,
-	    width,
-	    height,
-	    volume_texture ? depth : 1u,
-	    levels,
-	    volume_texture ? 1u : depth,
-	};
-	const auto&              description = layout.surface.description;
-	const auto               tile_mode   = description.tile_mode;
-	TileTextureElementLayout element {};
+	layout.tile           = static_cast<uint32_t>(tile);
+	layout.pitch          = static_cast<uint32_t>(pitch);
+	layout.texel_block    = Prospero::BlockCompressedBytesPerBlock(fmt) != 0 ? 4u : 1u;
+	layout.volume_texture = volume_texture;
 
-	if (format == Prospero::BufferFormat::kInvalid) {
-		EXIT("%s: legacy texture upload format unsupported: fmt=0 tile=%u size=%" PRIu64
-		     " extent=%ux%u levels=%u\n",
-		     owner, static_cast<uint32_t>(description.tile_mode), upload_size, width, height,
-		     levels);
-	}
-
-	switch (tile_mode) {
-		case Prospero::TileMode::kLinear:
-			if (!TileGetTextureElementLayout(format, element)) {
-				EXIT("%s: unsupported linear texture format: fmt=%u\n", owner,
-				     static_cast<uint32_t>(format));
+	if (fmt != 0) {
+		if (layout.tile != 0) {
+			const auto tile_mode = static_cast<Prospero::TileMode>(layout.tile);
+			switch (tile_mode) {
+				case Prospero::TileMode::kStandard256B:
+					if (TileIsStandard256BTextureSupported(fmt)) {
+						layout.tile_family = TileBlockFamily::Standard256B;
+					}
+					break;
+				case Prospero::TileMode::kStandard4KB:
+					if (TileIsStandard4KBTextureSupported(fmt)) {
+						layout.tile_family = TileBlockFamily::Standard4KB;
+					}
+					break;
+				case Prospero::TileMode::kStandard64KB:
+					if (TileIsStandard64KBTextureSupported(fmt)) {
+						layout.tile_family = TileBlockFamily::Standard64KB;
+					}
+					break;
+				case Prospero::TileMode::kPrt:
+					if (TileIsStandard64KBTextureSupported(fmt)) {
+						layout.tile_family = TileBlockFamily::Prt64KB;
+					}
+					break;
+				case Prospero::TileMode::kRenderTarget:
+					if (Prospero::RenderTargetBytesPerElement(fmt) != 0) {
+						layout.tile_family = TileBlockFamily::RenderTarget64KB;
+					}
+					break;
+				case Prospero::TileMode::kDepth:
+					if (allow_depth_tile && Prospero::RenderTargetBytesPerElement(fmt) != 0) {
+						layout.tile_family = TileBlockFamily::Depth64KB;
+					}
+					break;
+				default: break;
 			}
-			break;
-		case Prospero::TileMode::kDepth:
-			if (!allow_depth_tile || !TileGetTiledTextureLayout(description, layout.surface)) {
+			if (layout.tile_family == TileBlockFamily::Count) {
 				EXIT("%s: unsupported typed tiled upload: fmt=%u tile=%u "
-				     "size=%" PRIu64 " extent=%ux%u levels=%u\n",
-				     owner, static_cast<uint32_t>(format),
-				     static_cast<uint32_t>(description.tile_mode), upload_size, width, height,
-				     levels);
+				     "size=%" PRIu64 " extent=%" PRIu64 "x%" PRIu64 " pitch=%" PRIu64
+				     " levels=%" PRIu64 "\n",
+				     owner, static_cast<uint32_t>(fmt), layout.tile, upload_size, width, height,
+				     pitch, levels);
 			}
-			break;
-		default:
-			if (!TileGetTiledTextureLayout(description, layout.surface)) {
-				EXIT("%s: unsupported typed tiled upload: fmt=%u tile=%u "
-				     "size=%" PRIu64 " extent=%ux%u levels=%u\n",
-				     owner, static_cast<uint32_t>(format),
-				     static_cast<uint32_t>(description.tile_mode), upload_size, width, height,
-				     levels);
-			}
-			break;
-	}
-
-	if (tile_mode != Prospero::TileMode::kLinear) {
-		element = {layout.surface.texture.block.bytes_per_element,
-		           layout.surface.texture.texel_width, layout.surface.texture.texel_height};
-	}
-	layout.pitch = TileGetTexturePitch(format, width, description.tile_mode);
-	if (tile_mode == Prospero::TileMode::kLinear) {
-		TileSizeOffset level_sizes[16] {};
-		TilePaddedSize padded_sizes[16] {};
-		TileGetTextureSize(format, width, height, levels, description.tile_mode, nullptr,
-		                   level_sizes, padded_sizes);
-		for (uint32_t level = 0; level < levels; ++level) {
-			layout.mips[level] = {level_sizes[level].offset, level_sizes[level].size,
-			                      padded_sizes[level].width, padded_sizes[level].height};
 		}
-	} else if (volume_texture) {
-		layout.slice_stride = SetLinearUploadLevels(layout.mips, element, height, levels, width);
+
+		layout.pitch = TileGetTexturePitch(fmt, width, levels, layout.tile);
+
+		TileGetTextureSize(fmt, width, height, layout.pitch, levels, layout.tile, nullptr,
+		                   layout.level_sizes, layout.padded_sizes);
+
+		if (static_cast<Prospero::TileMode>(layout.tile) != Prospero::TileMode::kLinear) {
+			if (layout.volume_texture) {
+				layout.slice_stride = SetLinearUploadLevels(layout.level_sizes, fmt, height, levels,
+				                                            static_cast<uint32_t>(width));
+			} else {
+				TileSizeOffset tiled_levels[16] {};
+				std::copy_n(layout.level_sizes, levels, tiled_levels);
+				layout.source_slice_stride =
+				    CalcTextureSliceStride(tiled_levels, levels, upload_size, depth);
+				SetLinearUploadLevels(layout.level_sizes, fmt, height, levels, layout.pitch);
+				for (uint32_t i = 0; i < levels; ++i) {
+					if (tiled_levels[i].src_size > tiled_levels[i].size) {
+						layout.first_tail_level = std::min(layout.first_tail_level, i);
+					}
+					layout.level_sizes[i].src_offset = GetLevelSrcOffset(tiled_levels[i]);
+					layout.level_sizes[i].src_size   = GetLevelSrcSize(tiled_levels[i]);
+					layout.level_sizes[i].x          = tiled_levels[i].x;
+					layout.level_sizes[i].y          = tiled_levels[i].y;
+				}
+			}
+		} else if (layout.volume_texture) {
+			layout.slice_stride =
+			    CalcTextureSliceStride(layout.level_sizes, levels, upload_size, depth);
+		}
 	} else {
-		layout.source_slice_stride = layout.surface.block_slice_size;
-		if (depth > 1 && upload_size != 0 && upload_size % depth == 0) {
-			layout.source_slice_stride = std::max(layout.source_slice_stride, upload_size / depth);
-		}
-		SetLinearUploadLevels(layout.mips, element, height, levels, layout.pitch);
+		EXIT("%s: legacy texture upload format unsupported: fmt=0 tile=%u size=%" PRIu64
+		     " extent=%" PRIu64 "x%" PRIu64 " pitch=%" PRIu64 " levels=%" PRIu64 "\n",
+		     owner, layout.tile, upload_size, width, height, pitch, levels);
 	}
 
-	if (!volume_texture || tile_mode == Prospero::TileMode::kLinear) {
-		layout.slice_stride = CalcTextureSliceStride(layout.mips, levels, upload_size, depth);
+	if (!layout.volume_texture) {
+		layout.slice_stride =
+		    CalcTextureSliceStride(layout.level_sizes, levels, upload_size, depth);
 	}
 	return layout;
 }
 
-std::vector<vk::BufferImageCopy> TextureBuildImageCopies(const TextureUploadLayout& layout) {
-	const auto& description    = layout.surface.description;
-	const bool  volume_texture = description.dimension == TileSurfaceDimension::Dim3D;
-	const auto  depth          = volume_texture ? description.depth : description.layers;
-	uint32_t    mip_width      = description.width;
-	uint32_t    mip_height     = description.height;
-	uint32_t    mip_pitch = volume_texture && description.tile_mode != Prospero::TileMode::kLinear
-	                            ? description.width
-	                            : layout.pitch;
+std::vector<vk::BufferImageCopy> TextureBuildImageCopies(const TextureUploadLayout& layout,
+                                                         uint32_t width, uint32_t height,
+                                                         uint32_t depth, uint64_t levels,
+                                                         bool array_texture, bool volume_texture) {
+	uint32_t mip_width  = width;
+	uint32_t mip_height = height;
+	uint32_t mip_pitch  = volume_texture && static_cast<Prospero::TileMode>(layout.tile) !=
+	                                            Prospero::TileMode::kLinear
+	                          ? width
+	                          : layout.pitch;
 
 	std::vector<vk::BufferImageCopy> regions;
-	regions.reserve(GetTextureRegionCount(depth, description.levels, volume_texture));
-	for (uint32_t i = 0; i < description.levels; i++) {
-		EXIT_NOT_IMPLEMENTED(layout.mips[i].size == 0);
+	regions.reserve(GetTextureRegionCount(depth, levels, volume_texture));
+	for (uint32_t i = 0; i < levels; i++) {
+		EXIT_NOT_IMPLEMENTED(layout.level_sizes[i].size == 0);
 
 		const auto mip_depth = GetTextureLevelDepth(depth, i, volume_texture);
 
 		for (uint32_t z = 0; z < mip_depth; z++) {
 			const auto          slice_offset = z * layout.slice_stride;
 			vk::BufferImageCopy region {};
-			region.bufferOffset     = layout.mips[i].offset + slice_offset;
-			region.imageSubresource = {vk::ImageAspectFlagBits::eColor, i, volume_texture ? 0u : z,
+			region.bufferOffset     = layout.level_sizes[i].offset + slice_offset;
+			region.imageSubresource = {vk::ImageAspectFlagBits::eColor, i, array_texture ? z : 0,
 			                           1};
 			region.imageOffset.z    = volume_texture ? static_cast<int>(z) : 0;
 			region.imageExtent      = {mip_width, mip_height, 1};
-			const bool linear       = description.tile_mode == Prospero::TileMode::kLinear;
+			const bool linear =
+			    static_cast<Prospero::TileMode>(layout.tile) == Prospero::TileMode::kLinear;
 			if (linear) {
-				region.bufferRowLength   = layout.mips[i].row_length;
-				region.bufferImageHeight = layout.mips[i].image_height;
+				region.bufferRowLength   = layout.padded_sizes[i].width;
+				region.bufferImageHeight = layout.padded_sizes[i].height;
 			} else {
-				const auto texel_width = layout.surface.texture.texel_width;
-				const auto align       = [](uint32_t value, uint32_t block) {
+				const auto align = [](uint32_t value, uint32_t block) {
 					return ((value + block - 1u) / block) * block;
 				};
-				const auto pitch       = align(mip_pitch, texel_width);
-				region.bufferRowLength = pitch > align(mip_width, texel_width) ? pitch : 0;
+				const auto pitch       = align(mip_pitch, layout.texel_block);
+				region.bufferRowLength = pitch > align(mip_width, layout.texel_block) ? pitch : 0;
 			}
 			regions.push_back(region);
 		}
@@ -323,6 +456,24 @@ std::vector<vk::BufferImageCopy> TextureBuildImageCopies(const TextureUploadLayo
 	return regions;
 }
 
+struct GpuTileElementLayout {
+	uint32_t bytes = 0;
+	uint32_t wide  = 1;
+	uint32_t tall  = 1;
+};
+
+static bool GetGpuTileElementLayout(uint32_t fmt, GpuTileElementLayout& out) {
+	if (const auto bytes = Prospero::NumBytesPerElement(fmt); bytes != 0) {
+		out = {bytes, 1, 1};
+		return true;
+	}
+	if (const auto bytes = Prospero::BlockCompressedBytesPerBlock(fmt); bytes != 0) {
+		out = {bytes, 4, 4};
+		return true;
+	}
+	return false;
+}
+
 static bool SetGpuTileSize(uint64_t offset, uint64_t length, uint64_t capacity, uint64_t& size) {
 	if (offset > capacity || length > capacity - offset) {
 		return false;
@@ -331,33 +482,43 @@ static bool SetGpuTileSize(uint64_t offset, uint64_t length, uint64_t capacity,
 	return true;
 }
 
-bool TextureBuildGpuTileInfos(uint64_t tiled_size, const std::vector<vk::BufferImageCopy>& regions,
-                              const TextureUploadLayout& layout, uint32_t levels,
-                              std::vector<GpuTileInfo>& out_infos) {
-	const auto& description    = layout.surface.description;
-	const bool  volume_texture = description.dimension == TileSurfaceDimension::Dim3D;
-	const auto  depth          = volume_texture ? description.depth : description.layers;
-	if (tiled_size == 0 || levels == 0 || levels > 16 || depth == 0 ||
-	    regions.size() != GetTextureRegionCount(depth, levels, volume_texture) ||
-	    Prospero::IsFmaskTextureFormat(description.format)) {
+bool TextureBuildGpuTileInfos(uint64_t size, const std::vector<vk::BufferImageCopy>& regions,
+                              const TextureUploadLayout& layout, uint32_t fmt, uint32_t depth,
+                              uint64_t levels, std::vector<GpuTileInfo>& out_infos) {
+	if (size == 0 || levels == 0 || levels > 16 || depth == 0 ||
+	    regions.size() != GetTextureRegionCount(depth, levels, layout.volume_texture) ||
+	    Prospero::IsFmaskTextureFormat(fmt)) {
 		return false;
 	}
 
-	const auto& surface = layout.surface;
-	const auto& texture = surface.texture;
-	const auto& block   = texture.block;
-	if (surface.description.levels < levels || block.bytes_per_element == 0 ||
-	    block.family == TileBlockFamily::Count) {
+	GpuTileElementLayout element {};
+	if (layout.tile_family == TileBlockFamily::RenderTarget64KB ||
+	    layout.tile_family == TileBlockFamily::Depth64KB) {
+		element.bytes = Prospero::RenderTargetBytesPerElement(fmt);
+	} else if (!GetGpuTileElementLayout(fmt, element)) {
+		return false;
+	}
+	if (element.bytes == 0) {
 		return false;
 	}
 
 	std::vector<GpuTileInfo> infos;
 	infos.reserve(regions.size());
-	if (volume_texture) {
+	if (layout.volume_texture) {
+		TileVolumeLayout volume {};
+		if (!TileGetTextureVolumeLayout(fmt, regions[0].imageExtent.width,
+		                                regions[0].imageExtent.height, depth,
+		                                static_cast<uint32_t>(levels), layout.tile, volume)) {
+			return false;
+		}
+		element = {volume.bytes_per_element, volume.texel_width, volume.texel_height};
+		TileBlockLayout block {};
+		if (!TileGetBlockLayout(volume.family, element.bytes, block)) return false;
+
 		size_t region_base = 0;
 		for (uint32_t level = 0; level < levels; ++level) {
 			const uint32_t mip_depth     = GetTextureLevelDepth(depth, level, true);
-			const bool     tail          = level >= surface.first_tail_level;
+			const bool     tail          = level >= volume.first_tail_level;
 			const uint64_t linear_stride = layout.slice_stride;
 			for (uint32_t z = 0; z < mip_depth; z += block.block_depth) {
 				const uint32_t copy_depth = std::min(block.block_depth, mip_depth - z);
@@ -372,43 +533,49 @@ bool TextureBuildGpuTileInfos(uint64_t tiled_size, const std::vector<vk::BufferI
 				info.bytes_per_element = block.bytes_per_element;
 				info.linear_offset     = region.bufferOffset;
 				info.tiled_offset =
-				    static_cast<uint64_t>(z / block.block_depth) * surface.block_slice_size +
-				    surface.mips[level].offset;
+				    static_cast<uint64_t>(z / block.block_depth) * volume.block_slice_size +
+				    volume.level_offsets[level];
 				const uint64_t linear_span =
 				    static_cast<uint64_t>(copy_depth - 1u) * linear_stride +
-				    layout.mips[level].size;
-				if (!SetGpuTileSize(info.linear_offset, linear_span, UINT64_MAX,
-				                    info.linear_size) ||
-				    !SetGpuTileSize(info.tiled_offset, surface.mips[level].size, tiled_size,
+				    layout.level_sizes[level].size;
+				if (!SetGpuTileSize(info.linear_offset, linear_span, size, info.linear_size) ||
+				    !SetGpuTileSize(info.tiled_offset, volume.level_sizes[level], size,
 				                    info.tiled_size)) {
 					return false;
 				}
 				info.linear_slice_stride = linear_stride;
-				info.width  = std::max((region.imageExtent.width + texture.texel_width - 1u) /
-				                           texture.texel_width,
-				                       1u);
-				info.height = std::max(
-				    (logical_height + texture.texel_height - 1u) / texture.texel_height, 1u);
-				info.depth = copy_depth;
+				info.width =
+				    std::max((region.imageExtent.width + element.wide - 1u) / element.wide, 1u);
+				info.height = std::max((logical_height + element.tall - 1u) / element.tall, 1u);
+				info.depth  = copy_depth;
 				info.surface_z =
 				    block.block_depth == 1 ? static_cast<uint32_t>(region.imageOffset.z) : 0;
-				info.pitch = std::max((pitch + texture.texel_width - 1u) / texture.texel_width, 1u);
-				info.tail_x       = tail ? surface.mips[level].tail_x : 0;
-				info.tail_y       = tail ? surface.mips[level].tail_y : 0;
+				info.pitch        = std::max((pitch + element.wide - 1u) / element.wide, 1u);
+				info.tail_x       = tail ? volume.tail_x[level] : 0;
+				info.tail_y       = tail ? volume.tail_y[level] : 0;
 				info.tail         = tail;
-				info.tiled_width  = surface.mips[level].padded_width;
-				info.tiled_height = surface.mips[level].padded_height;
+				info.tiled_width  = volume.level_widths[level];
+				info.tiled_height = volume.level_heights[level];
 				infos.push_back(info);
 			}
 			region_base += mip_depth;
 		}
 	} else {
+		const auto base_family = layout.tile_family;
+		if (base_family == TileBlockFamily::Count) {
+			return false;
+		}
+
 		size_t region_index = 0;
 		for (uint32_t level = 0; level < levels; level++) {
-			const auto& level_size  = layout.mips[level];
-			const auto& mip         = surface.mips[level];
-			const bool  tail        = level >= surface.first_tail_level;
-			const auto  level_depth = GetTextureLevelDepth(depth, level, false);
+			const auto&     level_size = layout.level_sizes[level];
+			const bool      tail       = level >= layout.first_tail_level;
+			const auto      family     = base_family;
+			TileBlockLayout block {};
+			if (!TileGetBlockLayout(family, element.bytes, block)) {
+				return false;
+			}
+			const auto level_depth = GetTextureLevelDepth(depth, level, layout.volume_texture);
 			for (uint32_t z = 0; z < level_depth; z++) {
 				const auto& region = regions[region_index++];
 				const auto  pitch =
@@ -417,36 +584,38 @@ bool TextureBuildGpuTileInfos(uint64_t tiled_size, const std::vector<vk::BufferI
 				                                 ? region.bufferImageHeight
 				                                 : region.imageExtent.height;
 				GpuTileInfo info {};
-				info.family              = block.family;
-				info.bytes_per_element   = block.bytes_per_element;
-				info.linear_offset       = region.bufferOffset;
-				const auto source_stride = layout.source_slice_stride != 0
-				                               ? layout.source_slice_stride
-				                               : surface.block_slice_size;
-				if (z > (UINT64_MAX - mip.offset) / source_stride) {
+				info.family            = block.family;
+				info.bytes_per_element = block.bytes_per_element;
+				info.linear_offset     = region.bufferOffset;
+				info.tiled_offset      = TextureUploadSliceSourceOffset(layout, level, z);
+				if (!SetGpuTileSize(info.linear_offset, level_size.size, size, info.linear_size) ||
+				    !SetGpuTileSize(info.tiled_offset, GetLevelSrcSize(level_size), size,
+				                    info.tiled_size)) {
 					return false;
 				}
-				info.tiled_offset = mip.offset + static_cast<uint64_t>(z) * source_stride;
-				if (!SetGpuTileSize(info.linear_offset, level_size.size, UINT64_MAX,
-				                    info.linear_size) ||
-				    !SetGpuTileSize(info.tiled_offset, mip.size, tiled_size, info.tiled_size)) {
-					return false;
-				}
-				info.width  = std::max((region.imageExtent.width + texture.texel_width - 1u) /
-				                           texture.texel_width,
-				                       1u);
-				info.height = std::max(
-				    (logical_height + texture.texel_height - 1u) / texture.texel_height, 1u);
-				info.surface_z = block.family == TileBlockFamily::RenderTarget64KB ||
-				                         block.family == TileBlockFamily::Depth64KB
+				info.width =
+				    std::max((region.imageExtent.width + element.wide - 1u) / element.wide, 1u);
+				info.height    = std::max((logical_height + element.tall - 1u) / element.tall, 1u);
+				info.surface_z = base_family == TileBlockFamily::RenderTarget64KB ||
+				                         base_family == TileBlockFamily::Depth64KB
 				                     ? region.imageSubresource.baseArrayLayer
 				                     : 0;
-				info.pitch = std::max((pitch + texture.texel_width - 1u) / texture.texel_width, 1u);
-				info.tail  = tail;
-				info.tail_x       = tail ? mip.tail_x : 0;
-				info.tail_y       = tail ? mip.tail_y : 0;
-				info.tiled_width  = mip.padded_width;
-				info.tiled_height = mip.padded_height;
+				info.pitch     = std::max((pitch + element.wide - 1u) / element.wide, 1u);
+				info.tail      = tail;
+				info.tail_x    = tail ? level_size.x : 0;
+				info.tail_y    = tail ? level_size.y : 0;
+				info.tiled_width =
+				    layout.padded_sizes[level].width != 0
+				        ? std::max((layout.padded_sizes[level].width + element.wide - 1u) /
+				                       element.wide,
+				                   1u)
+				        : info.pitch;
+				info.tiled_height =
+				    layout.padded_sizes[level].height != 0
+				        ? std::max((layout.padded_sizes[level].height + element.tall - 1u) /
+				                       element.tall,
+				                   1u)
+				        : info.height;
 				infos.push_back(info);
 			}
 		}

src/graphics/host_gpu/renderer/image/textureCommon.h

@@ -3,7 +3,7 @@
 
 #include "common/abi.h"
 #include "common/common.h"
-#include "graphics/guest_gpu/gpu_format.h"
+#include "graphics/guest_gpu/gpu_defs.h"
 #include "graphics/guest_gpu/tile.h"
 #include "graphics/host_gpu/vulkanCommon.h"
 
@@ -19,44 +19,34 @@ struct RenderTargetFormatInfo {
 	Prospero::ColorComponentMapping export_mapping;
 };
 
-struct SurfaceFormatInfo {
-	explicit constexpr SurfaceFormatInfo(vk::Format format,
-	                                     Prospero::BufferFormat conversion_format)
-	    : vk_format(format), conversion_format(conversion_format) {}
-
-	vk::Format             vk_format;
-	Prospero::BufferFormat conversion_format;
-};
-
-struct TextureUploadMipLayout {
-	uint64_t offset       = 0;
-	uint64_t size         = 0;
-	uint32_t row_length   = 0;
-	uint32_t image_height = 0;
-};
-
 struct TextureUploadLayout {
-	uint32_t               pitch               = 0;
-	uint64_t               slice_stride        = 0;
-	uint64_t               source_slice_stride = 0;
-	TileSurfaceLayout      surface;
-	TextureUploadMipLayout mips[16] = {};
+	uint32_t        tile                = 0;
+	uint32_t        pitch               = 0;
+	uint32_t        texel_block         = 1;
+	uint64_t        slice_stride        = 0;
+	uint64_t        source_slice_stride = 0;
+	uint32_t        first_tail_level    = 16;
+	TileBlockFamily tile_family         = TileBlockFamily::Count;
+	bool            volume_texture      = false;
+	TileSizeOffset  level_sizes[16]     = {};
+	TilePaddedSize  padded_sizes[16]    = {};
 };
 
 vk::ComponentMapping   TextureGetComponentMapping(uint32_t swizzle);
-SurfaceFormatInfo      TextureGetSurfaceFormatInfo(Prospero::BufferFormat format);
-RenderTargetFormatInfo TextureGetRenderTargetFormat(Prospero::ChannelLayout layout,
-                                                    Prospero::ChannelType   type,
-                                                    Prospero::ChannelOrder  order);
-TextureUploadLayout    TextureCalcUploadLayout(Prospero::BufferFormat format, uint32_t width,
-                                               uint32_t height, uint32_t levels, uint32_t depth,
-                                               Prospero::TileMode tile, uint64_t upload_size,
+vk::Format             TextureGetFormat(uint32_t fmt);
+RenderTargetFormatInfo TextureGetRenderTargetFormat(uint32_t layout, uint32_t type, uint32_t order);
+TextureUploadLayout    TextureCalcUploadLayout(uint32_t fmt, uint64_t width, uint64_t height,
+                                               uint64_t levels, uint32_t depth, uint64_t pitch,
+                                               uint64_t tile, uint64_t upload_size,
                                                bool allow_depth_tile, bool volume_texture,
                                                const char* owner);
-std::vector<vk::BufferImageCopy> TextureBuildImageCopies(const TextureUploadLayout& layout);
-bool TextureBuildGpuTileInfos(uint64_t tiled_size, const std::vector<vk::BufferImageCopy>& regions,
-                              const TextureUploadLayout& layout, uint32_t levels,
-                              std::vector<GpuTileInfo>& infos);
+std::vector<vk::BufferImageCopy> TextureBuildImageCopies(const TextureUploadLayout& layout,
+                                                         uint32_t width, uint32_t height,
+                                                         uint32_t depth, uint64_t levels,
+                                                         bool array_texture, bool volume_texture);
+bool TextureBuildGpuTileInfos(uint64_t size, const std::vector<vk::BufferImageCopy>& regions,
+                              const TextureUploadLayout& layout, uint32_t fmt, uint32_t depth,
+                              uint64_t levels, std::vector<GpuTileInfo>& infos);
 
 } // namespace Libs::Graphics
 

src/graphics/host_gpu/renderer/pipeline/descriptorCache.cpp

@@ -0,0 +1,300 @@
+#include "graphics/host_gpu/renderer/pipeline/descriptorCache.h"
+
+#include "common/assert.h"
+#include "common/profiler.h"
+#include "graphics/shader/recompiler/ir/ShaderIR.h"
+
+#include <array>
+
+namespace Libs::Graphics {
+namespace {
+
+using BindingKind = ShaderRecompiler::IR::DescriptorBindingKind;
+
+vk::ShaderStageFlags StageFlags(DescriptorCache::Stage stage) {
+	switch (stage) {
+		case DescriptorCache::Stage::Vertex: return vk::ShaderStageFlagBits::eVertex;
+		case DescriptorCache::Stage::Pixel: return vk::ShaderStageFlagBits::eFragment;
+		case DescriptorCache::Stage::Compute: return vk::ShaderStageFlagBits::eCompute;
+		default: EXIT("unknown descriptor stage\n");
+	}
+}
+
+bool IsSampledImage(BindingKind kind) {
+	switch (kind) {
+		case BindingKind::Sampled1D:
+		case BindingKind::Sampled1DArray:
+		case BindingKind::Sampled2D:
+		case BindingKind::Sampled2DArray:
+		case BindingKind::Sampled2DMsaa:
+		case BindingKind::Sampled2DMsaaArray:
+		case BindingKind::Sampled3D:
+		case BindingKind::SampledUint1D:
+		case BindingKind::SampledUint1DArray:
+		case BindingKind::SampledUint2D:
+		case BindingKind::SampledUint2DArray:
+		case BindingKind::SampledUint2DMsaa:
+		case BindingKind::SampledUint2DMsaaArray:
+		case BindingKind::SampledUint3D: return true;
+		default: return false;
+	}
+}
+
+bool IsStorageImage(BindingKind kind) {
+	switch (kind) {
+		case BindingKind::Storage1D:
+		case BindingKind::Storage1DArray:
+		case BindingKind::Storage2D:
+		case BindingKind::Storage2DArray:
+		case BindingKind::Storage3D:
+		case BindingKind::StorageUint1D:
+		case BindingKind::StorageUint1DArray:
+		case BindingKind::StorageUint2D:
+		case BindingKind::StorageUint2DArray:
+		case BindingKind::StorageUint3D: return true;
+		default: return false;
+	}
+}
+
+vk::DescriptorType DescriptorType(BindingKind kind) {
+	if (kind == BindingKind::Samplers) {
+		return vk::DescriptorType::eSampler;
+	}
+	if (IsSampledImage(kind)) {
+		return vk::DescriptorType::eSampledImage;
+	}
+	if (IsStorageImage(kind)) {
+		return vk::DescriptorType::eStorageImage;
+	}
+	return vk::DescriptorType::eStorageBuffer;
+}
+
+uint32_t DescriptorCount(const ShaderRecompiler::IR::DescriptorBinding& binding) {
+	return binding.resources.empty() ? 1u : static_cast<uint32_t>(binding.resources.size());
+}
+
+std::vector<uint32_t> LayoutKey(DescriptorCache::Stage               stage,
+                                const ShaderRecompiler::IR::Program& program) {
+	std::vector<uint32_t> key;
+	key.reserve(1u + program.bindings.descriptors.size() * 4u);
+	key.push_back(static_cast<uint32_t>(stage));
+	for (const auto& binding: program.bindings.descriptors) {
+		key.push_back(static_cast<uint32_t>(binding.kind));
+		key.push_back(binding.binding);
+		key.push_back(DescriptorCount(binding));
+		key.push_back(static_cast<uint32_t>(DescriptorType(binding.kind)));
+	}
+	return key;
+}
+
+vk::DescriptorBufferInfo BufferInfo(const BufferView& view) {
+	EXIT_IF(view.buffer == nullptr);
+	return {view.buffer, view.offset, view.range};
+}
+
+} // namespace
+
+vk::DescriptorImageInfo DescriptorCache::MakeImageInfo(const TextureBinding& texture) {
+	EXIT_IF(!texture.image_id || texture.image_view == nullptr ||
+	        texture.layout == vk::ImageLayout::eUndefined);
+	return {nullptr, texture.image_view, texture.layout};
+}
+
+DescriptorCache::~DescriptorCache() {
+	for (auto& [layout, sets]: m_free_sets_by_layout) {
+		(void)layout;
+		for (auto* set: sets) {
+			delete set;
+		}
+	}
+	for (const auto& [key, layout]: m_descriptor_set_layouts) {
+		(void)key;
+		m_graphics.device.destroyDescriptorSetLayout(layout, nullptr);
+	}
+	for (const auto& pool: m_pools) {
+		m_graphics.device.destroyDescriptorPool(pool.pool, nullptr);
+	}
+}
+
+vk::DescriptorSetLayout
+DescriptorCache::GetDescriptorSetLayoutInternal(Stage                                stage,
+                                                const ShaderRecompiler::IR::Program& program) {
+	const auto key = LayoutKey(stage, program);
+	if (const auto found = m_descriptor_set_layouts.find(key);
+	    found != m_descriptor_set_layouts.end()) {
+		return found->second;
+	}
+
+	std::vector<vk::DescriptorSetLayoutBinding> bindings;
+	bindings.reserve(program.bindings.descriptors.size());
+	for (const auto& descriptor: program.bindings.descriptors) {
+		bindings.push_back({descriptor.binding, DescriptorType(descriptor.kind),
+		                    DescriptorCount(descriptor), StageFlags(stage), nullptr});
+	}
+	if (bindings.empty()) {
+		return nullptr;
+	}
+
+	vk::DescriptorSetLayoutCreateInfo info {};
+	info.sType                     = vk::StructureType::eDescriptorSetLayoutCreateInfo;
+	info.bindingCount              = static_cast<uint32_t>(bindings.size());
+	info.pBindings                 = bindings.data();
+	vk::DescriptorSetLayout layout = nullptr;
+	const auto result = m_graphics.device.createDescriptorSetLayout(&info, nullptr, &layout);
+	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess || layout == nullptr);
+	m_descriptor_set_layouts.emplace(key, layout);
+	return layout;
+}
+
+void DescriptorCache::CreatePool() {
+	KYTY_PROFILER_FUNCTION();
+	constexpr uint32_t           MaxSets = 512;
+	const vk::DescriptorPoolSize sizes[] = {
+	    {vk::DescriptorType::eStorageBuffer,
+	     MaxSets * (ShaderRecompiler::IR::ShaderInfo::MaxBuffers +
+	                ShaderRecompiler::IR::ShaderInfo::MaxAddresses + 3u)},
+	    {vk::DescriptorType::eSampledImage, MaxSets * ShaderRecompiler::IR::ShaderInfo::MaxImages},
+	    {vk::DescriptorType::eStorageImage, MaxSets * ShaderRecompiler::IR::ShaderInfo::MaxImages},
+	    {vk::DescriptorType::eSampler, MaxSets * ShaderRecompiler::IR::ShaderInfo::MaxSamplers},
+	};
+	vk::DescriptorPoolCreateInfo info {};
+	info.sType         = vk::StructureType::eDescriptorPoolCreateInfo;
+	info.poolSizeCount = static_cast<uint32_t>(std::size(sizes));
+	info.pPoolSizes    = sizes;
+	info.maxSets       = MaxSets;
+	const auto pool_id = static_cast<int>(m_pools.size());
+	auto&      pool    = m_pools.emplace_back();
+	const auto result  = m_graphics.device.createDescriptorPool(&info, nullptr, &pool.pool);
+	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess || pool.pool == nullptr);
+	pool.next_free_pool = m_first_free_pool;
+	m_first_free_pool   = pool_id;
+}
+
+VulkanDescriptorSet* DescriptorCache::Allocate(Stage                                stage,
+                                               const ShaderRecompiler::IR::Program& program) {
+	KYTY_PROFILER_FUNCTION();
+	Common::LockGuard lock(m_mutex);
+	const auto        layout = GetDescriptorSetLayoutInternal(stage, program);
+	EXIT_IF(layout == nullptr);
+	auto& free_sets = m_free_sets_by_layout[layout];
+	if (!free_sets.empty()) {
+		auto* result = free_sets.back();
+		free_sets.pop_back();
+		return result;
+	}
+
+	constexpr uint32_t Batch = 32;
+	for (int attempt = 0; attempt < 2; attempt++) {
+		for (int pool_id = m_first_free_pool; pool_id != -1;
+		     pool_id     = m_pools[pool_id].next_free_pool) {
+			auto&                                      pool = m_pools[pool_id];
+			std::array<vk::DescriptorSetLayout, Batch> layouts;
+			layouts.fill(layout);
+			std::array<vk::DescriptorSet, Batch> sets {};
+			vk::DescriptorSetAllocateInfo        info {};
+			info.sType              = vk::StructureType::eDescriptorSetAllocateInfo;
+			info.descriptorPool     = pool.pool;
+			info.descriptorSetCount = Batch;
+			info.pSetLayouts        = layouts.data();
+			if (m_graphics.device.allocateDescriptorSets(&info, sets.data()) ==
+			    vk::Result::eSuccess) {
+				free_sets.reserve(free_sets.size() + Batch - 1u);
+				for (uint32_t i = 0; i + 1u < Batch; i++) {
+					free_sets.push_back(new VulkanDescriptorSet {sets[i], layout, pool_id});
+				}
+				return new VulkanDescriptorSet {sets.back(), layout, pool_id};
+			}
+			m_first_free_pool = pool.next_free_pool;
+			break;
+		}
+		CreatePool();
+	}
+	return nullptr;
+}
+
+void DescriptorCache::Recycle(VulkanDescriptorSet& set) {
+	EXIT_IF(set.set == nullptr || set.layout == nullptr);
+	Common::LockGuard lock(m_mutex);
+	m_free_sets_by_layout[set.layout].push_back(&set);
+}
+
+VulkanDescriptorSet& DescriptorCache::GetDescriptor(Stage                                stage,
+                                                    const ShaderRecompiler::IR::Program& program,
+                                                    const NativeDescriptors&             data) {
+	KYTY_PROFILER_FUNCTION();
+	EXIT_IF(data.buffers.size() != program.info.buffers.size() ||
+	        data.images.size() != program.info.images.size() ||
+	        data.samplers.size() != program.info.samplers.size() ||
+	        data.addresses.size() != program.info.addresses.size());
+	auto* set = Allocate(stage, program);
+	EXIT_NOT_IMPLEMENTED(set == nullptr);
+
+	const auto descriptor_count = program.info.buffers.size() + program.info.images.size() +
+	                              program.info.samplers.size() + program.info.addresses.size() + 3u;
+	std::vector<vk::DescriptorBufferInfo> buffer_infos;
+	std::vector<vk::DescriptorImageInfo>  image_infos;
+	std::vector<vk::WriteDescriptorSet>   writes;
+	buffer_infos.reserve(descriptor_count);
+	image_infos.reserve(descriptor_count);
+	writes.reserve(program.bindings.descriptors.size());
+
+	for (const auto& binding: program.bindings.descriptors) {
+		vk::WriteDescriptorSet write {};
+		write.sType             = vk::StructureType::eWriteDescriptorSet;
+		write.dstSet            = set->set;
+		write.dstBinding        = binding.binding;
+		write.descriptorType    = DescriptorType(binding.kind);
+		write.descriptorCount   = DescriptorCount(binding);
+		const auto buffer_start = buffer_infos.size();
+		const auto image_start  = image_infos.size();
+		switch (binding.kind) {
+			case BindingKind::Buffers:
+				for (const auto resource: binding.resources) {
+					buffer_infos.push_back(BufferInfo(data.buffers.at(resource)));
+				}
+				break;
+			case BindingKind::AddressMemory:
+				for (const auto resource: binding.resources) {
+					buffer_infos.push_back(BufferInfo(data.addresses.at(resource)));
+				}
+				break;
+			case BindingKind::FlattenedSrt:
+				buffer_infos.push_back(BufferInfo(data.flattened_srt));
+				break;
+			case BindingKind::UserData: buffer_infos.push_back(BufferInfo(data.user_data)); break;
+			case BindingKind::Gds: buffer_infos.push_back(BufferInfo(data.gds)); break;
+			case BindingKind::Samplers:
+				for (const auto resource: binding.resources) {
+					const auto sampler = data.samplers.at(resource);
+					EXIT_IF(sampler == nullptr);
+					image_infos.push_back({sampler, nullptr, vk::ImageLayout::eUndefined});
+				}
+				break;
+			default: {
+				for (const auto resource: binding.resources) {
+					const auto& texture = data.images.at(resource);
+					image_infos.push_back(MakeImageInfo(texture));
+				}
+				break;
+			}
+		}
+		if (buffer_infos.size() != buffer_start) {
+			write.pBufferInfo = buffer_infos.data() + buffer_start;
+		}
+		if (image_infos.size() != image_start) {
+			write.pImageInfo = image_infos.data() + image_start;
+		}
+		writes.push_back(write);
+	}
+	m_graphics.device.updateDescriptorSets(static_cast<uint32_t>(writes.size()), writes.data(), 0,
+	                                       nullptr);
+	return *set;
+}
+
+vk::DescriptorSetLayout
+DescriptorCache::GetDescriptorSetLayout(Stage stage, const ShaderRecompiler::IR::Program& program) {
+	Common::LockGuard lock(m_mutex);
+	return GetDescriptorSetLayoutInternal(stage, program);
+}
+
+} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/pipeline/descriptorCache.h

@@ -0,0 +1,114 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DESCRIPTORCACHE_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DESCRIPTORCACHE_H_
+
+#include "common/abi.h"
+#include "common/assert.h"
+#include "common/common.h"
+#include "common/threads.h"
+#include "graphics/host_gpu/graphicContext.h"
+#include "graphics/host_gpu/renderer/cache/textureCache.h"
+#include "graphics/host_gpu/vulkanCommon.h"
+#include "graphics/shader/shaderBindings.h"
+
+#include <map>
+#include <memory>
+#include <span>
+#include <unordered_map>
+#include <vector>
+
+namespace Libs::Graphics {
+
+namespace ShaderRecompiler::IR {
+struct DescriptorValue;
+struct ImageResource;
+struct Program;
+struct ResourceSnapshot;
+} // namespace ShaderRecompiler::IR
+
+class CommandBuffer;
+struct DescriptorCacheTestAccess;
+struct ShaderStageRuntime;
+
+struct VulkanDescriptorSet {
+	vk::DescriptorSet       set     = nullptr;
+	vk::DescriptorSetLayout layout  = nullptr;
+	int                     pool_id = -1;
+};
+
+struct BufferView {
+	std::shared_ptr<void> owner;
+	vk::Buffer            buffer = nullptr;
+	vk::DeviceSize        offset = 0;
+	vk::DeviceSize        range  = VK_WHOLE_SIZE;
+};
+
+class DescriptorCache {
+public:
+	enum class Stage { Unknown, Vertex, Pixel, Compute };
+
+	struct TextureBinding {
+		ImageId                 image_id;
+		vk::ImageView           image_view = nullptr;
+		TextureCache::ImageDesc desc;
+		vk::ImageLayout         layout = vk::ImageLayout::eUndefined;
+	};
+
+	struct NativeDescriptors {
+		std::vector<BufferView>     buffers;
+		std::vector<TextureBinding> images;
+		std::vector<vk::Sampler>    samplers;
+		std::vector<BufferView>     addresses;
+		BufferView                  gds;
+		BufferView                  flattened_srt;
+		BufferView                  user_data;
+	};
+
+	struct PreparedBindings {
+		std::shared_ptr<const ShaderRecompiler::IR::Program>          program;
+		std::shared_ptr<const ShaderRecompiler::IR::ResourceSnapshot> snapshot;
+		NativeDescriptors                                             resources;
+		std::vector<uint32_t>                                         flattened_srt;
+		std::vector<uint32_t>                                         user_data;
+		vk::ShaderStageFlags                                          shader_stage;
+		Stage                                                         stage     = Stage::Unknown;
+		bool                                                          committed = false;
+	};
+
+	explicit DescriptorCache(GraphicContext& graphics): m_graphics(graphics) {
+		EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
+	}
+	~DescriptorCache();
+	KYTY_CLASS_NO_COPY(DescriptorCache);
+
+	vk::DescriptorSetLayout GetDescriptorSetLayout(Stage                                stage,
+	                                               const ShaderRecompiler::IR::Program& program);
+	void                    Recycle(VulkanDescriptorSet& set);
+	VulkanDescriptorSet&    GetDescriptor(Stage stage, const ShaderRecompiler::IR::Program& program,
+	                                      const NativeDescriptors& descriptors);
+
+private:
+	friend struct DescriptorCacheTestAccess;
+
+	struct Pool {
+		vk::DescriptorPool pool           = nullptr;
+		int                next_free_pool = -1;
+	};
+
+	static vk::DescriptorImageInfo MakeImageInfo(const TextureBinding& texture);
+	void                           CreatePool();
+	VulkanDescriptorSet* Allocate(Stage stage, const ShaderRecompiler::IR::Program& program);
+	vk::DescriptorSetLayout
+	GetDescriptorSetLayoutInternal(Stage stage, const ShaderRecompiler::IR::Program& program);
+
+	GraphicContext&   m_graphics;
+	Common::Mutex     m_mutex;
+	std::vector<Pool> m_pools;
+	int               m_first_free_pool = -1;
+	std::unordered_map<vk::DescriptorSetLayout, std::vector<VulkanDescriptorSet*>>
+	                                                         m_free_sets_by_layout;
+	std::map<std::vector<uint32_t>, vk::DescriptorSetLayout> m_descriptor_set_layouts;
+};
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DESCRIPTORCACHE_H_

src/graphics/host_gpu/renderer/pipeline/descriptorHeap.cpp

@@ -1,97 +0,0 @@
-#include "graphics/host_gpu/renderer/pipeline/descriptorHeap.h"
-
-#include "common/assert.h"
-#include "common/profiler.h"
-#include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/renderer/masterSemaphore.h"
-
-namespace Libs::Graphics {
-namespace {
-
-constexpr uint32_t   DescriptorHeapCount = 1024;
-constexpr std::array DescriptorPoolSizes = {
-    vk::DescriptorPoolSize {vk::DescriptorType::eStorageBuffer, 8192},
-    vk::DescriptorPoolSize {vk::DescriptorType::eSampledImage, 8192},
-    vk::DescriptorPoolSize {vk::DescriptorType::eStorageImage, 1024},
-    vk::DescriptorPoolSize {vk::DescriptorType::eSampler, 1024},
-};
-
-} // namespace
-
-DescriptorHeap::DescriptorHeap(GraphicContext& graphics, MasterSemaphore& master_semaphore)
-    : m_graphics(graphics), m_master_semaphore(master_semaphore) {
-	CreatePool();
-}
-
-DescriptorHeap::~DescriptorHeap() {
-	m_graphics.device.destroyDescriptorPool(m_current_pool, nullptr);
-	for (const auto& [pool, tick]: m_pending_pools) {
-		m_master_semaphore.Wait(tick);
-		m_graphics.device.destroyDescriptorPool(pool, nullptr);
-	}
-}
-
-vk::DescriptorSet DescriptorHeap::Commit(vk::DescriptorSetLayout layout) {
-	KYTY_PROFILER_FUNCTION();
-	EXIT_IF(layout == nullptr);
-
-	auto& batch = m_sets[layout];
-	if (batch.size != 0) {
-		return batch.sets[--batch.size];
-	}
-	if (Allocate(layout, batch)) {
-		return batch.sets[--batch.size];
-	}
-
-	m_pending_pools.emplace_back(m_current_pool, m_master_semaphore.CurrentTick());
-	if (const auto& [pool, tick] = m_pending_pools.front(); m_master_semaphore.IsFree(tick)) {
-		m_current_pool = pool;
-		m_pending_pools.pop_front();
-		EXIT_IF(m_graphics.device.resetDescriptorPool(m_current_pool, {}) != vk::Result::eSuccess);
-	} else {
-		CreatePool();
-	}
-
-	m_sets.clear();
-	auto& fresh_batch = m_sets[layout];
-	EXIT_IF(!Allocate(layout, fresh_batch));
-	return fresh_batch.sets[--fresh_batch.size];
-}
-
-bool DescriptorHeap::Allocate(vk::DescriptorSetLayout layout, Batch& batch) {
-	std::array<vk::DescriptorSetLayout, DescriptorSetBatch> layouts;
-	layouts.fill(layout);
-
-	vk::DescriptorSetAllocateInfo allocate {};
-	allocate.sType          = vk::StructureType::eDescriptorSetAllocateInfo;
-	allocate.descriptorPool = m_current_pool;
-	allocate.pSetLayouts    = layouts.data();
-
-	for (;;) {
-		allocate.descriptorSetCount = batch.allocation;
-		const auto result = m_graphics.device.allocateDescriptorSets(&allocate, batch.sets.data());
-		if (result == vk::Result::eSuccess) {
-			batch.size = batch.allocation;
-			return true;
-		}
-		EXIT_IF(result != vk::Result::eErrorOutOfPoolMemory &&
-		        result != vk::Result::eErrorFragmentedPool);
-		if (batch.allocation == 1) {
-			return false;
-		}
-		batch.allocation /= 2;
-	}
-}
-
-void DescriptorHeap::CreatePool() {
-	vk::DescriptorPoolCreateInfo create {};
-	create.sType         = vk::StructureType::eDescriptorPoolCreateInfo;
-	create.flags         = {};
-	create.maxSets       = DescriptorHeapCount;
-	create.poolSizeCount = static_cast<uint32_t>(DescriptorPoolSizes.size());
-	create.pPoolSizes    = DescriptorPoolSizes.data();
-	EXIT_IF(m_graphics.device.createDescriptorPool(&create, nullptr, &m_current_pool) !=
-	        vk::Result::eSuccess);
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/pipeline/descriptorHeap.h

@@ -1,45 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DESCRIPTORHEAP_H_
-#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DESCRIPTORHEAP_H_
-
-#include "common/common.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <array>
-#include <deque>
-#include <unordered_map>
-
-namespace Libs::Graphics {
-
-struct GraphicContext;
-class MasterSemaphore;
-
-class DescriptorHeap {
-public:
-	DescriptorHeap(GraphicContext& graphics, MasterSemaphore& master_semaphore);
-	~DescriptorHeap();
-	KYTY_CLASS_NO_COPY(DescriptorHeap);
-
-	[[nodiscard]] vk::DescriptorSet Commit(vk::DescriptorSetLayout layout);
-
-private:
-	static constexpr uint32_t DescriptorSetBatch = 32;
-
-	struct Batch {
-		std::array<vk::DescriptorSet, DescriptorSetBatch> sets {};
-		uint32_t                                          size       = 0;
-		uint32_t                                          allocation = DescriptorSetBatch;
-	};
-
-	[[nodiscard]] bool Allocate(vk::DescriptorSetLayout layout, Batch& batch);
-	void               CreatePool();
-
-	GraphicContext&                                     m_graphics;
-	MasterSemaphore&                                    m_master_semaphore;
-	vk::DescriptorPool                                  m_current_pool = nullptr;
-	std::deque<std::pair<vk::DescriptorPool, uint64_t>> m_pending_pools;
-	std::unordered_map<vk::DescriptorSetLayout, Batch>  m_sets;
-};
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DESCRIPTORHEAP_H_

src/graphics/host_gpu/renderer/pipeline/descriptors.h

@@ -2,8 +2,6 @@
 #define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DESCRIPTORS_H_
 
 #include "common/assert.h"
-#include "graphics/host_gpu/renderer/cache/bufferCache.h"
-#include "graphics/host_gpu/renderer/cache/textureCache.h"
 #include "graphics/host_gpu/renderer/image/image.h"
 #include "graphics/host_gpu/vulkanCommon.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
@@ -12,52 +10,9 @@
 #include <cstdint>
 #include <cstring>
 #include <type_traits>
-#include <vector>
 
 namespace Libs::Graphics {
 
-namespace ShaderRecompiler::IR {
-struct ResourceSnapshot;
-}
-
-struct BufferView {
-	vk::Buffer     buffer = nullptr;
-	vk::DeviceSize offset = 0;
-	vk::DeviceSize range  = VK_WHOLE_SIZE;
-};
-
-struct TextureBinding {
-	ImageId                    image_id;
-	vk::ImageView              image_view = nullptr;
-	TextureCache::ImageDesc    desc;
-	vk::ImageLayout            layout = vk::ImageLayout::eUndefined;
-	std::vector<vk::ImageView> mip_views;
-};
-
-struct NativeDescriptors {
-	std::vector<BufferView>     buffers;
-	std::vector<TextureBinding> images;
-	std::vector<vk::Sampler>    samplers;
-	BufferView                  gds;
-	BufferView                  flattened_srt;
-	BufferView                  shader_data;
-};
-
-struct PreparedBindings {
-	const ShaderRecompiler::IR::CompiledShaderInfo* program  = nullptr;
-	const ShaderRecompiler::IR::ResourceSnapshot* snapshot = nullptr;
-	NativeDescriptors                             resources;
-	std::vector<std::pair<ShaderBufferResource, BufferId>> buffer_sources;
-	std::vector<uint32_t>                         shader_data;
-};
-
-[[nodiscard]] vk::DescriptorType
-NativeDescriptorType(ShaderRecompiler::IR::DescriptorBindingKind kind);
-[[nodiscard]] uint32_t
-NativeDescriptorCount(const ShaderRecompiler::IR::DescriptorBinding& binding);
-[[nodiscard]] vk::DescriptorImageInfo MakeImageInfo(const TextureBinding& texture,
-                                                    uint32_t              element = 0);
-
 template <typename T>
 [[nodiscard]] T DecodeNativeDescriptor(const ShaderRecompiler::IR::DescriptorValue& value) {
 	static_assert(std::is_trivially_copyable_v<T>);
@@ -79,9 +34,9 @@ ResolveTargetTextureView(const ShaderRecompiler::IR::ImageResource& resource,
                          Prospero::ImageType type, uint32_t base_layer, uint32_t image_layers);
 
 [[nodiscard]] bool IsSupportedDepthTargetDescriptor(const ShaderTextureResource& descriptor,
-                                                    const Image& image, bool r128 = false);
+                                                    const Image&                 image);
 [[nodiscard]] bool IsSupportedDepthTextureEncoding(const ShaderTextureResource& descriptor,
-                                                   const Image& image, bool r128 = false);
+                                                   const Image&                 image);
 [[nodiscard]] bool
 IsSupportedSampledVideoOutView(const ShaderRecompiler::IR::ImageResource& resource,
                                const ShaderTextureResource& descriptor, const Image& image);

src/graphics/host_gpu/renderer/pipeline/pipelineCache.cpp

@@ -1,8 +1,6 @@
 #include "graphics/host_gpu/renderer/pipeline/pipelineCache.h"
 
 #include "common/assert.h"
-#include "common/emulatorConfig.h"
-#include "common/file.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
 #include "graphics/guest_gpu/hardwareContext.h"
@@ -12,68 +10,16 @@
 #include "graphics/host_gpu/renderer/image/imageView.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/shader/recompiler/ShaderRecompiler.h"
-#include "graphics/shader/shaderCompiler.h"
-#include "kernel/memory.h"
-#include "kytyGitVersion.h"
-#include "loader/systemContent.h"
 
-#include <algorithm>
 #include <atomic>
-#include <cctype>
-#include <cstdio>
 #include <cstring>
-#include <fmt/format.h>
-#include <limits>
 #include <span>
-#include <spirv-tools/libspirv.hpp>
-#include <string_view>
-#include <tuple>
 #include <utility>
-#include <vector>
-#include <xxhash.h>
 
 namespace Libs::Graphics {
 
 namespace {
 
-std::string DriverCacheSignature(const vk::PhysicalDeviceProperties& properties) {
-	constexpr char hex[] = "0123456789abcdef";
-	std::string    uuid(VK_UUID_SIZE * 2, '0');
-	for (size_t i = 0; i < VK_UUID_SIZE; i++) {
-		uuid[i * 2]     = hex[properties.pipelineCacheUUID[i] >> 4u];
-		uuid[i * 2 + 1] = hex[properties.pipelineCacheUUID[i] & 0xfu];
-	}
-	return fmt::format("KytyPC1:{}:{:08x}:{:08x}:{:08x}:{}\n", KYTY_GIT_REVISION,
-	                   properties.vendorID, properties.deviceID, properties.driverVersion, uuid);
-}
-
-std::string PipelineCacheTitleId() {
-	std::string title_id;
-	if ((!Loader::SystemContentParamSfoGetString("TITLE_ID", &title_id) || title_id.empty()) &&
-	    (!Loader::SystemContentParamSfoGetString("CONTENT_ID", &title_id) || title_id.empty())) {
-		return {};
-	}
-	if (!std::ranges::all_of(title_id, [](unsigned char c) {
-		    return std::isalnum(c) != 0 || c == '-' || c == '_';
-	    })) {
-		return {};
-	}
-	return title_id;
-}
-
-template <typename... Args>
-void PipelineCacheLog(fmt::format_string<Args...> format, Args&&... args) {
-	auto message = fmt::format(format, std::forward<Args>(args)...);
-	message += '\n';
-	if (Log::GetDirection() != Log::Direction::Console) {
-		std::fwrite(message.data(), 1, message.size(), stdout);
-		std::fflush(stdout);
-	}
-	Log::Write(message);
-	Log::Flush();
-}
-
 void NormalizeStaticParamsForDynamicState(PipelineStaticParameters& static_params) {
 	static_params.viewport_scale[0]  = 0.5f;
 	static_params.viewport_scale[1]  = 0.5f;
@@ -88,512 +34,18 @@ void NormalizeStaticParamsForDynamicState(PipelineStaticParameters& static_param
 	static_params.scissor_ltrb[3] = 1;
 }
 
-bool ReadShaderGuestMemory(void*, uint64_t address, uint32_t* value) {
-	return value != nullptr &&
-	       Libs::LibKernel::Memory::TryReadGpuCleanBacking(address, value, sizeof(*value));
-}
-
-void DumpShaderSpirv(const char* stage_name, uint64_t shader_hash,
-                     const std::vector<uint32_t>& spirv) {
-	if (!Config::GraphicsDebugDumpEnabled()) {
-		return;
-	}
-	static std::atomic_int id = 0;
-	const auto path = Config::GetShaderLogFolder() / fmt::format("{:04d}_new_shader_{}_{:016x}.spv",
-	                                                             id++, stage_name, shader_hash);
-	Common::File::CreateDirectories(path.parent_path());
-	Common::File file(path, Common::File::Mode::Write);
-	if (file.IsInvalid()) {
-		const auto path_text = Common::PathToString(path);
-		LOGF_COLOR(Log::Color::BrightRed, "Can't create file: %s\n", path_text.c_str());
-		return;
-	}
-	file.Write(spirv.data(), spirv.size() * sizeof(uint32_t));
-}
-
-void DumpShaderOriginal(const char* stage_name, uint64_t shader_hash,
-                        std::span<const uint32_t> code, const std::string& decoded_dump) {
-	if (!Config::GraphicsDebugDumpEnabled()) {
-		return;
-	}
-	EXIT_IF(code.empty());
-	static std::atomic_int id = 0;
-	const auto base = Config::GetShaderLogFolder() / "original" /
-	                  fmt::format("{:04d}_new_shader_{}_{:016x}", id++, stage_name, shader_hash);
-	Common::File::CreateDirectories(base.parent_path());
-	for (const auto& [suffix, data, size]: {
-	         std::tuple {".bin", static_cast<const void*>(code.data()), code.size_bytes()},
-	         std::tuple {".rdna2", static_cast<const void*>(decoded_dump.data()),
-	                     decoded_dump.size()},
-	     }) {
-		if (size == 0) {
-			continue;
-		}
-		auto path = base;
-		path += suffix;
-		Common::File file(path, Common::File::Mode::Write);
-		if (file.IsInvalid()) {
-			const auto path_text = Common::PathToString(path);
-			LOGF_COLOR(Log::Color::BrightRed, "Can't create file: %s\n", path_text.c_str());
-		} else {
-			file.Write(data, size);
-		}
-	}
-}
-
-bool ValidateShaderSpirv(const char* label, uint64_t shader_hash,
-                         const std::vector<uint32_t>& spirv) {
-	if (!Config::ShaderValidationEnabled()) {
-		return true;
-	}
-	spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_3);
-	std::string          messages;
-	tools.SetMessageConsumer([&messages](spv_message_level_t, const char*,
-	                                     const spv_position_t& position, const char* message) {
-		messages += fmt::format("{}: {} ({}) {}\n", static_cast<int>(position.line),
-		                        static_cast<int>(position.column), static_cast<int>(position.index),
-		                        message);
-	});
-	if (tools.Validate(spirv)) {
-		return true;
-	}
-	spvtools::SpirvTools disassembler(SPV_ENV_VULKAN_1_2);
-	std::string          text;
-	disassembler.Disassemble(spirv, &text,
-	                         static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER) |
-	                             static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) |
-	                             static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_COMMENT) |
-	                             static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_INDENT) |
-	                             static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_COLOR));
-	LOGF_COLOR(Log::Color::BrightRed, "%s SPIR-V validation failed hash=0x%016" PRIx64 ":\n%s",
-	           label, shader_hash, messages.c_str());
-	LOGF("%s\n", text.c_str());
-	return false;
-}
-
 } // namespace
 
-struct PipelineCache::ProgramCache {
-	struct ProgramKey {
-		ShaderType            stage           = ShaderType::Unknown;
-		uint64_t              hash            = 0;
-		uint32_t              user_data_count = 0;
-		uint32_t              code_size       = 0;
-		std::vector<uint32_t> static_state;
-
-		bool operator==(const ProgramKey&) const = default;
-	};
-
-	struct Permutation {
-		ShaderRecompiler::IR::ResourceSpecialization specialization;
-		ShaderRecompiler::IR::CompiledShaderInfo     program;
-		ShaderProgram                                handle;
-	};
-
-	struct SourceEntry {
-		explicit SourceEntry(ShaderRecompiler::IR::ResourcePlan plan)
-		    : resource_plan(std::move(plan)) {
-			permutations.reserve(8);
-		}
-
-		ShaderRecompiler::IR::ResourcePlan resource_plan;
-		std::vector<Permutation>           permutations;
-	};
-
-	struct ProgramKeyHash {
-		std::size_t operator()(const ProgramKey& key) const {
-			std::size_t hash = static_cast<std::size_t>(key.stage);
-			PipelineKeyHash::Mix(hash, static_cast<std::size_t>(key.hash));
-			if constexpr (sizeof(std::size_t) < sizeof(uint64_t)) {
-				PipelineKeyHash::Mix(hash, static_cast<std::size_t>(key.hash >> 32u));
-			}
-			PipelineKeyHash::Mix(hash, key.user_data_count);
-			PipelineKeyHash::Mix(hash, key.code_size);
-			PipelineKeyHash::Mix(hash, key.static_state.size());
-			// Bucket same-shape static variants by source. ProgramKey equality performs the one
-			// exact state comparison needed on a stable hit without hashing up to 429 words first.
-			return hash;
-		}
-	};
-
-	static constexpr std::size_t MaxStaticKeyWords = 13 + ShaderVertexInputInfo::RES_MAX * 13;
-
-	template <ShaderType Stage>
-	Permutation CompilePermutation(const ShaderParams&                          params,
-	                               const ShaderRecompiler::CompileOptions&      options,
-	                               ShaderRecompiler::TranslateResult            translated,
-	                               ShaderRecompiler::IR::ResourceSpecialization specialization,
-	                               uint32_t push_data_start_dword) {
-		constexpr const char* stage_name = [] {
-			if constexpr (Stage == ShaderType::Vertex) {
-				return "vs";
-			} else if constexpr (Stage == ShaderType::Pixel) {
-				return "ps";
-			} else {
-				static_assert(Stage == ShaderType::Compute);
-				return "cs";
-			}
-		}();
-		auto result = ShaderRecompiler::CompileProgram(std::move(translated), options,
-		                                               specialization, push_data_start_dword);
-		DumpShaderOriginal(stage_name, options.shader_hash, params.code, result.decoded_dump);
-		if (!ValidateShaderSpirv(options.dump_label, options.shader_hash, result.spirv)) {
-			DumpShaderSpirv(stage_name, options.shader_hash, result.spirv);
-			EXIT("%s failed hash=0x%016" PRIx64 ": SPIR-V validation failed\n", options.dump_label,
-			     options.shader_hash);
-		}
-		DumpShaderSpirv(stage_name, options.shader_hash, result.spirv);
-
-		vk::ShaderModuleCreateInfo create_info {};
-		create_info.sType       = vk::StructureType::eShaderModuleCreateInfo;
-		create_info.codeSize    = result.spirv.size() * sizeof(uint32_t);
-		create_info.pCode       = result.spirv.data();
-		vk::ShaderModule module = nullptr;
-		RequireVulkanSuccess(device.createShaderModule(&create_info, nullptr, &module),
-		                     "create recompiled shader module");
-		EXIT_IF(module == nullptr);
-		if (options.dump_ir) {
-			if (!options.early_dump) {
-				LOGF("%s decoded RDNA2:\n%s", options.dump_label, result.decoded_dump.c_str());
-				LOGF("%s IR:\n%s", options.dump_label, result.ir_dump.c_str());
-			}
-			LOGF("%s SPIR-V words=%" PRIu64 " wave_size=%u\n", options.dump_label,
-			     static_cast<uint64_t>(result.spirv.size()), options.wave_size);
-		}
-		return {
-		    .specialization = std::move(specialization),
-		    .program        = std::move(result.program).TakeCompiledInfo(),
-		    .handle         = {.id = ++next_shader_id, .module = module},
-		};
-	}
-
-	template <typename InputInfo>
-	ShaderProgram Get(const ShaderParams& params, InputInfo& input_info,
-	                  uint32_t& push_data_cursor) {
-		constexpr ShaderType stage = [] {
-			if constexpr (std::is_same_v<InputInfo, ShaderVertexInputInfo>) {
-				return ShaderType::Vertex;
-			} else if constexpr (std::is_same_v<InputInfo, ShaderPixelInputInfo>) {
-				return ShaderType::Pixel;
-			} else {
-				static_assert(std::is_same_v<InputInfo, ShaderComputeInputInfo>);
-				return ShaderType::Compute;
-			}
-		}();
-
-		lookup_key.stage           = stage;
-		lookup_key.hash            = params.hash;
-		lookup_key.user_data_count = static_cast<uint32_t>(params.user_data.size());
-		lookup_key.code_size       = static_cast<uint32_t>(params.code.size());
-		BuildStageStaticKey(input_info, lookup_key.static_state);
-		auto                                         entry = programs.find(lookup_key);
-		ShaderRecompiler::IR::ResourceSnapshot       resources;
-		ShaderRecompiler::IR::ResourceSpecialization specialization;
-		const ShaderRecompiler::IR::SrtRuntime       runtime {
-		    .user_data                  = params.user_data,
-		    .shader_base                = params.Base(),
-		    .read_specialization_memory = ReadShaderGuestMemory,
-		};
-		if (entry != programs.end()) {
-			EXIT_IF(!ShaderRecompiler::IR::MaterializeResources(
-			    entry->second.resource_plan, runtime, resources, specialization));
-			if (const auto permutation = std::ranges::find_if(
-			        entry->second.permutations, [&](const Permutation& candidate) {
-				        const auto& layout = candidate.program.bindings;
-				        return layout.push_data_start_dword ==
-				                   ShaderRecompiler::IR::PushData::StartFor(
-				                       push_data_cursor, layout.ShaderDataDwords()) &&
-				               candidate.specialization == specialization;
-			        });
-			    permutation != entry->second.permutations.end()) {
-				input_info.stage = {.program   = &permutation->program,
-				                    .resources = std::move(resources)};
-				permutation->program.bindings.AdvancePushData(push_data_cursor);
-				return permutation->handle;
-			}
-		}
-
-		ShaderStageInputInfo stage_input {};
-		if constexpr (std::is_same_v<InputInfo, ShaderVertexInputInfo>) {
-			stage_input.vertex = &input_info;
-		} else if constexpr (std::is_same_v<InputInfo, ShaderPixelInputInfo>) {
-			stage_input.pixel = &input_info;
-		} else {
-			stage_input.compute = &input_info;
-		}
-		constexpr const char* label = [] {
-			if constexpr (stage == ShaderType::Vertex) {
-				return "ShaderRecompiler VS";
-			} else if constexpr (stage == ShaderType::Pixel) {
-				return "ShaderRecompiler PS";
-			} else {
-				return "ShaderRecompiler CS";
-			}
-		}();
-		ShaderRecompiler::CompileOptions options;
-		options.stage       = stage;
-		options.shader_hash = params.hash;
-		options.user_data   = params.user_data;
-		options.dump_ir     = Config::GetShaderLogDirection() != Config::ShaderLogDirection::Silent;
-		options.early_dump  = options.dump_ir;
-		options.dump_label  = label;
-		options.input_info  = stage_input;
-		if constexpr (stage == ShaderType::Vertex) {
-			options.user_data_base = 8;
-			options.scratch_dwords = input_info.scratch_size_dwords;
-		} else if constexpr (stage == ShaderType::Pixel) {
-			options.scratch_dwords = input_info.scratch_size_dwords;
-		} else {
-			options.scratch_dwords = input_info.scratch_size_dwords;
-			options.wave_size      = input_info.wave_size;
-		}
-		auto translated = ShaderRecompiler::TranslateProgram(params.code, options);
-		if (entry == programs.end()) {
-			auto resource_plan = ShaderRecompiler::IR::ExtractResourcePlan(translated.program);
-			EXIT_IF(!ShaderRecompiler::IR::MaterializeResources(resource_plan, runtime, resources,
-			                                                    specialization));
-			entry = programs.try_emplace(lookup_key, std::move(resource_plan)).first;
-		}
-		entry->second.permutations.push_back(CompilePermutation<stage>(
-		    params, options, std::move(translated), std::move(specialization), push_data_cursor));
-		const auto& permutation = entry->second.permutations.back();
-		input_info.stage = {.program = &permutation.program, .resources = std::move(resources)};
-		permutation.program.bindings.AdvancePushData(push_data_cursor);
-
-		std::printf("Num compiled %u shaders\n", ++num_compiled);
-		return permutation.handle;
-	}
-
-	explicit ProgramCache(vk::Device device): device(device) {
-		lookup_key.static_state.reserve(MaxStaticKeyWords);
-	}
-	~ProgramCache() {
-		for (const auto& [key, entry]: programs) {
-			(void)key;
-			for (const auto& permutation: entry.permutations) {
-				device.destroyShaderModule(permutation.handle.module, nullptr);
-			}
-		}
-	}
-
-	std::unordered_map<ProgramKey, SourceEntry, ProgramKeyHash> programs;
-	ProgramKey                                                  lookup_key;
-	vk::Device                                                  device;
-	uint32_t                                                    num_compiled   = 0;
-	uint64_t                                                    next_shader_id = 0;
-};
-
-PipelineCache::PipelineCache(GraphicContext& graphics)
-    : m_graphics(graphics), m_program_cache(std::make_unique<ProgramCache>(graphics.device)) {
-	EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
-	InitializeDriverCache();
-}
-
 PipelineCache::~PipelineCache() {
-	Save();
 	auto destroy = [this](const auto& pipelines) {
 		for (const auto& [key, pipeline]: pipelines) {
 			(void)key;
 			m_graphics.device.destroyPipeline(pipeline->pipeline, nullptr);
 			m_graphics.device.destroyPipelineLayout(pipeline->pipeline_layout, nullptr);
-			m_graphics.device.destroyDescriptorSetLayout(pipeline->descriptor_set_layout, nullptr);
 		}
 	};
 	destroy(m_graphics_pipelines);
 	destroy(m_compute_pipelines);
-	if (m_driver_cache != nullptr) {
-		m_graphics.device.destroyPipelineCache(m_driver_cache, nullptr);
-	}
-}
-
-void PipelineCache::InitializeDriverCache() {
-	const auto title_id = PipelineCacheTitleId();
-	if (title_id.empty()) {
-		return;
-	}
-	if (KYTY_BUILD != KYTY_BUILD_RELEASE) {
-		PipelineCacheLog("Vulkan pipeline cache: disabled (non-Release build)");
-		return;
-	}
-	const std::string_view git_hash     = KYTY_GIT_HASH;
-	const std::string_view git_revision = KYTY_GIT_REVISION;
-	if (git_hash == "unknown" || git_revision == "unknown") {
-		PipelineCacheLog("Vulkan pipeline cache: disabled (unknown git revision)");
-		return;
-	}
-	if (git_hash.ends_with("-dirty")) {
-		PipelineCacheLog("Vulkan pipeline cache: disabled (dirty build)");
-		return;
-	}
-
-	m_driver_cache_path     = std::filesystem::path("_PipelineCache") / (title_id + ".bin");
-	const auto path         = Common::PathToString(m_driver_cache_path);
-	const bool cache_exists = Common::File::IsFileExisting(m_driver_cache_path);
-	if (cache_exists) {
-		PipelineCacheLog("Vulkan pipeline cache: loading {}", path);
-	} else {
-		PipelineCacheLog("Vulkan pipeline cache: initializing {}", path);
-	}
-	std::vector<uint8_t> initial_data;
-	if (cache_exists) {
-		Common::File file(m_driver_cache_path, Common::File::Mode::Read);
-		const auto   file_size = file.IsInvalid() ? 0 : file.Size();
-		const auto   signature = DriverCacheSignature(m_graphics.GetPhysicalDeviceProperties());
-		if (file_size >= signature.size() + sizeof(uint64_t) &&
-		    file_size <= std::numeric_limits<uint32_t>::max()) {
-			std::string cached_signature(signature.size(), '\0');
-			uint64_t    payload_hash = 0;
-			initial_data.resize(file_size - signature.size() - sizeof(payload_hash));
-			uint32_t signature_read = 0;
-			uint32_t hash_read      = 0;
-			uint32_t payload_read   = 0;
-			file.Read(cached_signature.data(), static_cast<uint32_t>(cached_signature.size()),
-			          &signature_read);
-			file.Read(&payload_hash, sizeof(payload_hash), &hash_read);
-			file.Read(initial_data.data(), static_cast<uint32_t>(initial_data.size()),
-			          &payload_read);
-			file.Close();
-			if (signature_read != cached_signature.size() || hash_read != sizeof(payload_hash) ||
-			    payload_read != initial_data.size() || cached_signature != signature ||
-			    XXH3_64bits(initial_data.data(), initial_data.size()) != payload_hash) {
-				initial_data.clear();
-				PipelineCacheLog(
-				    "Vulkan pipeline cache: invalidating {} (driver, emulator, or data mismatch)",
-				    path);
-			}
-		} else {
-			file.Close();
-			PipelineCacheLog("Vulkan pipeline cache: invalidating {} (invalid file size)", path);
-		}
-	}
-
-	vk::PipelineCacheCreateInfo create {};
-	create.sType           = vk::StructureType::ePipelineCacheCreateInfo;
-	create.initialDataSize = initial_data.size();
-	create.pInitialData    = initial_data.empty() ? nullptr : initial_data.data();
-	auto result = m_graphics.device.createPipelineCache(&create, nullptr, &m_driver_cache);
-	if (result != vk::Result::eSuccess && !initial_data.empty()) {
-		PipelineCacheLog("Vulkan pipeline cache: driver rejected {} ({}); starting empty", path,
-		                 VulkanToString(result));
-		initial_data.clear();
-		create.initialDataSize = 0;
-		create.pInitialData    = nullptr;
-		result = m_graphics.device.createPipelineCache(&create, nullptr, &m_driver_cache);
-	}
-	if (result != vk::Result::eSuccess) {
-		PipelineCacheLog("Vulkan pipeline cache: disabled ({})", VulkanToString(result));
-		m_driver_cache = nullptr;
-		return;
-	}
-	if (!initial_data.empty()) {
-		PipelineCacheLog("Vulkan pipeline cache: loaded {} bytes from {}", initial_data.size(),
-		                 path);
-	} else {
-		PipelineCacheLog("Vulkan pipeline cache: initialized empty");
-	}
-}
-
-void PipelineCache::Save() {
-	Common::LockGuard lock(m_mutex);
-	if (m_driver_cache == nullptr) {
-		return;
-	}
-
-	size_t               size = 0;
-	vk::Result           result;
-	std::vector<uint8_t> payload;
-	for (uint32_t attempt = 0; attempt < 3; attempt++) {
-		size   = 0;
-		result = m_graphics.device.getPipelineCacheData(m_driver_cache, &size, nullptr);
-		if (result != vk::Result::eSuccess || size == 0 ||
-		    size > std::numeric_limits<uint32_t>::max()) {
-			break;
-		}
-		payload.resize(size);
-		result = m_graphics.device.getPipelineCacheData(m_driver_cache, &size, payload.data());
-		if (result != vk::Result::eIncomplete) {
-			break;
-		}
-	}
-	if (result != vk::Result::eSuccess || size == 0 ||
-	    size > std::numeric_limits<uint32_t>::max()) {
-		PipelineCacheLog("Vulkan pipeline cache: save failed ({}, {} bytes)",
-		                 VulkanToString(result), size);
-		return;
-	}
-	payload.resize(size);
-	auto       prefix       = DriverCacheSignature(m_graphics.GetPhysicalDeviceProperties());
-	const auto payload_hash = XXH3_64bits(payload.data(), payload.size());
-	prefix.append(reinterpret_cast<const char*>(&payload_hash), sizeof(payload_hash));
-	if (!Common::File::CreateDirectories(m_driver_cache_path.parent_path())) {
-		PipelineCacheLog("Vulkan pipeline cache: failed to create cache directory");
-		return;
-	}
-	auto temp_path = m_driver_cache_path;
-	temp_path += ".tmp";
-	Common::File file;
-	uint32_t     prefix_written  = 0;
-	uint32_t     payload_written = 0;
-	if (file.Create(temp_path)) {
-		file.Write(prefix.data(), static_cast<uint32_t>(prefix.size()), &prefix_written);
-		file.Write(payload.data(), static_cast<uint32_t>(payload.size()), &payload_written);
-	}
-	const bool flushed = !file.IsInvalid() && file.Flush();
-	file.Close();
-	if (prefix_written != prefix.size() || payload_written != payload.size() || !flushed ||
-	    !Common::File::RenameFile(temp_path, m_driver_cache_path)) {
-		PipelineCacheLog("Vulkan pipeline cache: failed to write {}",
-		                 Common::PathToString(m_driver_cache_path));
-		return;
-	}
-	PipelineCacheLog("Vulkan pipeline cache: saved {} bytes to {}", payload.size(),
-	                 Common::PathToString(m_driver_cache_path));
-	m_graphics.device.destroyPipelineCache(m_driver_cache, nullptr);
-	m_driver_cache = nullptr;
-}
-
-PipelineCache::GraphicsPrograms PipelineCache::GetGraphicsPrograms(
-    const HW::VertexShaderInfo& vertex_regs, const HW::PixelShaderInfo& pixel_regs,
-    const HW::ShaderRegisters& sh, const HW::Context& context,
-    std::span<const Prospero::ColorComponentMapping, 8> target_export_mapping,
-    bool pixel_active, ShaderVertexInputInfo& vertex_info, ShaderPixelInputInfo& pixel_info) {
-	const auto vertex_params = PrepareProgram(vertex_regs, sh, vertex_info);
-	ShaderParams pixel_params;
-	if (pixel_active) {
-		pixel_params = PrepareProgram(pixel_regs, sh, target_export_mapping, pixel_info);
-	}
-	if (context.GetClipControl().clip_disable) {
-		const auto& viewport = context.GetScreenViewport().viewports[0];
-		const auto& limits   = m_graphics.GetPhysicalDeviceProperties().limits;
-		auto&       clip     = vertex_info.clip_space;
-		clip.scale[0]        = viewport.xscale;
-		clip.scale[1]        = viewport.yscale;
-		clip.offset[0]       = viewport.xoffset;
-		clip.offset[1]       = viewport.yoffset;
-		clip.half_extent[0] =
-		    static_cast<float>(std::min(limits.maxViewportDimensions[0], 16384u)) * 0.5f;
-		clip.half_extent[1] =
-		    static_cast<float>(std::min(limits.maxViewportDimensions[1], 16384u)) * 0.5f;
-		clip.enabled = true;
-	}
-	Common::LockGuard lock(m_mutex);
-	uint32_t          push_data_cursor = 0;
-	GraphicsPrograms  result;
-	if (pixel_active) {
-		result.pixel = m_program_cache->Get(pixel_params, pixel_info, push_data_cursor);
-	}
-	result.vertex = m_program_cache->Get(vertex_params, vertex_info, push_data_cursor);
-	return result;
-}
-
-ShaderProgram PipelineCache::GetComputeProgram(const HW::ComputeShaderInfo& regs,
-                                               const HW::ShaderRegisters&   sh,
-                                               ShaderComputeInputInfo&      input_info) {
-	input_info.needs_lds_barriers = !m_graphics.compute_wave64_supported;
-	const auto        params      = PrepareProgram(regs, sh, input_info);
-	Common::LockGuard lock(m_mutex);
-	uint32_t          push_data_cursor = 0;
-	return m_program_cache->Get(params, input_info, push_data_cursor);
 }
 
 bool PipelineStaticParameters::operator==(const PipelineStaticParameters& other) const noexcept {
@@ -601,23 +53,25 @@ bool PipelineStaticParameters::operator==(const PipelineStaticParameters& other)
 }
 
 PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
-    std::span<const RenderColorInfo> colors, const RenderDepthInfo& depth,
-    const ShaderVertexInputInfo& vs_input_info, CommandBuffer& command,
-    const ShaderPixelInputInfo* ps_input_info, vk::PrimitiveTopology topology,
-    bool primitive_restart_enable, const ShaderProgram& vertex_program,
-    const ShaderProgram& pixel_program) {
+    RenderColorInfo* colors, uint32_t color_count, RenderDepthInfo& depth,
+    ShaderVertexInputInfo& vs_input_info, RenderCommandBuffer& command,
+    ShaderPixelInputInfo* ps_input_info, vk::PrimitiveTopology topology, bool ps_active,
+    std::span<const uint32_t> vs_spirv, std::span<const uint32_t> ps_spirv) {
 	KYTY_PROFILER_BLOCK("PipelineCache::CreatePipeline(Gfx)", profiler::colors::DeepOrangeA200);
 
-	EXIT_IF(colors.size() > RENDER_COLOR_ATTACHMENTS_MAX);
-	EXIT_IF(!vertex_program);
-	const bool ps_active = ps_input_info != nullptr;
-	EXIT_IF(ps_active && !pixel_program);
-	const auto color_count = static_cast<uint32_t>(colors.size());
+	EXIT_IF(colors == nullptr);
+	EXIT_IF(color_count > RENDER_COLOR_ATTACHMENTS_MAX);
+	EXIT_IF(vs_spirv.empty());
+	EXIT_IF(ps_active && ps_spirv.empty());
 
 	Common::LockGuard lock(m_mutex);
-	auto&             ctx = command.GetRegisters();
+	auto&             ctx    = command.GetRegisters();
+	auto&             sh_ctx = command.GetShaders();
 
-	uint32_t color_mask[RENDER_COLOR_ATTACHMENTS_MAX] = {};
+	const auto&           vertex_info                              = sh_ctx.GetVs();
+	const auto&           ps_regs                                  = sh_ctx.GetPs();
+	const HW::BlendColor& bclr                                     = ctx.GetBlendColor();
+	uint32_t              color_mask[RENDER_COLOR_ATTACHMENTS_MAX] = {};
 	for (uint32_t i = 0; i < color_count; i++) {
 		color_mask[i] =
 		    (colors[i].image_id ? colors[i].export_mapping.ApplyMask(render_target_mask_slot(
@@ -626,8 +80,11 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 	}
 	const HW::ModeControl& mc = ctx.GetModeControl();
 
-	const auto vs_id = vertex_program.id;
-	const auto ps_id = ps_active ? pixel_program.id : 0;
+	auto     vs_id = ShaderGetIdVS(vertex_info, vs_input_info, true);
+	ShaderId ps_id {};
+	if (ps_active) {
+		ps_id = ShaderGetIdPS(ps_regs, *ps_input_info, true);
+	}
 
 	PipelineStaticParameters static_params {};
 	GraphicsPipeline         p {};
@@ -663,12 +120,6 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 			     depth.samples);
 		}
 	}
-	if (color_count == 0 && !with_depth) {
-		attachment_samples = render_sample_count(ctx.GetAaConfig().msaa_num_samples);
-		EXIT_IF(!static_cast<bool>(
-		    m_graphics.GetPhysicalDeviceProperties().limits.framebufferNoAttachmentsSampleCounts &
-		    vulkan_sample_count(attachment_samples)));
-	}
 	EXIT_IF(attachment_samples == 0 ||
 	        vulkan_sample_count(attachment_samples) == vk::SampleCountFlagBits {});
 
@@ -679,12 +130,12 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 		}
 	}
 
-	const auto& clip_control               = ctx.GetClipControl();
-	static_params.negative_one_to_one      = !clip_control.dx_clip_space;
-	static_params.depth_clip_enable        = clip_control.IsZClipEnabled();
-	static_params.topology                 = topology;
-	static_params.primitive_restart_enable = primitive_restart_enable;
-	static_params.samples                  = attachment_samples;
+	const auto& clip_control = ctx.GetClipControl();
+	EXIT_NOT_IMPLEMENTED(!clip_control.IsZClipModeRepresentable());
+	static_params.negative_one_to_one = !clip_control.dx_clip_space;
+	static_params.depth_clip_enable   = clip_control.IsZClipEnabled();
+	static_params.topology            = topology;
+	static_params.samples             = attachment_samples;
 	static_params.sample_shading_enable =
 	    ps_active && attachment_samples > 1 && ps_input_info->ps_sample_shading;
 	if (static_params.sample_shading_enable && !m_graphics.sample_rate_shading_enabled) {
@@ -703,9 +154,8 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 	for (uint32_t i = 0; i < RENDER_COLOR_ATTACHMENTS_MAX; i++) {
 		static_params.color_mask[i] = color_mask[i];
 	}
-	const bool rect_list     = topology == vk::PrimitiveTopology::ePatchList;
-	static_params.cull_back  = !rect_list && mc.cull_back;
-	static_params.cull_front = !rect_list && mc.cull_front;
+	static_params.cull_back  = mc.cull_back;
+	static_params.cull_front = mc.cull_front;
 	static_params.face       = mc.face;
 
 	for (uint32_t i = 0; i < color_count; i++) {
@@ -721,6 +171,11 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 		static_params.blend_enable[i]         = bc.enable;
 		static_params.blend_bypass[i]         = rt.info.blend_bypass;
 	}
+	static_params.blend_color_red   = bclr.red;
+	static_params.blend_color_green = bclr.green;
+	static_params.blend_color_blue  = bclr.blue;
+	static_params.blend_color_alpha = bclr.alpha;
+
 	NormalizeStaticParamsForDynamicState(static_params);
 
 	GraphicsPipelineKey key {};
@@ -728,30 +183,6 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 	key.vs_shader_id  = p.vs_shader_id;
 	key.ps_shader_id  = p.ps_shader_id;
 	key.static_params = static_params;
-	EXIT_IF(vs_input_info.buffers_num < 0 ||
-	        vs_input_info.buffers_num > ShaderVertexInputInfo::RES_MAX ||
-	        vs_input_info.resources_num < 0 ||
-	        vs_input_info.resources_num > ShaderVertexInputInfo::RES_MAX);
-	key.vertex_input.binding_count   = static_cast<uint8_t>(vs_input_info.buffers_num);
-	key.vertex_input.attribute_count = static_cast<uint8_t>(vs_input_info.resources_num);
-	uint32_t attributes_num          = 0;
-	for (int binding = 0; binding < vs_input_info.buffers_num; binding++) {
-		const auto& buffer = vs_input_info.buffers[binding];
-		EXIT_IF(buffer.attr_num < 0 || buffer.attr_num > ShaderVertexInputBuffer::ATTR_MAX);
-		attributes_num += static_cast<uint32_t>(buffer.attr_num);
-		EXIT_IF(attributes_num > static_cast<uint32_t>(vs_input_info.resources_num));
-		key.vertex_input.bindings[binding] = {.stride   = buffer.stride,
-		                                      .instance = buffer.fetch_index != 0};
-		for (int attribute = 0; attribute < buffer.attr_num; attribute++) {
-			const auto index = buffer.attr_indices[attribute];
-			EXIT_IF(index < 0 || index >= vs_input_info.resources_num);
-			key.vertex_input.attributes[index] = {
-			    .offset  = buffer.attr_offsets[attribute],
-			    .binding = static_cast<uint8_t>(binding),
-			};
-		}
-	}
-	EXIT_IF(attributes_num != static_cast<uint32_t>(vs_input_info.resources_num));
 
 	if (auto iter = m_graphics_pipelines.find(key); iter != m_graphics_pipelines.end()) {
 		return *iter->second;
@@ -762,17 +193,20 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 		if (ps_active) {
 			ShaderDbgDumpInputInfo(*ps_input_info);
 		}
-		LOGF("PipelineTrace: shader modules VS=%" PRIu64 " module=%p PS=%" PRIu64 " module=%p\n",
-		     vs_id, static_cast<void*>(vertex_program.module), ps_id,
-		     static_cast<void*>(pixel_program.module));
+		LOGF("PipelineTrace: shader binaries VS=0x%08" PRIx32 "/0x%08" PRIx32 " words=%" PRIu64
+		     " PS=0x%08" PRIx32 "/0x%08" PRIx32 " words=%" PRIu64 "\n",
+		     vs_id.hash0, vs_id.crc32, static_cast<uint64_t>(vs_spirv.size()), ps_id.hash0,
+		     ps_id.crc32, static_cast<uint64_t>(ps_spirv.size()));
 	}
 
 	auto cached = std::make_unique<GraphicsPipeline>(p);
-	LogPipelineTrace("CreatePipelineInternal begin", vs_id, ps_id);
-	CreatePipelineInternal(m_graphics, *cached, rendering, key.vertex_input, vs_input_info,
-	                       vertex_program.module, ps_input_info, pixel_program.module,
-	                       static_params, m_driver_cache);
-	LogPipelineTrace("CreatePipelineInternal done", vs_id, ps_id);
+	LogPipelineTrace("CreatePipelineInternal begin", vs_id.hash0, vs_id.crc32, ps_id.hash0,
+	                 ps_id.crc32);
+	CreatePipelineInternal(m_graphics, m_descriptor_cache, *cached, rendering, vs_input_info,
+	                       vs_spirv, ps_input_info, ps_spirv, static_params, vs_id.hash0,
+	                       vs_id.crc32, ps_id.hash0, ps_id.crc32, ps_active);
+	LogPipelineTrace("CreatePipelineInternal done", vs_id.hash0, vs_id.crc32, ps_id.hash0,
+	                 ps_id.crc32);
 
 	EXIT_NOT_IMPLEMENTED(cached->pipeline == nullptr);
 	EXIT_NOT_IMPLEMENTED(cached->pipeline_layout == nullptr);
@@ -784,16 +218,19 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 }
 
 PipelineCache::ComputePipeline&
-PipelineCache::CreateComputePipeline(ShaderComputeInputInfo& input_info,
-                                     const ShaderProgram&    compute_program) {
+PipelineCache::CreateComputePipeline(ShaderComputeInputInfo&      input_info,
+                                     const HW::ComputeShaderInfo& cs_regs,
+                                     std::span<const uint32_t>    cs_spirv) {
 	KYTY_PROFILER_BLOCK("PipelineCache::CreatePipeline(Compute)", profiler::colors::RedA100);
 
-	EXIT_IF(!compute_program);
+	EXIT_IF(cs_spirv.empty());
 
 	Common::LockGuard lock(m_mutex);
 
+	auto cs_id = ShaderGetIdCS(cs_regs, input_info, true);
+
 	ComputePipeline p {};
-	p.cs_shader_id = compute_program.id;
+	p.cs_shader_id = cs_id;
 
 	ComputePipelineKey key {};
 	key.cs_shader_id = p.cs_shader_id;
@@ -807,7 +244,7 @@ PipelineCache::CreateComputePipeline(ShaderComputeInputInfo& input_info,
 	}
 
 	auto cached = std::make_unique<ComputePipeline>(p);
-	CreatePipelineInternal(m_graphics, *cached, input_info, compute_program.module, m_driver_cache);
+	CreatePipelineInternal(m_graphics, m_descriptor_cache, *cached, input_info, cs_spirv);
 
 	EXIT_NOT_IMPLEMENTED(cached->pipeline == nullptr);
 	EXIT_NOT_IMPLEMENTED(cached->pipeline_layout == nullptr);

src/graphics/host_gpu/renderer/pipeline/pipelineCache.h

@@ -10,7 +10,6 @@
 #include "graphics/shader/shader.h"
 
 #include <cstddef>
-#include <filesystem>
 #include <memory>
 #include <span>
 #include <type_traits>
@@ -21,7 +20,8 @@ namespace Libs::Graphics {
 struct GraphicContext;
 struct RenderColorInfo;
 struct RenderDepthInfo;
-class CommandBuffer;
+class RenderCommandBuffer;
+class DescriptorCache;
 
 namespace HW {
 class Context;
@@ -38,7 +38,6 @@ struct PipelineStaticParameters {
 	bool                       depth_clip_enable        = true;
 	int                        scissor_ltrb[4]          = {0};
 	vk::PrimitiveTopology      topology                 = vk::PrimitiveTopology::ePointList;
-	bool                       primitive_restart_enable = false;
 	uint32_t                   samples                  = 1;
 	bool                       sample_shading_enable    = false;
 	bool                       with_depth               = false;
@@ -65,6 +64,10 @@ struct PipelineStaticParameters {
 	bool                       separate_alpha_blend[RENDER_COLOR_ATTACHMENTS_MAX] = {};
 	bool                       blend_enable[RENDER_COLOR_ATTACHMENTS_MAX]         = {};
 	bool                       blend_bypass[RENDER_COLOR_ATTACHMENTS_MAX]         = {};
+	float                      blend_color_red                                    = 0.0f;
+	float                      blend_color_green                                  = 0.0f;
+	float                      blend_color_blue                                   = 0.0f;
+	float                      blend_color_alpha                                  = 0.0f;
 
 	bool operator==(const PipelineStaticParameters& other) const noexcept;
 };
@@ -76,12 +79,12 @@ static_assert(std::is_standard_layout_v<PipelineStaticParameters>);
 static_assert(alignof(PipelineStaticParameters) == 1);
 static_assert(sizeof(PipelineStaticParameters) ==
               sizeof(float[3]) + sizeof(float[3]) + sizeof(bool) * 2 + sizeof(int[4]) +
-                  sizeof(vk::PrimitiveTopology) + sizeof(bool) + sizeof(uint32_t) +
-                  sizeof(bool) * 4 + sizeof(vk::CompareOp) + sizeof(bool) + sizeof(float) * 2 +
-                  sizeof(bool) + sizeof(PipelineStencilStaticState) * 2 + sizeof(uint32_t) +
+                  sizeof(vk::PrimitiveTopology) + sizeof(uint32_t) + sizeof(bool) * 4 +
+                  sizeof(vk::CompareOp) + sizeof(bool) + sizeof(float) * 2 + sizeof(bool) +
+                  sizeof(PipelineStencilStaticState) * 2 + sizeof(uint32_t) +
                   sizeof(uint32_t[RENDER_COLOR_ATTACHMENTS_MAX]) + sizeof(bool) * 3 +
                   sizeof(uint8_t[RENDER_COLOR_ATTACHMENTS_MAX]) * 6 +
-                  sizeof(bool[RENDER_COLOR_ATTACHMENTS_MAX]) * 3);
+                  sizeof(bool[RENDER_COLOR_ATTACHMENTS_MAX]) * 3 + sizeof(float) * 4);
 
 struct PipelineRenderingState {
 	std::array<vk::Format, RENDER_COLOR_ATTACHMENTS_MAX> color_formats {};
@@ -92,98 +95,54 @@ struct PipelineRenderingState {
 	bool operator==(const PipelineRenderingState&) const = default;
 };
 
-struct PipelineVertexInputState {
-	struct Binding {
-		uint32_t stride                           = 0;
-		bool     instance                         = false;
-		bool     operator==(const Binding&) const = default;
-	};
-	struct Attribute {
-		uint32_t offset                             = 0;
-		uint8_t  binding                            = 0;
-		bool     operator==(const Attribute&) const = default;
-	};
-
-	std::array<Binding, ShaderVertexInputInfo::RES_MAX>   bindings {};
-	std::array<Attribute, ShaderVertexInputInfo::RES_MAX> attributes {};
-	uint8_t                                               binding_count   = 0;
-	uint8_t                                               attribute_count = 0;
-
-	bool operator==(const PipelineVertexInputState&) const = default;
-};
-
-struct ShaderProgram {
-	uint64_t         id     = 0;
-	vk::ShaderModule module = nullptr;
-
-	explicit operator bool() const { return id != 0 && module != nullptr; }
-};
-
 class PipelineCache {
 public:
-	explicit PipelineCache(GraphicContext& graphics);
+	PipelineCache(GraphicContext& graphics, DescriptorCache& descriptor_cache)
+	    : m_graphics(graphics), m_descriptor_cache(descriptor_cache) {
+		EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
+	}
 	~PipelineCache();
 	KYTY_CLASS_NO_COPY(PipelineCache);
-	void Save();
 
 	struct Pipeline {
-		vk::PipelineLayout      pipeline_layout       = nullptr;
-		vk::Pipeline            pipeline              = nullptr;
-		vk::DescriptorSetLayout descriptor_set_layout = nullptr;
-		bool                    uses_push_descriptors = false;
+		vk::PipelineLayout pipeline_layout = nullptr;
+		vk::Pipeline       pipeline        = nullptr;
 	};
 
 	struct GraphicsPipeline: Pipeline {
-		uint64_t vs_shader_id = 0;
-		uint64_t ps_shader_id = 0;
+		ShaderId vs_shader_id;
+		ShaderId ps_shader_id;
 	};
 
 	struct ComputePipeline: Pipeline {
-		uint64_t cs_shader_id = 0;
+		ShaderId cs_shader_id;
 	};
 
-	struct GraphicsPrograms {
-		ShaderProgram vertex;
-		ShaderProgram pixel;
-	};
-
-	GraphicsPrograms GetGraphicsPrograms(
-	    const HW::VertexShaderInfo& vertex_regs, const HW::PixelShaderInfo& pixel_regs,
-	    const HW::ShaderRegisters& sh, const HW::Context& context,
-	    std::span<const Prospero::ColorComponentMapping, 8> target_export_mapping,
-	    bool pixel_active, ShaderVertexInputInfo& vertex_info, ShaderPixelInputInfo& pixel_info);
-	ShaderProgram GetComputeProgram(const HW::ComputeShaderInfo& regs,
-	                                const HW::ShaderRegisters&   sh,
-	                                ShaderComputeInputInfo&      input_info);
-
 	GraphicsPipeline&
-	CreateGraphicsPipeline(std::span<const RenderColorInfo> colors, const RenderDepthInfo& depth,
-	                       const ShaderVertexInputInfo& vs_input_info, CommandBuffer& command,
-	                       const ShaderPixelInputInfo* ps_input_info,
-	                       vk::PrimitiveTopology topology, bool primitive_restart_enable,
-	                       const ShaderProgram& vertex_program, const ShaderProgram& pixel_program);
-	ComputePipeline& CreateComputePipeline(ShaderComputeInputInfo& input_info,
-	                                       const ShaderProgram&    compute_program);
+	CreateGraphicsPipeline(RenderColorInfo* colors, uint32_t color_count, RenderDepthInfo& depth,
+	                       ShaderVertexInputInfo& vs_input_info, RenderCommandBuffer& command,
+	                       ShaderPixelInputInfo* ps_input_info, vk::PrimitiveTopology topology,
+	                       bool ps_active, std::span<const uint32_t> vs_spirv,
+	                       std::span<const uint32_t> ps_spirv);
+	ComputePipeline& CreateComputePipeline(ShaderComputeInputInfo&      input_info,
+	                                       const HW::ComputeShaderInfo& cs_regs,
+	                                       std::span<const uint32_t>    cs_spirv);
 
 private:
-	struct ProgramCache;
-
 	struct GraphicsPipelineKey {
 		PipelineRenderingState   rendering;
-		uint64_t                 vs_shader_id = 0;
-		uint64_t                 ps_shader_id = 0;
-		PipelineVertexInputState vertex_input;
+		ShaderId                 vs_shader_id;
+		ShaderId                 ps_shader_id;
 		PipelineStaticParameters static_params;
 
 		bool operator==(const GraphicsPipelineKey& other) const {
 			return rendering == other.rendering && vs_shader_id == other.vs_shader_id &&
-			       ps_shader_id == other.ps_shader_id && vertex_input == other.vertex_input &&
-			       static_params == other.static_params;
+			       ps_shader_id == other.ps_shader_id && static_params == other.static_params;
 		}
 	};
 
 	struct ComputePipelineKey {
-		uint64_t cs_shader_id = 0;
+		ShaderId cs_shader_id;
 
 		bool operator==(const ComputePipelineKey& other) const {
 			return cs_shader_id == other.cs_shader_id;
@@ -196,6 +155,15 @@ private:
 			        (hash >> 2u);
 		}
 
+		static void MixShaderId(std::size_t& hash, const ShaderId& id) {
+			Mix(hash, id.hash0);
+			Mix(hash, id.crc32);
+			Mix(hash, id.ids.size());
+			for (auto value: id.ids) {
+				Mix(hash, value);
+			}
+		}
+
 		static void MixStaticParams(std::size_t& hash, const PipelineStaticParameters& params) {
 			const auto* bytes = reinterpret_cast<const uint8_t*>(&params);
 			for (std::size_t i = 0; i < sizeof(params); i++) {
@@ -217,18 +185,8 @@ private:
 		std::size_t operator()(const GraphicsPipelineKey& key) const {
 			std::size_t hash = 0;
 			PipelineKeyHash::MixRendering(hash, key.rendering);
-			PipelineKeyHash::Mix(hash, key.vs_shader_id);
-			PipelineKeyHash::Mix(hash, key.ps_shader_id);
-			PipelineKeyHash::Mix(hash, key.vertex_input.binding_count);
-			for (uint32_t i = 0; i < key.vertex_input.binding_count; i++) {
-				PipelineKeyHash::Mix(hash, key.vertex_input.bindings[i].stride);
-				PipelineKeyHash::Mix(hash, key.vertex_input.bindings[i].instance);
-			}
-			PipelineKeyHash::Mix(hash, key.vertex_input.attribute_count);
-			for (uint32_t i = 0; i < key.vertex_input.attribute_count; i++) {
-				PipelineKeyHash::Mix(hash, key.vertex_input.attributes[i].offset);
-				PipelineKeyHash::Mix(hash, key.vertex_input.attributes[i].binding);
-			}
+			PipelineKeyHash::MixShaderId(hash, key.vs_shader_id);
+			PipelineKeyHash::MixShaderId(hash, key.ps_shader_id);
 			PipelineKeyHash::MixStaticParams(hash, key.static_params);
 			return hash;
 		}
@@ -237,35 +195,34 @@ private:
 	struct ComputePipelineKeyHash {
 		std::size_t operator()(const ComputePipelineKey& key) const {
 			std::size_t hash = 0;
-			PipelineKeyHash::Mix(hash, key.cs_shader_id);
+			PipelineKeyHash::MixShaderId(hash, key.cs_shader_id);
 			return hash;
 		}
 	};
 
-	GraphicContext&               m_graphics;
-	std::unique_ptr<ProgramCache> m_program_cache;
-	vk::PipelineCache             m_driver_cache = nullptr;
-	std::filesystem::path         m_driver_cache_path;
+	GraphicContext&  m_graphics;
+	DescriptorCache& m_descriptor_cache;
 	std::unordered_map<GraphicsPipelineKey, std::unique_ptr<GraphicsPipeline>,
 	                   GraphicsPipelineKeyHash>
 	    m_graphics_pipelines;
 	std::unordered_map<ComputePipelineKey, std::unique_ptr<ComputePipeline>, ComputePipelineKeyHash>
 	              m_compute_pipelines;
 	Common::Mutex m_mutex;
-
-	void InitializeDriverCache();
 };
 
-void LogPipelineTrace(const char* phase, uint64_t vertex_program_id, uint64_t pixel_program_id);
+void LogPipelineTrace(const char* phase, uint32_t vs_hash0, uint32_t vs_crc32, uint32_t ps_hash0,
+                      uint32_t ps_crc32);
 void CreatePipelineInternal(
-    GraphicContext& graphics, PipelineCache::GraphicsPipeline& pipeline,
-    const PipelineRenderingState& rendering, const PipelineVertexInputState& vertex_input,
-    const ShaderVertexInputInfo& vs_input_info, vk::ShaderModule vertex_module,
-    const ShaderPixelInputInfo* ps_input_info, vk::ShaderModule pixel_module,
-    const PipelineStaticParameters& static_params, vk::PipelineCache driver_cache);
-void CreatePipelineInternal(GraphicContext& graphics, PipelineCache::ComputePipeline& pipeline,
-                            const ShaderComputeInputInfo& input_info,
-                            vk::ShaderModule compute_module, vk::PipelineCache driver_cache);
+    GraphicContext& graphics, DescriptorCache& descriptor_cache,
+    PipelineCache::GraphicsPipeline& pipeline, const PipelineRenderingState& rendering,
+    const ShaderVertexInputInfo& vs_input_info, std::span<const uint32_t> vs_shader,
+    const ShaderPixelInputInfo* ps_input_info, std::span<const uint32_t> ps_shader,
+    const PipelineStaticParameters& static_params, uint32_t vs_hash0, uint32_t vs_crc32,
+    uint32_t ps_hash0, uint32_t ps_crc32, bool ps_active);
+void CreatePipelineInternal(GraphicContext& graphics, DescriptorCache& descriptor_cache,
+                            PipelineCache::ComputePipeline& pipeline,
+                            const ShaderComputeInputInfo&   input_info,
+                            std::span<const uint32_t>       cs_shader);
 
 } // namespace Libs::Graphics
 

src/graphics/host_gpu/renderer/pipeline/shaderResourceBarrier.cpp

@@ -36,22 +36,6 @@ VulkanMemoryBarrier MakeShaderWriteDependency() {
 	return barrier;
 }
 
-VulkanMemoryBarrier MakeShaderAccessDependency() {
-	VulkanMemoryBarrier barrier {};
-	barrier.sType         = vk::StructureType::eMemoryBarrier;
-	barrier.srcAccessMask = vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eShaderWrite;
-	barrier.dstAccessMask = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite;
-	return barrier;
-}
-
-VulkanMemoryBarrier MakeShaderWriteHazardDependency() {
-	VulkanMemoryBarrier barrier {};
-	barrier.sType         = vk::StructureType::eMemoryBarrier;
-	barrier.srcAccessMask = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite;
-	barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eShaderWrite;
-	return barrier;
-}
-
 vk::BufferMemoryBarrier MakeGdsDependency(vk::Buffer buffer) {
 	EXIT_IF(buffer == nullptr);
 
@@ -69,7 +53,7 @@ vk::BufferMemoryBarrier MakeGdsDependency(vk::Buffer buffer) {
 }
 
 std::vector<ShaderBufferWriteRange>
-CollectShaderBufferWrites(const ShaderRecompiler::IR::CompiledShaderInfo& program,
+CollectShaderBufferWrites(const ShaderRecompiler::IR::Program&          program,
                           const ShaderRecompiler::IR::ResourceSnapshot& resources) {
 	EXIT_IF(resources.buffers.size() != program.info.buffers.size());
 	std::vector<ShaderBufferWriteRange> writes;
@@ -97,22 +81,7 @@ CollectShaderBufferWrites(const ShaderRecompiler::IR::CompiledShaderInfo& progra
 
 bool HasShaderBufferWrites(const ShaderStageRuntime& runtime) {
 	EXIT_IF(!runtime);
-	return !CollectShaderBufferWrites(*runtime.program, runtime.resources).empty();
-}
-
-void ShaderAccessBarrier(vk::CommandBuffer vk_buffer, vk::PipelineStageFlags source_stages) {
-	EXIT_IF(vk_buffer == nullptr || !source_stages);
-	const auto barrier = MakeShaderAccessDependency();
-	vk_buffer.pipelineBarrier(source_stages, vk::PipelineStageFlagBits::eAllCommands,
-	                          vk::DependencyFlags {}, 1, &barrier, 0, nullptr, 0, nullptr);
-}
-
-void ShaderWriteHazardBarrier(vk::CommandBuffer      vk_buffer,
-                              vk::PipelineStageFlags destination_stages) {
-	EXIT_IF(vk_buffer == nullptr || !destination_stages);
-	const auto barrier = MakeShaderWriteHazardDependency();
-	vk_buffer.pipelineBarrier(vk::PipelineStageFlagBits::eAllCommands, destination_stages,
-	                          vk::DependencyFlags {}, 1, &barrier, 0, nullptr, 0, nullptr);
+	return !CollectShaderBufferWrites(*runtime.program, *runtime.resources).empty();
 }
 
 void ShaderWriteBarrier(vk::CommandBuffer vk_buffer, vk::PipelineStageFlags source_stages) {

src/graphics/host_gpu/renderer/pipeline/shaderResourceBarrier.h

@@ -2,7 +2,7 @@
 #define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_SHADERRESOURCEBARRIER_H_
 
 #include "graphics/host_gpu/graphicContext.h"
-#include "graphics/shader/recompiler/ir/passes/ResourceMaterialization.h"
+#include "graphics/shader/recompiler/ir/ResourceMaterialization.h"
 
 #include <vector>
 
@@ -18,17 +18,12 @@ struct ShaderBufferWriteRange {
 };
 
 vk::PipelineStageFlags  ShaderPipelineStages(vk::ShaderStageFlags stages);
-VulkanMemoryBarrier     MakeShaderAccessDependency();
-VulkanMemoryBarrier     MakeShaderWriteHazardDependency();
 VulkanMemoryBarrier     MakeShaderWriteDependency();
 vk::BufferMemoryBarrier MakeGdsDependency(vk::Buffer buffer);
 std::vector<ShaderBufferWriteRange>
-CollectShaderBufferWrites(const ShaderRecompiler::IR::CompiledShaderInfo& program,
+CollectShaderBufferWrites(const ShaderRecompiler::IR::Program&          program,
                           const ShaderRecompiler::IR::ResourceSnapshot& resources);
 bool HasShaderBufferWrites(const ShaderStageRuntime& runtime);
-void ShaderAccessBarrier(vk::CommandBuffer vk_buffer, vk::PipelineStageFlags source_stages);
-void ShaderWriteHazardBarrier(vk::CommandBuffer      vk_buffer,
-                              vk::PipelineStageFlags destination_stages);
 void ShaderWriteBarrier(vk::CommandBuffer vk_buffer, vk::PipelineStageFlags source_stages);
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/pipeline/shaderSubgroup.cpp

@@ -0,0 +1,60 @@
+#include "graphics/host_gpu/renderer/pipeline/shaderSubgroup.h"
+
+#include "graphics/shader/recompiler/emitter/SpirvEmitter.h"
+
+namespace Libs::Graphics {
+
+ShaderSubgroupCapabilities::ShaderSubgroupCapabilities(const GraphicContext& graphics)
+    : subgroup_size(graphics.subgroup_size), min_subgroup_size(graphics.min_subgroup_size),
+      max_subgroup_size(graphics.max_subgroup_size),
+      required_subgroup_size_stages(graphics.required_subgroup_size_stages),
+      subgroup_size_control_enabled(graphics.subgroup_size_control_enabled) {}
+
+ShaderLaneMaskMode SelectGraphicsLaneMaskMode(uint32_t guest_wave_size) {
+	// A 64-wide guest wave can't assume the host GPU's lane layout matches
+	// GCN's. AMD RDNA also reports a 64-wide subgroup but uses a different
+	// lane/pixel layout, which corrupted rendering under "native wave" mode.
+	// Per-invocation emulation works regardless of the host's lane layout.
+	if (guest_wave_size == 64u) {
+		return ShaderLaneMaskMode::PerInvocation;
+	}
+	return ShaderLaneMaskMode::NativeWave;
+}
+
+ShaderSubgroupConfiguration ConfigureShaderSubgroup(const ShaderSubgroupCapabilities& capabilities,
+                                                    vk::ShaderStageFlagBits           stage,
+                                                    const ShaderRecompiler::IR::Program& program) {
+	const auto guest_wave_size = program.wave_size;
+	if (guest_wave_size != 32u && guest_wave_size != 64u) {
+		return {};
+	}
+	if (stage != vk::ShaderStageFlagBits::eCompute) {
+		const auto expected = SelectGraphicsLaneMaskMode(guest_wave_size);
+		if (program.lane_mask_mode != expected || (capabilities.subgroup_size != guest_wave_size &&
+		                                           expected != ShaderLaneMaskMode::PerInvocation)) {
+			return {};
+		}
+		return {expected == ShaderLaneMaskMode::NativeWave
+		            ? ShaderSubgroupMode::Natural
+		            : ShaderSubgroupMode::PerInvocationGraphics,
+		        0};
+	}
+	if (program.lane_mask_mode != ShaderLaneMaskMode::NativeWave) {
+		return {};
+	}
+	if (capabilities.subgroup_size == guest_wave_size) {
+		return {ShaderSubgroupMode::Natural, 0};
+	}
+	if (capabilities.subgroup_size_control_enabled &&
+	    (capabilities.required_subgroup_size_stages & stage) &&
+	    guest_wave_size >= capabilities.min_subgroup_size &&
+	    guest_wave_size <= capabilities.max_subgroup_size) {
+		return {ShaderSubgroupMode::Controlled, guest_wave_size};
+	}
+	if (!ShaderRecompiler::Spirv::ProgramRequiresExactSubgroupSize(program)) {
+		return {ShaderSubgroupMode::FlattenedMasks, 0};
+	}
+	return {};
+}
+
+} // namespace Libs::Graphics