guest_gpu: remove memory-unmap submission deadlock + remove legacy agc buffering

implement dynamic
2026-10-28 16:23:05 +00:00 · 2026-08-02 13:17:53 +02:00 · 2026-08-02 10:50:28 +02:00
166 changed files with 5227 additions and 14272 deletions
@@ -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
@@ -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 audio_out2_port_tests 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 "^(audio_out2_port|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 audio_out2_port_tests 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 '^(audio_out2_port|virtual_memory_allocation)$'

      - name: Install
        shell: bash
@@ -240,7 +213,6 @@ jobs:

  linux:
    name: Build KytyPS5 (Linux)
-    needs: metadata
    runs-on: ubuntu-24.04

    steps:
@@ -298,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
@@ -329,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 \
+              audio_out2_port_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 '^(audio_out2_port|page_manager|memory_tracker|virtual_memory_allocation)$'

      - name: Install
        shell: bash
@@ -373,77 +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_dir="artifacts/KytyPS5-macOS-x86_64"
-          test -d "$macos_dir"
-          chmod a+x \
-            "$macos_dir/launcher" \
-            "$macos_dir/kyty_emulator" \
-            "$macos_dir/libMoltenVK.dylib"
          (
            cd "$macos_dir"
            zip -r "$GITHUB_WORKSPACE/$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"
          tar -C "$linux_dir" -czf \
            "$GITHUB_WORKSPACE/$RELEASE_NAME-Linux-x86_64.tar.gz" .

@@ -452,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 \
@@ -3,5 +3,4 @@
 .idea/
 build/
 _Build/vscode-clang/
-_Build/
-cmake-build-debug/
+_Build/
@@ -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
@@ -1,5 +1,5 @@
 {
-    "cmake.sourceDirectory": "${workspaceFolder}",
+    "cmake.sourceDirectory": "${workspaceFolder}/src",
    "cmake.buildDirectory": "${workspaceFolder}/_Build/vscode-clang",
    "cmake.generator": "Ninja",
    "cmake.environment": {
@@ -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)
@@ -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,
@@ -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"
@@ -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,55 +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/cfg/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/cfg/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/decompiler/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/decompiler/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/emitter/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/emitter/*.h"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/*.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/*.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
@@ -250,7 +215,7 @@ foreach(shader_name IN LISTS gpu_tiler_shader_names)
 		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
 	)
@@ -274,7 +239,7 @@ foreach(shader_source IN LISTS gpu_blit_shader_sources)
 		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
 	)
@@ -283,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)

@@ -292,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)
@@ -315,7 +280,7 @@ 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
@@ -327,13 +292,13 @@ set(inc_headers

 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)
@@ -355,114 +320,108 @@ 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/ReadLaneElimination.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ScalarProvenance.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/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_include_directories(page_manager_tests PRIVATE ${inc_headers})

 add_executable(bit_array_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/BitArrayTests.cpp"
+	../tests/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/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(shader_stage_runtime_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ShaderStageRuntimeTests.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/shaderStageRuntime.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ResourceMaterialization.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ScalarProvenance.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/SrtWalker.cpp"
+	../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(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/recompiler/ir/ScalarProvenance.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/SrtWalker.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/SrtPatcher.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ResourceTracking.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ResourceMaterialization.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ShaderInfoCollection.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/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(resource_mutex_tests EXCLUDE_FROM_ALL
+	../tests/ResourceMutexTests.cpp
+	graphics/host_gpu/renderer/cache/resourceMutex.cpp
+)
+target_link_libraries(resource_mutex_tests common)
+target_include_directories(resource_mutex_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"
+	../tests/AudioOut2PortTests.cpp
+	libs/libAudio2.cpp
+	loader/timer.cpp
 )
 target_link_libraries(audio_out2_port_tests common fmt::fmt)
 target_include_directories(audio_out2_port_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_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
@@ -478,14 +437,14 @@ add_custom_command(
 	        -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)

@@ -498,7 +457,6 @@ if(NOT KYTY_CLANG_CL)
 endif()

 if(BUILD_TESTING)
-	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>)
@@ -508,22 +466,18 @@ if(BUILD_TESTING)
 	add_test(NAME shader_vertex_metadata COMMAND $<TARGET_FILE:shader_vertex_metadata_tests>)
 	add_test(NAME shader_stage_runtime COMMAND $<TARGET_FILE:shader_stage_runtime_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 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 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)

@@ -549,7 +503,6 @@ if(BUILD_TESTING)
 	endif()

 	add_custom_target(kyty_tests DEPENDS
-		ime_dialog_tests
 		shader_cfg_tests
 		scalar_provenance_tests
 		image_page_table_tests
@@ -559,15 +512,15 @@ if(BUILD_TESTING)
 		shader_vertex_metadata_tests
 		shader_stage_runtime_tests
 		resource_tracking_tests
+		resource_mutex_tests
 		event_queue_lifetime_tests
-		sync_on_address_tests
 		shader_recompiler_compute_tests
 		virtual_memory_allocation_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})
@@ -608,6 +561,8 @@ 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
@@ -615,14 +570,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 .)
@@ -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@
@@ -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
 )

@@ -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)));
@@ -33,18 +33,10 @@ uint32_t GetScreenHeight() {
 	return g_config->screen_height;
 }

-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;
 }
@@ -97,18 +89,12 @@ bool RenderDocEnabled() {
 	return g_config->renderdoc_enabled;
 }

+bool NggRectlistDrawEnabled() {
+	return g_config->ngg_rectlist_draw_enabled;
+}
+
 bool ReadbackLinearImagesEnabled() {
 	return g_config->readback_linear_images;
 }

-#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
@@ -5,8 +5,6 @@
 #include "common/subsystems.h"

 #include <filesystem>
-#include <string>
-#include <vector>

 namespace Config {

@@ -20,17 +18,10 @@ enum class ProfilerDirection { None, Network };

 enum class OutputDirection { Silent, Console, File };

-using Keymap = std::vector<std::string>;
-
-constexpr uint32_t DEFAULT_CONSOLE_LANGUAGE = 1;
-constexpr uint32_t MAX_CONSOLE_LANGUAGE     = 29;
-
 struct ConfigOptions {
 	uint32_t               screen_width                = 1280;
 	uint32_t               screen_height               = 720;
-	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;
@@ -44,20 +35,15 @@ struct ConfigOptions {
 	ProfilerDirection      profiler_direction          = ProfilerDirection::None;
 	bool                   spirv_debug_printf_enabled  = false;
 	bool                   renderdoc_enabled           = false;
+	bool                   ngg_rectlist_draw_enabled   = true;
 	bool                   readback_linear_images      = 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();
-bool     FullscreenEnabled();
 uint32_t GetVblankFrequency();
-uint32_t GetConsoleLanguage();
 bool     VulkanValidationEnabled();

 bool                   ShaderValidationEnabled();
@@ -78,12 +64,8 @@ ProfilerDirection GetProfilerDirection();
 bool SpirvDebugPrintfEnabled();

 bool RenderDocEnabled();
+bool NggRectlistDrawEnabled();
 bool ReadbackLinearImagesEnabled();
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-bool RedZoneProtectionEnabled();
-#endif
-
-const Keymap& GetKeymap();

 } // namespace Config

@@ -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 &&
@@ -1,8 +1,7 @@
 set(KYTY_GIT_VERSION "unknown")
-set(KYTY_GIT_HASH "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
@@ -12,27 +11,5 @@ if(GIT_EXECUTABLE)
 	if(NOT GIT_RESULT EQUAL 0)
 		set(KYTY_GIT_VERSION "unknown")
 	endif()
-
-	execute_process(
-		COMMAND "${GIT_EXECUTABLE}" rev-parse --short=7 HEAD
-		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
-		OUTPUT_VARIABLE KYTY_GIT_HASH
-		OUTPUT_STRIP_TRAILING_WHITESPACE
-		RESULT_VARIABLE GIT_HASH_RESULT
-		ERROR_QUIET
-	)
-	if(NOT GIT_HASH_RESULT EQUAL 0)
-		set(KYTY_GIT_HASH "unknown")
-	else()
-		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}")
@@ -15,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; }
@@ -56,12 +49,24 @@ public:
 	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; }
@@ -78,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,
@@ -146,9 +152,6 @@ 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(); }
 	RenderCommandBuffer& CurrentBuffer() { return GetScheduler().Current(); }
@@ -157,8 +160,6 @@ private:

 	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;
@@ -167,12 +168,12 @@ 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};

@@ -254,7 +254,6 @@ constexpr auto MakeCustomOpcodeDispatchTable() {
 	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;
 }
@@ -121,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);
@@ -18,9 +18,7 @@
 #include <algorithm>
 #include <array>
 #include <atomic>
-#include <bit>
 #include <cstdio>
-#include <cstring>
 #include <vector>

 #define KYTY_HW_CTX_PARSER_ARGS                                                                    \
@@ -183,10 +181,6 @@ static void HwCtxIgnoreAaMaskRegister([[maybe_unused]] uint32_t cmd_offset,

 static void HwCtxIgnoreAlphaToMaskRegister([[maybe_unused]] uint32_t value) {}

-static void HwCtxIgnoreDisabledUserClipPlane(CommandProcessor& cp, uint32_t value) {
-	EXIT_NOT_IMPLEMENTED(value != 0 || cp.GetCtx().GetClipControl().user_clip_planes != 0);
-}
-
 static void HwCtxIgnoreDrawPayloadControl([[maybe_unused]] uint32_t value) {}

 static void HwCtxIgnoreObjprimIdControl([[maybe_unused]] uint32_t value) {}
@@ -901,44 +895,23 @@ KYTY_HW_CTX_PARSER(HwCtxSetModeControl) {
 	return 1;
 }

-static void HwCtxSetPolyOffsetRegister(CommandProcessor& cp, uint32_t cmd_offset, uint32_t value) {
-	HW::PolyOffset offset = cp.GetCtx().GetPolyOffset();
+static void HwCtxIgnorePolyOffsetRegister(uint32_t cmd_offset, uint32_t value) {
+	static std::atomic<uint32_t> log_count = 0;

-	switch (cmd_offset) {
-		case Pm4::PA_SU_POLY_OFFSET_DB_FMT_CNTL: {
-			const auto neg_bits =
-			    KYTY_PM4_GET(value, PA_SU_POLY_OFFSET_DB_FMT_CNTL, NEG_NUM_DB_BITS);
-			offset.neg_num_db_bits = std::bit_cast<int8_t>(static_cast<uint8_t>(neg_bits));
-			offset.db_is_float_fmt =
-			    KYTY_PM4_GET(value, PA_SU_POLY_OFFSET_DB_FMT_CNTL, DB_IS_FLOAT_FMT) != 0;
-			break;
-		}
-		case Pm4::PA_SU_POLY_OFFSET_CLAMP: offset.clamp = std::bit_cast<float>(value); break;
-		case Pm4::PA_SU_POLY_OFFSET_FRONT_SCALE:
-			offset.front_scale = std::bit_cast<float>(value);
-			break;
-		case Pm4::PA_SU_POLY_OFFSET_FRONT_OFFSET:
-			offset.front_offset = std::bit_cast<float>(value);
-			break;
-		case Pm4::PA_SU_POLY_OFFSET_BACK_SCALE:
-			offset.back_scale = std::bit_cast<float>(value);
-			break;
-		case Pm4::PA_SU_POLY_OFFSET_BACK_OFFSET:
-			offset.back_offset = std::bit_cast<float>(value);
-			break;
-		default:
-			EXIT("unknown polygon offset context register 0x%03" PRIx32 " = 0x%08" PRIx32 "\n",
-			     cmd_offset, value);
+	auto count = log_count.fetch_add(1);
+	if (count < 8) {
+		LOGF_COLOR(Log::Color::Red,
+		           "\t temporary: ignoring polygon offset context register 0x%03" PRIx32
+		           " = 0x%08" PRIx32 " (depth bias not implemented)\n",
+		           cmd_offset, value);
 	}
-
-	cp.GetCtx().SetPolyOffset(offset);
 }

 KYTY_HW_CTX_PARSER(HwCtxSetPolyOffsetRegisters) {
 	auto num_values = KYTY_PM4_LEN(cmd_id) - 2u;

 	for (uint32_t i = 0; i < num_values; i++) {
-		HwCtxSetPolyOffsetRegister(cp, cmd_offset + i, buffer[i]);
+		HwCtxIgnorePolyOffsetRegister(cmd_offset + i, buffer[i]);
 	}

 	return num_values;
@@ -1339,36 +1312,26 @@ static void HwShSetCsRegister(CommandProcessor& cp, uint32_t cmd_offset, uint32_
 			    (value >> Pm4::COMPUTE_PGM_RSRC1_VGPRS_SHIFT) & Pm4::COMPUTE_PGM_RSRC1_VGPRS_MASK;
 			cs_regs.sgprs =
 			    (value >> Pm4::COMPUTE_PGM_RSRC1_SGPRS_SHIFT) & Pm4::COMPUTE_PGM_RSRC1_SGPRS_MASK;
-			cs_regs.float_mode    = (value >> Pm4::COMPUTE_PGM_RSRC1_FLOAT_MODE_SHIFT) &
-			                        Pm4::COMPUTE_PGM_RSRC1_FLOAT_MODE_MASK;
-			cs_regs.dx10_clamp    = ((value >> Pm4::COMPUTE_PGM_RSRC1_DX10_CLAMP_SHIFT) &
-			                         Pm4::COMPUTE_PGM_RSRC1_DX10_CLAMP_MASK) != 0u;
-			cs_regs.ieee_mode     = ((value >> Pm4::COMPUTE_PGM_RSRC1_IEEE_MODE_SHIFT) &
-			                         Pm4::COMPUTE_PGM_RSRC1_IEEE_MODE_MASK) != 0u;
-			cs_regs.fp16_overflow = ((value >> Pm4::COMPUTE_PGM_RSRC1_FP16_OVFL_SHIFT) &
-			                         Pm4::COMPUTE_PGM_RSRC1_FP16_OVFL_MASK) != 0u;
-			cs_regs.bulky         = ((value >> Pm4::COMPUTE_PGM_RSRC1_BULKY_SHIFT) &
-			                         Pm4::COMPUTE_PGM_RSRC1_BULKY_MASK) != 0u;
-			cs_regs.threadgroup_configuration = ((value >> Pm4::COMPUTE_PGM_RSRC1_WGP_MODE_SHIFT) &
-			                                     Pm4::COMPUTE_PGM_RSRC1_WGP_MODE_MASK) != 0u;
-			cs_regs.wave_size                 = (((value >> Pm4::COMPUTE_PGM_RSRC1_W32_EN_SHIFT) &
-			                                      Pm4::COMPUTE_PGM_RSRC1_W32_EN_MASK) != 0u)
-			                                        ? 32u
-			                                        : 64u;
+			cs_regs.bulky =
+			    (value >> Pm4::COMPUTE_PGM_RSRC1_BULKY_SHIFT) & Pm4::COMPUTE_PGM_RSRC1_BULKY_MASK;
+			cs_regs.wave_size = (((value >> Pm4::COMPUTE_PGM_RSRC1_W32_EN_SHIFT) &
+			                      Pm4::COMPUTE_PGM_RSRC1_W32_EN_MASK) != 0u)
+			                        ? 32u
+			                        : 64u;
 			break;
 		case Pm4::COMPUTE_PGM_RSRC2:
-			cs_regs.scratch_en     = ((value >> Pm4::COMPUTE_PGM_RSRC2_SCRATCH_EN_SHIFT) &
-			                          Pm4::COMPUTE_PGM_RSRC2_SCRATCH_EN_MASK) != 0u;
+			cs_regs.scratch_en     = (value >> Pm4::COMPUTE_PGM_RSRC2_SCRATCH_EN_SHIFT) &
+			                         Pm4::COMPUTE_PGM_RSRC2_SCRATCH_EN_MASK;
 			cs_regs.user_sgpr      = (value >> Pm4::COMPUTE_PGM_RSRC2_USER_SGPR_SHIFT) &
 			                         Pm4::COMPUTE_PGM_RSRC2_USER_SGPR_MASK;
-			cs_regs.tgid_x_en      = ((value >> Pm4::COMPUTE_PGM_RSRC2_TGID_X_EN_SHIFT) &
-			                          Pm4::COMPUTE_PGM_RSRC2_TGID_X_EN_MASK) != 0u;
-			cs_regs.tgid_y_en      = ((value >> Pm4::COMPUTE_PGM_RSRC2_TGID_Y_EN_SHIFT) &
-			                          Pm4::COMPUTE_PGM_RSRC2_TGID_Y_EN_MASK) != 0u;
-			cs_regs.tgid_z_en      = ((value >> Pm4::COMPUTE_PGM_RSRC2_TGID_Z_EN_SHIFT) &
-			                          Pm4::COMPUTE_PGM_RSRC2_TGID_Z_EN_MASK) != 0u;
-			cs_regs.tg_size_en     = ((value >> Pm4::COMPUTE_PGM_RSRC2_TG_SIZE_EN_SHIFT) &
-			                          Pm4::COMPUTE_PGM_RSRC2_TG_SIZE_EN_MASK) != 0u;
+			cs_regs.tgid_x_en      = (value >> Pm4::COMPUTE_PGM_RSRC2_TGID_X_EN_SHIFT) &
+			                         Pm4::COMPUTE_PGM_RSRC2_TGID_X_EN_MASK;
+			cs_regs.tgid_y_en      = (value >> Pm4::COMPUTE_PGM_RSRC2_TGID_Y_EN_SHIFT) &
+			                         Pm4::COMPUTE_PGM_RSRC2_TGID_Y_EN_MASK;
+			cs_regs.tgid_z_en      = (value >> Pm4::COMPUTE_PGM_RSRC2_TGID_Z_EN_SHIFT) &
+			                         Pm4::COMPUTE_PGM_RSRC2_TGID_Z_EN_MASK;
+			cs_regs.tg_size_en     = (value >> Pm4::COMPUTE_PGM_RSRC2_TG_SIZE_EN_SHIFT) &
+			                         Pm4::COMPUTE_PGM_RSRC2_TG_SIZE_EN_MASK;
 			cs_regs.tidig_comp_cnt = (value >> Pm4::COMPUTE_PGM_RSRC2_TIDIG_COMP_CNT_SHIFT) &
 			                         Pm4::COMPUTE_PGM_RSRC2_TIDIG_COMP_CNT_MASK;
 			cs_regs.lds_size       = (value >> Pm4::COMPUTE_PGM_RSRC2_LDS_SIZE_SHIFT) &
@@ -2139,24 +2102,11 @@ KYTY_CP_OP_PARSER(CpOpClearState) {
 	EXIT_NOT_IMPLEMENTED(cmd_id != 0xc0001200);
 	EXIT_NOT_IMPLEMENTED((buffer[0] & ~0xfu) != 0);

-	cp.ApplyContextStateOperation(ContextStateOperation::Clear);
+	cp.Reset();

 	return 1;
 }

-KYTY_CP_OP_PARSER(CpOpContextState) {
-	KYTY_PROFILER_FUNCTION();
-
-	const auto packet_size_dw = KYTY_PM4_LEN(cmd_id);
-	EXIT_NOT_IMPLEMENTED(KYTY_PM4_R(cmd_id) != Pm4::R_CONTEXT_STATE);
-	EXIT_NOT_IMPLEMENTED(packet_size_dw != 3u && packet_size_dw != 5u);
-	EXIT_NOT_IMPLEMENTED(buffer[0] > static_cast<uint32_t>(ContextStateOperation::PushClear));
-
-	cp.ApplyContextStateOperation(static_cast<ContextStateOperation>(buffer[0]));
-
-	return packet_size_dw - 1u;
-}
-
 KYTY_CP_OP_PARSER(CpOpDumpConstRam) {
 	KYTY_PROFILER_FUNCTION();

@@ -2686,21 +2636,14 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 	const bool gl2_writeback = ((gcr_cntl & GcrGl2Writeback) != 0);

 	auto trigger_interrupt = [&]() {
-		bool queued = false;
 		switch (interrupt_selector) {
 			case 0x00:
 			case 0x03: break;
 			case 0x01:
 			case 0x02:
-			case 0x04:
-				cp.TriggerEopEventAtEndOfPipe(interrupt_context_id);
-				queued = true;
-				break;
+			case 0x04: cp.TriggerEopEventAtEndOfPipe(interrupt_context_id); break;
 			default: EXIT("unknown release_mem interrupt selector\n");
 		}
-		if (queued) {
-			cp.BufferFlush();
-		}
 	};

 	if (data_sel == 0 || interrupt_selector == 4) {
@@ -2708,6 +2651,10 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 			cp.EmitGlobalBarrier();
 		}

+		if (gl2_writeback) {
+			cp.SynchronizeGpu();
+		}
+
 		trigger_interrupt();

 		return 7;
@@ -2718,6 +2665,10 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 			cp.EmitGlobalBarrier();
 		}

+		if (gl2_writeback) {
+			cp.SynchronizeGpu();
+		}
+
 		trigger_interrupt();

 		return 7;
@@ -2731,6 +2682,17 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 	cache_policy      = 0;

 	if (data_sel == 1) {
+		static std::atomic<uint32_t> log_count {0};
+		const auto                   dst_addr = reinterpret_cast<uint64_t>(dst_gpu_addr);
+		if ((dst_addr & 0xffffffffff000000ull) == 0x0000001021000000ull || log_count.load() < 64) {
+			if (log_count.fetch_add(1) < 256) {
+				LOGF(
+				    "\t runtime release_mem32: dst=0x%016" PRIx64 ", value=0x%08" PRIx32
+				    ", action=0x%02" PRIx32 ", gcr=0x%04" PRIx32 ", cache_action=0x%08" PRIx32 "\n",
+				    dst_addr, static_cast<uint32_t>(value), eop_event_type, gcr_cntl, cache_action);
+			}
+		}
+
 		eop_event_type    = 0x2f;
 		event_index       = 6;
 		auto event_source = 2u;
@@ -2745,6 +2707,7 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {

 	if (data_sel == 5) {
 		if (gl2_writeback) {
+			cp.SynchronizeGpu();
 			cache_action = 0;
 		}

@@ -2755,9 +2718,7 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 		cp.WriteAtEndOfPipe32(cache_policy, event_write_dest, eop_event_type, cache_action,
 		                      event_index, event_source, dst_gpu_addr, static_cast<uint32_t>(value),
 		                      interrupt_selector, interrupt_context_id);
-		if (interrupt_selector == 0x01) {
-			cp.BufferFlush();
-		}
+		cp.BufferFlush();

 		return 7;
 	}
@@ -3347,12 +3308,6 @@ void GraphicsInitJmpTablesCxIndirect() {
 		};
 	}

-	for (auto cmd_offset = Pm4::PA_CL_UCP_0_X; cmd_offset <= Pm4::PA_CL_UCP_5_W; cmd_offset++) {
-		g_hw_ctx_indirect_func[cmd_offset] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-			HwCtxIgnoreDisabledUserClipPlane(cp, value);
-		};
-	}
-
 	for (auto cmd_offset = Pm4::PA_SC_VPORT_SCISSOR_0_TL;
 	     cmd_offset <= Pm4::PA_SC_VPORT_SCISSOR_15_TL; cmd_offset += 2) {
 		g_hw_ctx_indirect_func[cmd_offset] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
@@ -3727,22 +3682,22 @@ void GraphicsInitJmpTablesCxIndirect() {
 	};

 	g_hw_ctx_indirect_func[Pm4::PA_SU_POLY_OFFSET_DB_FMT_CNTL] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HwCtxSetPolyOffsetRegister(cp, cmd_offset, value);
+		HwCtxIgnorePolyOffsetRegister(cmd_offset, value);
 	};
 	g_hw_ctx_indirect_func[Pm4::PA_SU_POLY_OFFSET_CLAMP] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HwCtxSetPolyOffsetRegister(cp, cmd_offset, value);
+		HwCtxIgnorePolyOffsetRegister(cmd_offset, value);
 	};
 	g_hw_ctx_indirect_func[Pm4::PA_SU_POLY_OFFSET_FRONT_SCALE] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HwCtxSetPolyOffsetRegister(cp, cmd_offset, value);
+		HwCtxIgnorePolyOffsetRegister(cmd_offset, value);
 	};
 	g_hw_ctx_indirect_func[Pm4::PA_SU_POLY_OFFSET_FRONT_OFFSET] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HwCtxSetPolyOffsetRegister(cp, cmd_offset, value);
+		HwCtxIgnorePolyOffsetRegister(cmd_offset, value);
 	};
 	g_hw_ctx_indirect_func[Pm4::PA_SU_POLY_OFFSET_BACK_SCALE] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HwCtxSetPolyOffsetRegister(cp, cmd_offset, value);
+		HwCtxIgnorePolyOffsetRegister(cmd_offset, value);
 	};
 	g_hw_ctx_indirect_func[Pm4::PA_SU_POLY_OFFSET_BACK_OFFSET] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HwCtxSetPolyOffsetRegister(cp, cmd_offset, value);
+		HwCtxIgnorePolyOffsetRegister(cmd_offset, value);
 	};

 	g_hw_ctx_indirect_func[Pm4::DB_Z_INFO] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
@@ -4265,28 +4220,29 @@ void GraphicsInitJmpTablesShIndirect() {
 	};

 	g_hw_sh_indirect_func[Pm4::SPI_SHADER_PGM_RSRC1_HS] = [](KYTY_HW_SH_INDIRECT_ARGS) {
-		HW::HsShaderResource1 r1;
-		r1.vgprs      = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, VGPRS);
-		r1.priority   = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, PRIORITY);
-		r1.float_mode = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, FLOAT_MODE);
-		r1.dx10_clamp = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, DX10_CLAMP) != 0;
-		r1.debug_mode = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, DEBUG_MODE) != 0;
-		r1.ieee_mode  = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, IEEE_MODE) != 0;
+		HW::VsShaderResource1 r1;
+		r1.vgprs                = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, VGPRS);
+		r1.sgprs                = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, SGPRS);
+		r1.priority             = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, PRIORITY);
+		r1.float_mode           = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, FLOAT_MODE);
+		r1.dx10_clamp           = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, DX10_CLAMP) != 0;
+		r1.ieee_mode            = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, IEEE_MODE) != 0;
+		r1.vgpr_component_count = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, VGPR_COMP_CNT);
+		r1.cu_group_enable = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, CU_GROUP_ENABLE) != 0;
 		r1.require_forward_progress =
-		    KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, FWD_PROGRESS) != 0;
-		r1.threadgroup_configuration = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, WGP_MODE) != 0;
-		r1.ls_vgpr_component_count = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, LS_VGPR_COMP_CNT);
-		r1.fp16_overflow           = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_HS, FP16_OVFL) != 0;
+		    KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, FWD_PROGRESS) != 0;
+		r1.fp16_overflow = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_VS, FP16_OVFL) != 0;
 		cp.GetShCtx().SetHsShaderResource1(r1);
 	};

 	g_hw_sh_indirect_func[Pm4::SPI_SHADER_PGM_RSRC2_HS] = [](KYTY_HW_SH_INDIRECT_ARGS) {
-		HW::HsShaderResource2 r2;
-		r2.scratch_en   = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_HS, SCRATCH_EN) != 0;
-		r2.user_sgpr    = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_HS, USER_SGPR) +
-		                  (KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_HS, USER_SGPR_MSB) << 5u);
-		r2.lds_size     = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_HS, LDS_SIZE);
-		r2.shared_vgprs = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_HS, SHARED_VGPR_CNT);
+		HW::VsShaderResource2 r2;
+		r2.scratch_en        = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_VS, SCRATCH_EN) != 0;
+		r2.user_sgpr         = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_VS, USER_SGPR) +
+		                       (KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_VS, USER_SGPR_MSB) << 5u);
+		r2.offchip_lds       = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_VS, OC_LDS_EN) != 0;
+		r2.streamout_enabled = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_VS, SO_EN) != 0;
+		r2.shared_vgprs      = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_VS, SHARED_VGPR_CNT);
 		cp.GetShCtx().SetHsShaderResource2(r2);
 	};

@@ -4374,7 +4330,7 @@ void GraphicsInitJmpTablesShIndirect() {
 		r1.cu_group_enable = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_GS, CU_GROUP_ENABLE) != 0;
 		r1.require_forward_progress =
 		    KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_GS, FWD_PROGRESS) != 0;
-		r1.threadgroup_configuration = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_GS, WGP_MODE) != 0;
+		r1.lds_configuration       = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_GS, WGP_MODE) != 0;
 		r1.gs_vgpr_component_count = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_GS, GS_VGPR_COMP_CNT);
 		r1.fp16_overflow           = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC1_GS, FP16_OVFL) != 0;
 		cp.GetShCtx().SetGsShaderResource1(r1);
@@ -4434,7 +4390,7 @@ void GraphicsInitJmpTablesShIndirect() {
 		r2.wave_cnt_en    = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_PS, WAVE_CNT_EN);
 		r2.extra_lds_size = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_PS, EXTRA_LDS_SIZE);
 		r2.raster_ordered_shading =
-		    KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_PS, RASTER_ORDERED_SHADING);
+		    KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_PS, LOAD_INTRAWAVE_COLLISION);
 		r2.shared_vgprs = KYTY_PM4_GET(value, SPI_SHADER_PGM_RSRC2_PS, SHARED_VGPR_CNT);
 		cp.GetShCtx().SetPsShaderResource2(r2);
 	};
@@ -4451,11 +4407,6 @@ void GraphicsInitJmpTablesUcIndirect() {
 		r.vertex_group_size    = KYTY_PM4_GET(value, GE_CNTL, VERT_GRP_SIZE);
 		cp.GetUcfg().SetGeControl(r);
 	};
-	g_hw_uc_indirect_func[Pm4::GE_PC_ALLOC] = [](KYTY_HW_UC_INDIRECT_ARGS) {
-		(void)cp;
-		(void)cmd_offset;
-		(void)value;
-	};

 	g_hw_uc_indirect_func[Pm4::GE_USER_VGPR_EN] = [](KYTY_HW_UC_INDIRECT_ARGS) {
 		HW::GeUserVgprEn r;
@@ -60,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 {
@@ -36,7 +36,6 @@ static thread_local CommandProcessor* g_current_processor = nullptr;
 static thread_local Pm4Execution*     g_current_execution = nullptr;
 static thread_local bool              g_gpu_mutex_owned   = false;
 static thread_local bool              g_gpu_thread        = false;
-static thread_local GpuState*         g_gpu_state         = nullptr;

 class GpuMutexLock final {
 public:
@@ -99,10 +98,11 @@ public:
 	void SubmitFlipPreparation(uint64_t request_id);
 	void Done();
 	void Shutdown();
-	[[nodiscard]] bool        IsStopping();
-	void                      SendCommand(Common::UniqueFunction<void>&& command);
-	void                      SendCommandSync(Common::UniqueFunction<void>&& command);
-	int                       GetFrameNum();
+	[[nodiscard]] bool IsStopping();
+	void               SendCommand(Common::UniqueFunction<void>&& command);
+	void               SendCommandSync(Common::UniqueFunction<void>&& command);
+	void SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command);
+	int  GetFrameNum();
 	[[nodiscard]] static bool IsGpuThread() noexcept { return g_gpu_thread; }

 private:
@@ -124,9 +124,9 @@ private:
 		uint64_t       flip_request_id               = 0;
 	};

+	void              WaitLocked();
 	void              Enqueue(Submission submission);
 	void              WaitForIdle();
-	void              ProcessCommands();
 	bool              Process(Submission& submission);
 	static void       ThreadRun(void* data);
 	CommandProcessor& GetProcessor(uint32_t queue_id);
@@ -139,7 +139,6 @@ private:
 	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;
@@ -154,8 +153,6 @@ private:
 	uint64_t        m_submit_id = 0;
 	std::atomic_int m_done_num  = 0;
 	std::jthread    m_thread;
-
-	friend class CommandProcessor;
 };

 static bool GraphicsRunDebugDumpEnabled() {
@@ -198,25 +195,9 @@ void GpuState::SendCommand(Common::UniqueFunction<void>&& command) {
 	Common::LockGuard lock(m_queue_mutex);
 	EXIT_IF(!m_accepting);
 	m_commands.push_back(std::move(command));
-	m_pending_commands.fetch_add(1, std::memory_order_release);
 	m_work_available.Signal();
 }

-void GpuState::ProcessCommands() {
-	EXIT_IF(!IsGpuThread());
-	while (m_pending_commands.load(std::memory_order_acquire) != 0) {
-		Common::UniqueFunction<void> command;
-		{
-			Common::LockGuard lock(m_queue_mutex);
-			EXIT_IF(m_commands.empty());
-			command = std::move(m_commands.front());
-			m_commands.pop_front();
-			EXIT_IF(m_pending_commands.fetch_sub(1, std::memory_order_acq_rel) == 0);
-		}
-		command();
-	}
-}
-
 void GpuState::SendCommandSync(Common::UniqueFunction<void>&& command) {
 	EXIT_IF(!command);
 	if (IsGpuThread()) {
@@ -231,6 +212,17 @@ void GpuState::SendCommandSync(Common::UniqueFunction<void>&& command) {
 	done.acquire();
 }

+void GpuState::SendCommandSyncWithProcessor(
+    Common::UniqueFunction<void, CommandProcessor&>&& command) {
+	EXIT_IF(!command);
+	SendCommandSync([this, operation = std::move(command)]() mutable {
+		EXIT_IF(g_current_processor != nullptr);
+		g_current_processor = m_gfx_cp.get();
+		operation(*m_gfx_cp);
+		g_current_processor = nullptr;
+	});
+}
+
 void GpuState::Submit(uint32_t* cmd_draw_buffer, uint32_t num_draw_dw, uint32_t* cmd_const_buffer,
                      uint32_t num_const_dw, bool trigger_agc_interrupt_on_done) {
 	GpuMutexLock lock(m_submission_mutex);
@@ -275,8 +267,10 @@ void GpuState::SubmitFlipPreparation(uint64_t request_id) {

 void GpuState::Done() {
 	GpuMutexLock lock(m_submission_mutex);
-	if (!IsGpuThread()) {
-		WaitForIdle();
+	if (IsGpuThread()) {
+		m_gfx_cp->BufferWait();
+	} else {
+		WaitLocked();
 	}
 	m_graphics_done = true;
 	m_done_num++;
@@ -286,6 +280,11 @@ int GpuState::GetFrameNum() {
 	return m_done_num;
 }

+void GpuState::WaitLocked() {
+	WaitForIdle();
+	SendCommandSync([this] { m_gfx_cp->BufferWait(); });
+}
+
 CommandProcessor& GpuState::GetProcessor(uint32_t queue_id) {
 	EXIT_IF(queue_id >= QueueCount);
 	if (queue_id == 0) {
@@ -299,11 +298,11 @@ CommandProcessor& GpuState::GetProcessor(uint32_t queue_id) {
 }

 void CommandProcessor::Reset() {
+	BufferWait();
+
 	m_sh_ctx.Reset();
 	m_ucfg.Reset();
 	m_ctx.Reset();
-	m_saved_ctx.Reset();
-	m_context_state_pushed             = false;
 	m_index_type_and_size              = 0;
 	m_index_buffer_size                = 0;
 	m_user_data_marker                 = HW::UserSgprType::Unknown;
@@ -313,30 +312,6 @@ void CommandProcessor::Reset() {
 	std::memset(m_const_ram, 0, sizeof(m_const_ram));
 }

-void CommandProcessor::ApplyContextStateOperation(ContextStateOperation operation) {
-	switch (operation) {
-		case ContextStateOperation::Clear: m_ctx.Reset(); break;
-		case ContextStateOperation::Push:
-			EXIT_IF(m_context_state_pushed);
-			m_saved_ctx            = m_ctx;
-			m_context_state_pushed = true;
-			break;
-		case ContextStateOperation::Pop:
-			EXIT_IF(!m_context_state_pushed);
-			m_ctx                  = m_saved_ctx;
-			m_saved_ctx            = {};
-			m_context_state_pushed = false;
-			break;
-		case ContextStateOperation::PushClear:
-			EXIT_IF(m_context_state_pushed);
-			m_saved_ctx            = m_ctx;
-			m_context_state_pushed = true;
-			m_ctx.Reset();
-			break;
-		default: EXIT("unknown context state operation: %u\n", static_cast<uint32_t>(operation));
-	}
-}
-
 void CommandProcessor::BufferInit() {
 	GetScheduler().Begin(m_ctx, m_ucfg, m_sh_ctx);
 }
@@ -375,6 +350,7 @@ void CommandProcessor::WaitDeDiff(uint32_t diff) {
 }

 void CommandProcessor::IncrementDe() {
+	BufferWait();
 	m_de_count++;
 }

@@ -473,6 +449,7 @@ void CommandProcessor::DmaData(uint8_t engine, uint8_t dst_sel, uint8_t dst_cach
 	if (num_bytes == 0) {
 		return;
 	}
+	EXIT_NOT_IMPLEMENTED((num_bytes & 3u) != 0);
 	EXIT_NOT_IMPLEMENTED(dst_cache_policy > 3);
 	EXIT_NOT_IMPLEMENTED(src_cache_policy > 3);
 	EXIT_NOT_IMPLEMENTED(wait_for_previous > 1);
@@ -532,7 +509,6 @@ void GpuState::ThreadRun(void* data) {
 	EXIT_IF(gpu == nullptr);
 	KYTY_PROFILER_THREAD("Thread_Gpu");
 	g_gpu_thread = true;
-	g_gpu_state  = gpu;

 	for (;;) {
 		Submission                   submission;
@@ -553,7 +529,6 @@ void GpuState::ThreadRun(void* data) {
 			} else if (!gpu->m_commands.empty()) {
 				command = std::move(gpu->m_commands.front());
 				gpu->m_commands.pop_front();
-				EXIT_IF(gpu->m_pending_commands.fetch_sub(1, std::memory_order_acq_rel) == 0);
 				gpu->m_processing = true;
 			} else {
 				int selected_queue = -1;
@@ -585,7 +560,6 @@ void GpuState::ThreadRun(void* data) {
 		}
 		if (should_stop) {
 			gpu->m_gfx_cp->BufferWait();
-			g_gpu_state  = nullptr;
 			g_gpu_thread = false;
 			return;
 		}
@@ -767,9 +741,6 @@ void CommandProcessor::SuspendPm4() {

 void CommandProcessor::ProcessPm4(Pm4Execution& execution, size_t stop_depth) {
 	while (execution.m_buffer_stack.size() > stop_depth) {
-		if (g_gpu_state != nullptr) {
-			g_gpu_state->ProcessCommands();
-		}
 		const auto buffer_index = execution.m_buffer_stack.size() - 1;
 		auto&      cursor       = execution.m_buffer_stack[buffer_index];
 		if (cursor.deferred_advance_dw != 0) {
@@ -1012,9 +983,8 @@ void CommandProcessor::DrawIndirect(uint32_t data_offset, uint32_t draw_initiato
 				     args.start_vertex_location, args.start_instance_location);
 			}
 		}
-		m_num_instances = args.instance_count;
-		SubmitNonIndexedDraw(args.vertex_count_per_instance, 0, 0, args.start_vertex_location,
-		                     args.start_instance_location);
+		DrawIndexAuto(args.vertex_count_per_instance, 0, 0, args.instance_count,
+		              args.start_vertex_location, args.start_instance_location);
 		return;
 	}

@@ -1054,7 +1024,6 @@ void CommandProcessor::DrawIndirect(uint32_t data_offset, uint32_t draw_initiato
 		}
 	}

-	m_num_instances = args.instance_count;
 	DrawIndex(index_count, index_addr, 0, 1, args.instance_count, nullptr, 0,
 	          static_cast<int32_t>(args.base_vertex_location), args.start_instance_location);
 }
@@ -1112,9 +1081,8 @@ void CommandProcessor::DrawIndirectMulti(uint32_t data_offset, uint32_t max_coun
 					     args->start_vertex_location, args->start_instance_location);
 				}
 			}
-			m_num_instances = args->instance_count;
-			SubmitNonIndexedDraw(args->vertex_count_per_instance, 0, 0, args->start_vertex_location,
-			                     args->start_instance_location);
+			DrawIndexAuto(args->vertex_count_per_instance, 0, 0, args->instance_count,
+			              args->start_vertex_location, args->start_instance_location);
 			continue;
 		}

@@ -1155,7 +1123,6 @@ void CommandProcessor::DrawIndirectMulti(uint32_t data_offset, uint32_t max_coun
 			}
 		}

-		m_num_instances = args->instance_count;
 		DrawIndex(index_count, index_addr, 0, 1, args->instance_count, nullptr, 0,
 		          static_cast<int32_t>(args->base_vertex_location), args->start_instance_location);
 	}
@@ -1164,9 +1131,9 @@ void CommandProcessor::DrawIndirectMulti(uint32_t data_offset, uint32_t max_coun
 void CommandProcessor::DispatchDirect(uint32_t thread_group_x, uint32_t thread_group_y,
                                      uint32_t thread_group_z, uint32_t mode) {
 	uint32_t frame_num = 0;
-	// uint32_t local_x   = 1;
-	// uint32_t local_y   = 1;
-	// uint32_t local_z   = 1;
+	uint32_t local_x   = 1;
+	uint32_t local_y   = 1;
+	uint32_t local_z   = 1;

 	{
 		CheckBuffer();
@@ -1190,9 +1157,9 @@ void CommandProcessor::DispatchDirect(uint32_t thread_group_x, uint32_t thread_g
 		}

 		const auto& cs = m_sh_ctx.GetCs().cs_regs;
-		// local_x        = std::max(cs.num_thread_x, 1u);
-		// local_y        = std::max(cs.num_thread_y, 1u);
-		// local_z        = std::max(cs.num_thread_z, 1u);
+		local_x        = std::max(cs.num_thread_x, 1u);
+		local_y        = std::max(cs.num_thread_y, 1u);
+		local_z        = std::max(cs.num_thread_z, 1u);
 		if (cs.wave_size == 64u) {
 			static std::atomic_bool logged_wave64_shader {false};
 			if (!logged_wave64_shader.exchange(true, std::memory_order_relaxed)) {
@@ -1208,27 +1175,27 @@ void CommandProcessor::DispatchDirect(uint32_t thread_group_x, uint32_t thread_g
 		                                              thread_group_y, thread_group_z, mode);
 	}

-	/*constexpr uint32_t DispatchInitiatorUseThreadDimensions = 1u << 5u;
+	constexpr uint32_t DispatchInitiatorUseThreadDimensions = 1u << 5u;
 	auto               group_count = [](uint32_t threads, uint32_t group_size) {
-	    return (threads == 0
-	                ? 0u
-	                : (threads + std::max(group_size, 1u) - 1u) / std::max(group_size, 1u));
+		return (threads == 0
+		            ? 0u
+		            : (threads + std::max(group_size, 1u) - 1u) / std::max(group_size, 1u));
 	};

 	auto groups_x = thread_group_x;
 	auto groups_y = thread_group_y;
 	auto groups_z = thread_group_z;
 	if ((mode & DispatchInitiatorUseThreadDimensions) != 0) {
-	    groups_x = group_count(thread_group_x, local_x);
-	    groups_y = group_count(thread_group_y, local_y);
-	    groups_z = group_count(thread_group_z, local_z);
+		groups_x = group_count(thread_group_x, local_x);
+		groups_y = group_count(thread_group_y, local_y);
+		groups_z = group_count(thread_group_z, local_z);
 	}

 	const uint64_t invocations =
 	    static_cast<uint64_t>(groups_x) * groups_y * groups_z * local_x * local_y * local_z;
 	if (invocations != 0) {
-	    BufferFlushAndWait();
-	}*/
+		BufferFlushAndWait();
+	}
 }

 void CommandProcessor::DispatchIndirect(uint32_t data_offset, uint32_t mode) {
@@ -1247,17 +1214,12 @@ void CommandProcessor::DispatchIndirect(uint32_t data_offset, uint32_t mode) {
 }

 void CommandProcessor::DrawIndexAuto(uint32_t index_count, uint32_t flags,
-                                     uint32_t render_target_slice_offset) {
-	SubmitNonIndexedDraw(index_count, flags, render_target_slice_offset, 0, 0);
-}
-
-void CommandProcessor::SubmitNonIndexedDraw(uint32_t vertex_count, uint32_t flags,
-                                            uint32_t render_target_slice_offset,
-                                            uint32_t first_vertex, uint32_t first_instance) {
+                                     uint32_t render_target_slice_offset, uint32_t instance_count,
+                                     uint32_t first_vertex, uint32_t first_instance) {
 	CheckBuffer();

-	m_renderer.GetRenderExecutor().DrawAuto(m_submit_id, CurrentBuffer(), vertex_count, flags,
-	                                        render_target_slice_offset, m_num_instances,
+	m_renderer.GetRenderExecutor().DrawAuto(m_submit_id, CurrentBuffer(), index_count, flags,
+	                                        render_target_slice_offset, instance_count,
 	                                        first_vertex, first_instance);
 }

@@ -1340,9 +1302,6 @@ void CommandProcessor::WriteAtEndOfPipe(uint32_t cache_policy, uint32_t event_wr
 					              value >> 16u);
 					Sync::WriteAtEndOfPipeGds32(m_submit_id, CurrentBuffer(), dst, value & 0xffffu,
 					                            value >> 16u);
-					if (with_interrupt) {
-						m_renderer.TriggerEopEvent(interrupt_context_id);
-					}
 					return;
 				}
 			} else if (eop_event_type == 0x04 && cache_action == 0x00 && event_index == 0x05) {
@@ -1545,6 +1504,7 @@ void CommandProcessor::TriggerEvent(uint32_t event_type, uint32_t event_index) {
 				     event_index);
 			}
 			EmitGlobalBarrier();
+			SynchronizeGpu();
 			break;
 		// DbDataWritebackInvalidate, DbMetadataWritebackInvalidate, CbMetadataWritebackInvalidate.
 		case 0x0000002a:
@@ -1681,6 +1641,10 @@ void Gpu::SendCommandSync(Common::UniqueFunction<void>&& command) {
 	m_state->SendCommandSync(std::move(command));
 }

+void Gpu::SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command) {
+	m_state->SendCommandSyncWithProcessor(std::move(command));
+}
+
 void Gpu::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) {
 	EXIT_IF(draw_commands == nullptr || draw_size_dw == 0);
@@ -1706,8 +1670,12 @@ int Gpu::GetFrameNum() const {
 	return m_state->GetFrameNum();
 }

-bool Gpu::IsGpuThread() noexcept {
-	return GpuState::IsGpuThread();
+bool Gpu::IsCommandProcessorThread() noexcept {
+	return g_current_processor != nullptr;
+}
+
+CommandProcessor* Gpu::CurrentCommandProcessor() noexcept {
+	return g_current_processor;
 }

 } // namespace Libs::Graphics
@@ -9,6 +9,7 @@

 namespace Libs::Graphics {

+class CommandProcessor;
 class GpuState;
 class RenderContext;

@@ -22,6 +23,7 @@ public:
 	[[nodiscard]] bool IsStopping();
 	void               SendCommand(Common::UniqueFunction<void>&& command);
 	void               SendCommandSync(Common::UniqueFunction<void>&& command);
+	void SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command);

 	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);
@@ -31,7 +33,8 @@ public:
 	void Done();
 	[[nodiscard]] int GetFrameNum() const;

-	[[nodiscard]] static bool IsGpuThread() noexcept;
+	[[nodiscard]] static bool              IsCommandProcessorThread() noexcept;
+	[[nodiscard]] static CommandProcessor* CurrentCommandProcessor() noexcept;

 private:
 	std::unique_ptr<GpuState> m_state;
@@ -348,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;
@@ -492,26 +482,6 @@ struct VsShaderResource2 {
 	uint8_t shared_vgprs      = 0;
 };

-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 HsShaderResource2 {
-	bool     scratch_en   = false;
-	uint8_t  user_sgpr    = 0;
-	uint16_t lds_size     = 0;
-	uint8_t  shared_vgprs = 0;
-};
-
 struct PsShaderResource1 {
 	uint8_t vgprs                    = 0;
 	uint8_t sgprs                    = 0;
@@ -530,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;
 };

@@ -543,27 +513,22 @@ struct PsStageRegisters {

 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  sgprs                     = 0;
-	uint8_t  float_mode                = 0;
-	bool     dx10_clamp                = false;
-	bool     ieee_mode                 = false;
-	bool     fp16_overflow             = false;
-	bool     bulky                     = 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;
+	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 {
@@ -578,24 +543,24 @@ struct LsStageRegisters {

 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 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    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 {
@@ -915,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; }
@@ -1014,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;
@@ -1072,8 +1034,8 @@ public:
 	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; }
@@ -30,7 +30,6 @@ constexpr auto MakeRegisterNames() {
 	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;
 }

@@ -87,7 +87,6 @@ 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;

@@ -372,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;
@@ -579,28 +577,24 @@ 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;
@@ -784,21 +778,21 @@ 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;
@@ -891,101 +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_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_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_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 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_SGPRS_SHIFT      = 6;
-constexpr uint32_t COMPUTE_PGM_RSRC1_SGPRS_MASK       = 0xF;
-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_IEEE_MODE_SHIFT  = 23;
-constexpr uint32_t COMPUTE_PGM_RSRC1_IEEE_MODE_MASK   = 0x1;
-constexpr uint32_t COMPUTE_PGM_RSRC1_BULKY_SHIFT      = 24;
-constexpr uint32_t COMPUTE_PGM_RSRC1_BULKY_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_W32_EN_SHIFT     = 30;
-constexpr uint32_t COMPUTE_PGM_RSRC1_W32_EN_MASK      = 0x1;
+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;
@@ -1048,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 GE_PC_ALLOC    = 0x260;

 constexpr uint32_t GE_USER_VGPR_EN                     = 0x262;
 constexpr uint32_t GE_USER_VGPR_EN_EN_USER_VGPR1_SHIFT = 0;
@@ -39,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;
@@ -47,69 +47,38 @@ 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 {
-	uint32_t             format    = 0;
-	uint32_t             tile_mode = 0;
-	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(uint32_t format, TileTextureElementLayout& layout);
-bool TileGetTextureBlockLayout(uint32_t format, uint32_t 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     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,
@@ -125,13 +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(uint32_t format, uint32_t width, uint32_t height, uint32_t levels,
-                            uint32_t tile, TileSizeAlign* total_size, TileSizeOffset* level_sizes,
-                            TilePaddedSize* padded_size);
-void     TileGetTextureTotalSize(uint32_t format, uint32_t width, uint32_t height, uint32_t depth,
-                                 uint32_t levels, uint32_t tile, bool volume_texture,
-                                 TileSizeAlign& total_size);
-uint32_t TileGetTexturePitch(uint32_t format, uint32_t width, uint32_t tile);
+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(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

@@ -79,6 +79,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);
@@ -87,6 +88,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);
@@ -95,6 +97,7 @@ 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);
@@ -103,6 +106,7 @@ void MemoryTracker::MarkRegionAsCpuModified(uint64_t vaddr, uint64_t size) {

 void MemoryTracker::MarkRegionAsGpuModified(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::Gpu, true>(manager->GetCpuAddr() + offset, bytes);
@@ -111,13 +115,14 @@ void MemoryTracker::MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size) {

 void MemoryTracker::UnmarkRegionAsGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
+	std::lock_guard access(m_access_mutex);
 	Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
 		manager->ChangeState<DirtySource::Gpu, false>(manager->GetCpuAddr() + offset, bytes);
 	});
 }

-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);
@@ -143,7 +148,8 @@ void MemoryTracker::UntrackMemoryImpl(uint64_t vaddr, uint64_t size) {

 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
@@ -29,29 +29,45 @@ 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) {
+				               manager->ChangeState<DirtySource::Cpu, true>(
+				                   manager->GetCpuAddr() + offset, bytes);
+			               });
+			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,
@@ -68,6 +84,7 @@ public:
 		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);
@@ -108,6 +125,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) {
@@ -171,12 +189,13 @@ 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;
 };

@@ -3,17 +3,15 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
-#include "graphics/guest_gpu/graphicsRun.h"
 #include "graphics/host_gpu/graphicContext.h"
+#include "graphics/host_gpu/renderer/cache/resourceMutex.h"
 #include "graphics/host_gpu/renderer/cache/textureCache.h"
 #include "graphics/host_gpu/renderer/commandScheduler.h"
 #include "graphics/host_gpu/renderer/render.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
 #include "kernel/memory.h"

 #include <algorithm>
 #include <array>
-#include <cinttypes>
 #include <cstring>
 #include <utility>
 #include <vector>
@@ -22,9 +20,30 @@ namespace Libs::Graphics {

 namespace {

+thread_local const void* g_cache_lock_owner = nullptr;
+
 constexpr uint64_t MiB           = 1024 * 1024;
 constexpr uint64_t GdsBufferSize = 64 * 1024;

+class FaultSafeCacheLock final {
+public:
+	FaultSafeCacheLock(const void* owner, Common::Mutex& mutex): m_mutex(mutex) {
+		if (g_cache_lock_owner != nullptr) {
+			EXIT("BufferCache: recursive cache lock acquisition\n");
+		}
+		g_cache_lock_owner = owner;
+		m_mutex.Lock();
+	}
+
+	~FaultSafeCacheLock() {
+		m_mutex.Unlock();
+		g_cache_lock_owner = nullptr;
+	}
+
+private:
+	Common::Mutex& m_mutex;
+};
+
 } // namespace

 uint64_t BufferCache::AlignDown(uint64_t value) noexcept {
@@ -38,6 +57,15 @@ uint64_t BufferCache::AlignUp(uint64_t value) {
 	return (value + CACHING_PAGE_SIZE - 1) & ~(CACHING_PAGE_SIZE - 1);
 }

+bool BufferCache::PageOverlaps(uint64_t left, uint64_t left_size, uint64_t right,
+                               uint64_t right_size) noexcept {
+	const auto left_begin  = left & ~(TRACKER_PAGE_SIZE - 1);
+	const auto left_end    = (left + left_size + TRACKER_PAGE_SIZE - 1) & ~(TRACKER_PAGE_SIZE - 1);
+	const auto right_begin = right & ~(TRACKER_PAGE_SIZE - 1);
+	const auto right_end = (right + right_size + TRACKER_PAGE_SIZE - 1) & ~(TRACKER_PAGE_SIZE - 1);
+	return left_begin < right_end && right_begin < left_end;
+}
+
 void BufferCache::Upload(CommandBuffer& command, Buffer& destination, uint64_t destination_offset,
                         const void* source, uint64_t size) {
 	auto* bytes = static_cast<const uint8_t*>(source);
@@ -170,23 +198,27 @@ void BufferCache::QueueGarbageDownload(std::span<const DownloadCopy> copies, Ret
 	m_scheduler.DeferOperation(
 	    [this, downloads = std::move(downloads), retire = std::move(retire)]() mutable {
 		    PublishDownloads(downloads);
-		    for (const auto& range: downloads) {
-			    m_gpu_modified_ranges.Subtract(range.address, range.size);
+		    {
+			    FaultSafeCacheLock lock(this, m_mutex);
+			    for (const auto& range: downloads) {
+				    m_gpu_modified_ranges.Subtract(range.address, range.size);
+			    }
+			    // ForEachDownloadRange reports full tracker pages, and every exact GPU-owned
+			    // interval on those pages was downloaded and removed. Clearing the original
+			    // query therefore cannot orphan a dirty sibling on an edge page.
+			    m_memory_tracker.UnmarkRegionAsGpuModified(retire.address, retire.size);
+			    if (m_memory_tracker.IsRegionGpuModified(retire.address, retire.size) ||
+			        !m_gpu_modified_ranges.Intersections(retire.address, retire.size).empty()) {
+				    EXIT("BufferCache: asynchronous garbage collection retained GPU ownership\n");
+			    }
+			    m_memory_tracker.UntrackMemory(retire.address, retire.size);
 		    }
-		    // ForEachDownloadRange reports full tracker pages, and every exact GPU-owned
-		    // interval on those pages was downloaded and removed. Clearing the original
-		    // query therefore cannot orphan a dirty sibling on an edge page.
-		    m_memory_tracker.UnmarkRegionAsGpuModified(retire.address, retire.size);
-		    if (m_memory_tracker.IsRegionGpuModified(retire.address, retire.size) ||
-		        !m_gpu_modified_ranges.Intersections(retire.address, retire.size).empty()) {
-			    EXIT("BufferCache: asynchronous garbage collection retained GPU ownership\n");
-		    }
-		    m_memory_tracker.UntrackMemory(retire.address, retire.size);
 	    });
 }

 BufferCache::BufferCache(GraphicContext& graphics, CommandScheduler& scheduler,
-                         PageManager& page_manager, TextureCache& texture_cache)
+                         PageManager& page_manager, TextureCache& texture_cache,
+                         ResourceMutex& resource_mutex)
    : m_graphics(graphics), m_scheduler(scheduler),
      m_gds_buffer(graphics, scheduler, MemoryUsage::Stream, 0, AllFlags, GdsBufferSize),
      m_memory_tracker(page_manager),
@@ -194,7 +226,7 @@ BufferCache::BufferCache(GraphicContext& graphics, CommandScheduler& scheduler,
      m_stream_buffer(graphics, scheduler, MemoryUsage::Stream, 64 * MiB),
      m_download_buffer(graphics, scheduler, MemoryUsage::Download, 32 * MiB),
      m_device_buffer(graphics, scheduler, MemoryUsage::DeviceLocal, 128 * MiB),
-      m_texture_cache(texture_cache) {
+      m_texture_cache(texture_cache), m_resource_mutex(resource_mutex) {
 	std::memset(m_gds_buffer.Mapped().data(), 0, static_cast<size_t>(m_gds_buffer.Size()));
 	m_gds_buffer.Flush(0, m_gds_buffer.Size());
 	if (!m_graphics.CanReportMemoryUsage()) {
@@ -252,77 +284,58 @@ void BufferCache::InvalidateMemory(uint64_t vaddr, uint64_t size) {
 	    size > TRACKER_ADDRESS_SIZE - vaddr) {
 		EXIT("BufferCache: invalid memory-invalidation range\n");
 	}
+	if (!HasPageOverlap(vaddr, size)) {
+		return;
+	}
 	m_memory_tracker.InvalidateRegion(vaddr, size,
-	                                  [this, vaddr, size] { ReadMemory(vaddr, size, true); });
+	                                  [this, vaddr, size] { ReadMemory(vaddr, size); });
 }

-void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size, bool is_write) {
-	if (Gpu::IsGpuThread()) {
-		ReadMemoryOnGpu(vaddr, size, is_write);
-		return;
-	}
-	if (CommandScheduler::InDeferredOperation()) {
-		EXIT("unsupported buffer readback from an asynchronous GPU completion, "
-		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
-		     vaddr, size);
-	}
-	m_scheduler.Context().GetGpu().SendCommandSync(
-	    [this, vaddr, size, is_write] { ReadMemoryOnGpu(vaddr, size, is_write); });
-}
-
-void BufferCache::ReadMemoryOnGpu(uint64_t vaddr, uint64_t size, bool is_write) {
-	// CPU invalidation reaches this point only for a GPU-owned tracker page. Resolve the exact
-	// Buffer owner on the GPU thread so the cache index remains single-thread-owned.
-	if (is_write && !IsRegionRegistered(vaddr, size)) {
-		return;
-	}
+void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size) {
 	std::vector<DownloadCopy> copies;
-	m_memory_tracker.ForEachDownloadRange<false>(
-	    vaddr, size,
-	    [&](uint64_t address, uint64_t bytes) noexcept {
-		    m_memory_tracker.ValidateGpuDirtyPages(m_gpu_modified_ranges, address, bytes,
-		                                           "memory invalidation");
-	    },
-	    [&](uint64_t address, uint64_t bytes) noexcept {
-		    for (const auto range: m_gpu_modified_ranges.Intersections(address, bytes)) {
-			    for (uint64_t copied = 0; copied < range.size;) {
-				    const auto copy_address = range.address + copied;
-				    auto       owner        = m_buffers.upper_bound(copy_address);
-				    if (owner == m_buffers.begin()) {
-					    EXIT("BufferCache: invalidation readback has no buffer owner\n");
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		m_memory_tracker.ForEachDownloadRange<false>(
+		    vaddr, size,
+		    [&](uint64_t address, uint64_t bytes) noexcept {
+			    m_memory_tracker.ValidateGpuDirtyPages(m_gpu_modified_ranges, address, bytes,
+			                                           "memory invalidation");
+		    },
+		    [&](uint64_t address, uint64_t bytes) noexcept {
+			    for (const auto range: m_gpu_modified_ranges.Intersections(address, bytes)) {
+				    for (uint64_t copied = 0; copied < range.size;) {
+					    const auto copy_address = range.address + copied;
+					    auto       owner        = m_buffers.upper_bound(copy_address);
+					    if (owner == m_buffers.begin()) {
+						    EXIT("BufferCache: invalidation readback has no buffer owner\n");
+					    }
+					    auto& cached = *std::prev(owner)->second;
+					    if (!cached.buffer->IsInBounds(copy_address, 1)) {
+						    EXIT(
+						        "BufferCache: invalidation readback is outside its buffer owner\n");
+					    }
+					    const auto copy_size = std::min(range.size - copied,
+					                                    cached.vaddr + cached.size - copy_address);
+					    copies.push_back({cached.buffer, cached.buffer->Offset(copy_address),
+					                      copy_address, copy_size});
+					    copied += copy_size;
 				    }
-				    auto& cached = *std::prev(owner)->second;
-				    if (!cached.buffer->IsInBounds(copy_address, 1)) {
-					    EXIT("BufferCache: invalidation readback is outside its buffer owner\n");
-				    }
-				    const auto copy_size =
-				        std::min(range.size - copied, cached.vaddr + cached.size - copy_address);
-				    copies.push_back({cached.buffer, cached.buffer->Offset(copy_address),
-				                      copy_address, copy_size});
-				    copied += copy_size;
 			    }
-		    }
-	    });
+		    });
+	}
 	if (copies.empty()) {
-		if (!is_write) {
-			return;
-		}
-		// A preceding read fault can consume the last GPU-owned copy after this write invalidation
-		// has already chosen to flush. Complete the CPU ownership handoff even though this callback
-		// no longer has bytes to download.
-		m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
 		return;
 	}
 	auto downloads = RecordDownloads(copies);
 	m_scheduler.FinishCurrent();
 	PublishDownloads(downloads);
-	for (const auto& range: downloads) {
-		m_gpu_modified_ranges.Subtract(range.address, range.size);
-	}
-	// The enumeration above covered whole dirty pages and every exact interval on them.
-	m_memory_tracker.UnmarkRegionAsGpuModified(vaddr, size);
-	if (is_write) {
-		m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		for (const auto& range: downloads) {
+			m_gpu_modified_ranges.Subtract(range.address, range.size);
+		}
+		// The enumeration above covered whole dirty pages and every exact interval on them.
+		m_memory_tracker.UnmarkRegionAsGpuModified(vaddr, size);
 	}
 }

@@ -333,40 +346,43 @@ void BufferCache::UnmapMemory(uint64_t vaddr, uint64_t size) {
 	std::vector<DownloadCopy>                  copies;
 	std::vector<std::pair<uint64_t, uint64_t>> modified_buffers;
 	std::vector<std::pair<uint64_t, uint64_t>> retired_buffers;
-	for (const auto& [begin, cached]: m_buffers) {
-		if (vaddr < begin + cached->size && begin < vaddr + size) {
-			retired_buffers.emplace_back(begin, cached->size);
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		for (const auto& [begin, cached]: m_buffers) {
+			if (vaddr < begin + cached->size && begin < vaddr + size) {
+				retired_buffers.emplace_back(begin, cached->size);
+			}
 		}
-	}
-	for (const auto& [begin, cached]: m_buffers) {
-		if (vaddr >= begin + cached->size || begin >= vaddr + size ||
-		    !m_memory_tracker.IsRegionGpuModified(begin, cached->size)) {
-			continue;
+		for (const auto& [begin, cached]: m_buffers) {
+			if (vaddr >= begin + cached->size || begin >= vaddr + size ||
+			    !m_memory_tracker.IsRegionGpuModified(begin, cached->size)) {
+				continue;
+			}
+			const auto dirty = m_gpu_modified_ranges.Intersections(begin, cached->size);
+			if (dirty.empty()) {
+				EXIT("BufferCache: GPU-modified buffer has no dirty ranges\n");
+			}
+			modified_buffers.emplace_back(begin, cached->size);
 		}
-		const auto dirty = m_gpu_modified_ranges.Intersections(begin, cached->size);
-		if (dirty.empty()) {
-			EXIT("BufferCache: GPU-modified buffer has no dirty ranges\n");
+		for (const auto& [begin, bytes]: modified_buffers) {
+			auto owner = m_buffers.find(begin);
+			if (owner == m_buffers.end() || owner->second->size != bytes) {
+				EXIT("BufferCache: unmap owner changed during collection\n");
+			}
+			auto& cached = *owner->second;
+			m_memory_tracker.ForEachDownloadRange<false>(
+			    begin, cached.size,
+			    [&](uint64_t address, uint64_t bytes) noexcept {
+				    m_memory_tracker.ValidateGpuDirtyPages(m_gpu_modified_ranges, address, bytes,
+				                                           "unmap");
+			    },
+			    [&](uint64_t address, uint64_t bytes) noexcept {
+				    for (const auto& range: m_gpu_modified_ranges.Intersections(address, bytes)) {
+					    copies.push_back(
+					        {cached.buffer, range.address - begin, range.address, range.size});
+				    }
+			    });
 		}
-		modified_buffers.emplace_back(begin, cached->size);
-	}
-	for (const auto& [begin, bytes]: modified_buffers) {
-		auto owner = m_buffers.find(begin);
-		if (owner == m_buffers.end() || owner->second->size != bytes) {
-			EXIT("BufferCache: unmap owner changed during collection\n");
-		}
-		auto& cached = *owner->second;
-		m_memory_tracker.ForEachDownloadRange<false>(
-		    begin, cached.size,
-		    [&](uint64_t address, uint64_t bytes) noexcept {
-			    m_memory_tracker.ValidateGpuDirtyPages(m_gpu_modified_ranges, address, bytes,
-			                                           "unmap");
-		    },
-		    [&](uint64_t address, uint64_t bytes) noexcept {
-			    for (const auto& range: m_gpu_modified_ranges.Intersections(address, bytes)) {
-				    copies.push_back(
-				        {cached.buffer, range.address - begin, range.address, range.size});
-			    }
-		    });
 	}
 	if (!copies.empty()) {
 		auto downloads = RecordDownloads(copies);
@@ -377,26 +393,29 @@ void BufferCache::UnmapMemory(uint64_t vaddr, uint64_t size) {
 		// command stream before removing such backing.
 		m_scheduler.FinishCurrent();
 	}
-	for (const auto& [begin, bytes]: modified_buffers) {
-		m_gpu_modified_ranges.Subtract(begin, bytes);
-		m_memory_tracker.UnmarkRegionAsGpuModified(begin, bytes);
-	}
-	for (const auto& [begin, bytes]: retired_buffers) {
-		m_memory_tracker.MarkRegionAsCpuModified(begin, bytes);
-	}
-	if (!m_gpu_modified_ranges.Intersections(vaddr, size).empty()) {
-		EXIT("BufferCache: unmap retained dirty byte ranges\n");
-	}
-	m_memory_tracker.UntrackMemory(vaddr, size);
-	for (auto it = m_buffers.begin(); it != m_buffers.end();) {
-		if (vaddr < it->first + it->second->size && it->first < vaddr + size) {
-			if (it->second->size > m_total_used_memory) {
-				EXIT("BufferCache: allocation accounting underflow\n");
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		for (const auto& [begin, bytes]: modified_buffers) {
+			m_gpu_modified_ranges.Subtract(begin, bytes);
+			m_memory_tracker.UnmarkRegionAsGpuModified(begin, bytes);
+		}
+		for (const auto& [begin, bytes]: retired_buffers) {
+			m_memory_tracker.MarkRegionAsCpuModified(begin, bytes);
+		}
+		if (!m_gpu_modified_ranges.Intersections(vaddr, size).empty()) {
+			EXIT("BufferCache: unmap retained dirty byte ranges\n");
+		}
+		m_memory_tracker.UntrackMemory(vaddr, size);
+		for (auto it = m_buffers.begin(); it != m_buffers.end();) {
+			if (vaddr < it->first + it->second->size && it->first < vaddr + size) {
+				if (it->second->size > m_total_used_memory) {
+					EXIT("BufferCache: allocation accounting underflow\n");
+				}
+				m_total_used_memory -= it->second->size;
+				it = m_buffers.erase(it);
+			} else {
+				++it;
 			}
-			m_total_used_memory -= it->second->size;
-			it = m_buffers.erase(it);
-		} else {
-			++it;
 		}
 	}
 }
@@ -478,6 +497,7 @@ BufferBinding BufferCache::ObtainBuffer(CommandBuffer& command, uint64_t vaddr,
 	if (command.IsInvalid() || command.IsExecute()) {
 		EXIT("BufferCache: buffer request requires a recording command buffer\n");
 	}
+	std::lock_guard transaction(m_resource_mutex);

 	if (is_read && !is_written && size <= CACHING_PAGE_SIZE &&
 	    !m_memory_tracker.IsRegionGpuModified(vaddr, size) &&
@@ -504,6 +524,7 @@ BufferBinding BufferCache::ObtainBuffer(CommandBuffer& command, uint64_t vaddr,
 		(void)m_texture_cache.InvalidateMemoryFromGPU(vaddr, size, true);
 	}

+	FaultSafeCacheLock                         lock(this, m_mutex);
 	auto&                                      cached = GetOrCreateBuffer(command, vaddr, size);
 	std::vector<std::pair<uint64_t, uint64_t>> uploads;
 	m_memory_tracker.ForEachUploadRange(
@@ -518,23 +539,26 @@ BufferBinding BufferCache::ObtainBuffer(CommandBuffer& command, uint64_t vaddr,
 	if (is_written) {
 		m_gpu_modified_ranges.Add(vaddr, size);
 	}
-	auto     owner  = cached.buffer;
-	uint64_t offset = cached.buffer->Offset(vaddr);
 	if (is_formatted && is_read && !is_written) {
-		(void)SynchronizeBufferFromImage(*owner, vaddr, size);
+		(void)SynchronizeBufferFromImage(*cached.buffer, vaddr, size);
 	}
-	return {owner, owner->Handle(), offset};
+	return {cached.buffer, cached.buffer->Handle(), cached.buffer->Offset(vaddr)};
 }

 std::shared_ptr<Buffer> BufferCache::ObtainNullBuffer() {
-	if (m_null_buffer != nullptr) {
-		return m_null_buffer;
+	std::shared_ptr<Buffer> buffer;
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		if (m_null_buffer != nullptr) {
+			return m_null_buffer;
+		}
+		m_null_buffer = std::make_shared<Buffer>(m_graphics, m_scheduler, MemoryUsage::DeviceLocal,
+		                                         0, AllFlags, 16);
+		buffer        = m_null_buffer;
 	}
-	m_null_buffer = std::make_shared<Buffer>(m_graphics, m_scheduler, MemoryUsage::DeviceLocal, 0,
-	                                         AllFlags, 16);
 	const std::array<uint8_t, 16> zeros {};
-	Upload(m_scheduler.Current(), *m_null_buffer, 0, zeros.data(), zeros.size());
-	return m_null_buffer;
+	Upload(m_scheduler.Current(), *buffer, 0, zeros.data(), zeros.size());
+	return buffer;
 }

 ImageBufferSource BufferCache::ObtainBufferForImage(uint64_t vaddr, uint64_t size) {
@@ -552,10 +576,11 @@ ImageBufferSource BufferCache::ObtainBufferForImage(uint64_t vaddr, uint64_t siz
 	};

 	{
-		const bool cpu_modified            = m_memory_tracker.IsRegionCpuModified(vaddr, size);
-		const bool gpu_modified            = m_memory_tracker.IsRegionGpuModified(vaddr, size);
-		const auto dirty                   = m_gpu_modified_ranges.Intersections(vaddr, size);
-		const bool has_dirty_buffer_source = !dirty.empty();
+		FaultSafeCacheLock lock(this, m_mutex);
+		const bool         cpu_modified = m_memory_tracker.IsRegionCpuModified(vaddr, size);
+		const bool         gpu_modified = m_memory_tracker.IsRegionGpuModified(vaddr, size);
+		const auto         dirty        = m_gpu_modified_ranges.Intersections(vaddr, size);
+		const bool         has_dirty_buffer_source = !dirty.empty();
 		m_memory_tracker.ValidateGpuDirtyOwnership(m_gpu_modified_ranges, vaddr, size,
 		                                           "image source");

@@ -626,9 +651,10 @@ ImageBufferSource BufferCache::ObtainBufferForImage(uint64_t vaddr, uint64_t siz
 	}
 	m_staging_buffer.Commit();

-	const auto dirty                   = m_gpu_modified_ranges.Intersections(vaddr, size);
-	const bool has_dirty_buffer_source = !dirty.empty();
-	auto       owner                   = find_owner();
+	FaultSafeCacheLock lock(this, m_mutex);
+	const auto         dirty                   = m_gpu_modified_ranges.Intersections(vaddr, size);
+	const bool         has_dirty_buffer_source = !dirty.empty();
+	auto               owner                   = find_owner();
 	if (has_dirty_buffer_source && owner == m_buffers.end()) {
 		EXIT("BufferCache: GPU-dirty image source lost its native owner\n");
 	}
@@ -661,7 +687,8 @@ void BufferCache::WriteHostMemory(uint64_t vaddr, std::span<const uint8_t> data)
 	}
 	Libs::LibKernel::Memory::WriteBacking(vaddr, data.data(), data.size());

-	const auto end = vaddr + data.size();
+	FaultSafeCacheLock lock(this, m_mutex);
+	const auto         end = vaddr + data.size();
 	for (auto& [address, cached]: m_buffers) {
 		const auto cached_end = address + cached->size;
 		const auto begin      = std::max(vaddr, address);
@@ -691,7 +718,8 @@ void BufferCache::FillBuffer(uint64_t vaddr, uint64_t size, uint32_t value, bool
 	}
 	(void)m_texture_cache.ClearMeta(vaddr);
 	{
-		const auto region = m_texture_cache.QueryRegion(vaddr, size);
+		std::lock_guard transaction(m_resource_mutex);
+		const auto      region = m_texture_cache.QueryRegion(vaddr, size);
 		if (!HasGpuDirtyBytes(vaddr, size) && !region.gpu_image_bytes) {
 			if (region.image_bytes) {
 				m_texture_cache.InvalidateMemory(vaddr, size);
@@ -722,15 +750,16 @@ void BufferCache::CopyBuffer(uint64_t dst_vaddr, uint64_t src_vaddr, uint64_t si
 	const bool dst_memory = !dst_gds;
 	const bool src_memory = !src_gds;
 	if ((dst_memory && dst_vaddr == 0) || (src_memory && src_vaddr == 0) || size == 0 ||
-	    ((dst_gds || src_gds) && ((dst_vaddr | src_vaddr | size) & 3u) != 0) ||
-	    size > UINT64_MAX - dst_vaddr || size > UINT64_MAX - src_vaddr || (dst_gds && src_gds) ||
+	    ((dst_vaddr | src_vaddr | size) & 3u) != 0 || size > UINT64_MAX - dst_vaddr ||
+	    size > UINT64_MAX - src_vaddr || (dst_gds && src_gds) ||
 	    (dst_gds == src_gds && src_vaddr < dst_vaddr + size && dst_vaddr < src_vaddr + size) ||
 	    (dst_gds && (dst_vaddr > m_gds_buffer.Size() || size > m_gds_buffer.Size() - dst_vaddr)) ||
 	    (src_gds && (src_vaddr > m_gds_buffer.Size() || size > m_gds_buffer.Size() - src_vaddr))) {
 		EXIT("BufferCache: invalid or overlapping copy range\n");
 	}
 	if (src_memory || dst_memory) {
-		const auto src_region =
+		std::lock_guard transaction(m_resource_mutex);
+		const auto      src_region =
 		    src_memory ? m_texture_cache.QueryRegion(src_vaddr, size) : TextureCache::RegionInfo {};
 		const auto dst_region =
 		    dst_memory ? m_texture_cache.QueryRegion(dst_vaddr, size) : TextureCache::RegionInfo {};
@@ -781,19 +810,18 @@ void BufferCache::CopyBuffer(uint64_t dst_vaddr, uint64_t src_vaddr, uint64_t si
 	destination.CopyFrom(command, source, src.offset, dst.offset, size);
 }

-bool BufferCache::IsRegionRegistered(uint64_t vaddr, uint64_t size) {
+bool BufferCache::HasPageOverlap(uint64_t vaddr, uint64_t size) {
 	if (vaddr == 0 || size == 0 || vaddr >= TRACKER_ADDRESS_SIZE ||
 	    size > TRACKER_ADDRESS_SIZE - vaddr) {
-		EXIT("BufferCache: invalid registered-region query\n");
+		EXIT("BufferCache: invalid page-overlap query\n");
 	}
-	// Cached buffers are ordered and non-overlapping. The last buffer beginning before the query
-	// end is therefore the only possible intersection.
-	const auto candidate = m_buffers.lower_bound(vaddr + size);
-	if (candidate == m_buffers.begin()) {
-		return false;
+	FaultSafeCacheLock lock(this, m_mutex);
+	for (const auto& [address, cached]: m_buffers) {
+		if (PageOverlaps(vaddr, size, address, cached->size)) {
+			return true;
+		}
 	}
-	const auto& [address, cached] = *std::prev(candidate);
-	return address + cached->size > vaddr;
+	return false;
 }

 bool BufferCache::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
@@ -801,6 +829,7 @@ bool BufferCache::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
 }

 bool BufferCache::HasGpuDirtyBytes(uint64_t vaddr, uint64_t size) {
+	FaultSafeCacheLock lock(this, m_mutex);
 	return !m_gpu_modified_ranges.Intersections(vaddr, size).empty();
 }

@@ -809,7 +838,8 @@ bool BufferCache::IsRegionCpuModified(uint64_t vaddr, uint64_t size) {
 }

 void BufferCache::RunGarbageCollector() {
-	const auto tick = m_gc_tick++;
+	std::lock_guard transaction(m_resource_mutex);
+	const auto      tick = m_gc_tick++;
 	if (m_graphics.CanReportMemoryUsage()) {
 		m_total_used_memory = m_graphics.GetDeviceMemoryUsage();
 	}
@@ -824,6 +854,7 @@ void BufferCache::RunGarbageCollector() {
 	std::vector<RetiredBuffer>                                       retires;
 	std::vector<std::pair<RetiredBuffer, std::vector<DownloadCopy>>> dirty_retires;
 	{
+		FaultSafeCacheLock    lock(this, m_mutex);
 		std::vector<uint64_t> candidates;
 		for (const auto& [address, owner]: m_buffers) {
 			const auto& cached = *owner;
@@ -871,6 +902,7 @@ void BufferCache::RunGarbageCollector() {
 		QueueGarbageDownload(copies, std::move(retire));
 	}

+	FaultSafeCacheLock lock(this, m_mutex);
 	for (const auto& retire: retires) {
 		auto found = m_buffers.find(retire.address);
 		if (found == m_buffers.end() || found->second->size != retire.size ||
@@ -3,6 +3,7 @@

 #include "common/abi.h"
 #include "common/common.h"
+#include "common/threads.h"
 #include "graphics/host_gpu/memoryTracker.h"
 #include "graphics/host_gpu/rangeSet.h"
 #include "graphics/host_gpu/renderer/cache/streamBuffer.h"
@@ -19,6 +20,7 @@ struct GraphicContext;
 class CommandBuffer;
 class CommandScheduler;
 class TextureCache;
+class ResourceMutex;

 struct BufferBinding {
 	std::shared_ptr<void> owner;
@@ -39,12 +41,12 @@ public:
 	}

 	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);
+	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,
@@ -59,8 +61,7 @@ public:
 	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);
-	// Cache-index and exact dirty-range queries require GPU-thread serialization.
-	[[nodiscard]] bool IsRegionRegistered(uint64_t vaddr, uint64_t size);
+	[[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);
@@ -83,6 +84,8 @@ private:
 	[[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);
 	[[nodiscard]] static bool ResolveOverlap(CacheRange& merged, CacheRange candidate) noexcept;
 	void Upload(CommandBuffer& command, Buffer& destination, uint64_t destination_offset,
@@ -94,11 +97,11 @@ private:
 	void PublishDownloads(std::span<const DownloadRange> downloads);
 	void QueueGarbageDownload(std::span<const DownloadCopy> copies, RetiredBuffer retire);
 	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;
 	Buffer                                            m_gds_buffer;
+	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;
@@ -108,6 +111,7 @@ private:
 	StreamBuffer                                      m_download_buffer;
 	StreamBuffer                                      m_device_buffer;
 	TextureCache&                                     m_texture_cache;
+	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;
@@ -1,13 +1,15 @@
 #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_scheduler(scheduler),
+      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,21 +18,69 @@ 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;
 }

@@ -57,6 +107,11 @@ void GpuResourceManager::UnmapMemory(uint64_t vaddr, uint64_t size) {
 		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
 		     vaddr, size);
 	}
+	if (m_resource_mutex.IsOwnedByCurrentThread()) {
+		EXIT("unsupported memory unmap from a pre-owned resource transaction, "
+		     "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();
@@ -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>
@@ -34,6 +35,7 @@ public:

 private:
 	PageManager               m_page_manager;
+	ResourceMutex             m_resource_mutex;
 	CommandScheduler&         m_scheduler;
 	BufferCache               m_buffer_cache;
 	TextureCache              m_texture_cache;
@@ -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) ||
+		    (!strict_bytes && !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_
@@ -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
@@ -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_
@@ -8,6 +8,7 @@
 #include "graphics/guest_gpu/tile.h"
 #include "graphics/host_gpu/graphicContext.h"
 #include "graphics/host_gpu/renderer/cache/bufferCache.h"
+#include "graphics/host_gpu/renderer/cache/resourceMutex.h"
 #include "graphics/host_gpu/renderer/commandScheduler.h"
 #include "graphics/host_gpu/renderer/image/imageView.h"
 #include "graphics/host_gpu/renderer/image/textureCommon.h"
@@ -55,12 +56,13 @@ private:
 } // namespace

 TextureCache::TextureCache(GraphicContext& graphics, CommandScheduler& scheduler,
-                           PageManager& page_manager, BufferCache& buffer_cache)
+                           PageManager& page_manager, BufferCache& buffer_cache,
+                           ResourceMutex& resource_mutex)
    : m_graphics(graphics), m_scheduler(scheduler), m_page_manager(page_manager),
      m_blit_helper(graphics, scheduler),
      m_tiler(std::make_unique<TileManager>(graphics, scheduler,
                                            buffer_cache.GetUtilityBuffer(MemoryUsage::Stream))),
-      m_buffer_cache(buffer_cache),
+      m_buffer_cache(buffer_cache), m_resource_mutex(resource_mutex),
      m_readback_linear_images(Config::ReadbackLinearImagesEnabled()) {
 	if (m_graphics.CanReportMemoryUsage()) {
 		constexpr int64_t GiB = 1024ll * 1024 * 1024;
@@ -193,12 +195,10 @@ void TextureCache::RegisterImage(ImageId id) {
 	if (image.registered || image.info.data.Empty()) {
 		EXIT("TextureCache: invalid image registration\n");
 	}
-	ImagePageTable::PageRange pages {};
-	if (!ImagePageTable::TryGetPageRange(image.info.data.address, image.info.data.size, pages)) {
-		EXIT("TextureCache: image registration is outside the guest address space\n");
-	}
-	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
-		m_image_page_table[page].push_back(id);
+	std::vector<ImageOwnerIndex::ByteRange> ranges;
+	ranges.push_back({image.info.data.address, image.info.data.size});
+	if (!m_image_owner_index.Register(id, ranges)) {
+		EXIT("TextureCache: duplicate or invalid image registration\n");
 	}
 	image.registered = true;
 	image.lru_id     = m_lru_cache.Insert(id, m_gc_tick);
@@ -211,15 +211,9 @@ void TextureCache::UnregisterImage(ImageId id) {
 		return;
 	}
 	UntrackImage(id);
-	ImagePageTable::PageRange pages {};
-	if (!ImagePageTable::TryGetPageRange(image.info.data.address, image.info.data.size, pages)) {
-		EXIT("TextureCache: registered image is outside the guest address space\n");
-	}
-	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
-		auto* owners = m_image_page_table.Find(page);
-		if (owners == nullptr || !owners->Erase(id)) {
-			EXIT("TextureCache: image missing from page owner index\n");
-		}
+	std::vector<ImageOwnerIndex::ByteRange> releases;
+	if (!m_image_owner_index.Unregister(id, releases)) {
+		EXIT("TextureCache: image missing from owner index\n");
 	}
 	m_lru_cache.Free(image.lru_id);
 	const auto accounted = image.AccountedSize();
@@ -432,8 +426,9 @@ void TextureCache::UntrackImageTail(ImageId id) {
 }

 void TextureCache::TrackImageDownload(ImageId id) {
-	CacheLock lock(*this, m_lock);
-	auto&     image = ResolveImage(id);
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
+	auto&           image = ResolveImage(id);
 	TrackImageDownloadLocked(id, image);
 }

@@ -456,48 +451,10 @@ const Image& TextureCache::GetImage(ImageId id) const {
 	return ResolveImage(id);
 }

-TextureCache::ImageIds TextureCache::FindImagesInRegion(uint64_t address, uint64_t size,
-                                                        bool page_overlap) const {
-	ImagePageTable::PageRange pages {};
-	if (!ImagePageTable::TryGetPageRange(address, size, pages)) {
-		return {};
-	}
-
-	uint32_t query_epoch = ++m_image_query_epoch;
-	if (query_epoch == 0) {
-		for (const auto& slot: m_slots) {
-			if (slot.image != nullptr) {
-				slot.image->query_epoch = 0;
-			}
-		}
-		query_epoch = ++m_image_query_epoch;
-	}
-
-	ImageIds result;
-	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
-		const auto* owners = m_image_page_table.Find(page);
-		if (owners == nullptr) {
-			continue;
-		}
-		owners->ForEach([&](ImageId id) {
-			if (!id || id.index >= m_slots.size()) {
-				return;
-			}
-			const auto& slot = m_slots[id.index];
-			if (slot.generation != id.generation || slot.image == nullptr) {
-				return;
-			}
-			auto& image = *slot.image;
-			if (image.query_epoch == query_epoch) {
-				return;
-			}
-			image.query_epoch = query_epoch;
-			if (image.Overlaps(address, size, page_overlap)) {
-				result.push_back(id);
-			}
-		});
-	}
-	return result;
+std::vector<ImageId> TextureCache::FindImagesInRegion(uint64_t address, uint64_t size,
+                                                      bool page_overlap) const {
+	return page_overlap ? m_image_owner_index.QueryCandidates(address, size)
+	                    : m_image_owner_index.Query(address, size);
 }

 ImageId TextureCache::GetNullImage(const ImageDesc& desc) {
@@ -881,20 +838,11 @@ struct TextureCache::ColorTransferPlan {
 	TextureUploadLayout              layout;
 	std::vector<vk::BufferImageCopy> regions;
 	std::vector<GpuTileInfo>         tiles;
-	uint64_t                         linear_size = 0;
 	bool                             tiled       = false;
 	bool                             swap_bgra16 = false;
 	bool                             valid       = false;
 };

-static uint64_t GetLinearSize(std::span<const GpuTileInfo> tiles) {
-	uint64_t size = 0;
-	for (const auto& tile: tiles) {
-		size = std::max(size, tile.linear_offset + tile.linear_size);
-	}
-	return size;
-}
-
 struct TextureCache::DownloadPlan {
 	ColorTransferPlan color;
 	bool              depth = false;
@@ -908,6 +856,7 @@ TextureCache::BuildColorTransfer(const Image& image, BindingType binding,
 	uint32_t    format           = info.guest_format;
 	uint32_t    layers           = info.TransferLayers();
 	bool        volume           = info.IsVolume();
+	bool        layered          = info.IsLayered();
 	bool        allow_depth_tile = direction == TransferDirection::Upload;
 	const char* owner =
 	    direction == TransferDirection::Upload ? "TextureCache" : "TextureCache readback";
@@ -936,6 +885,7 @@ TextureCache::BuildColorTransfer(const Image& image, BindingType binding,
 				format           = info.guest_format;
 				layers           = info.resources.layers;
 				volume           = false;
+				layered          = layers > 1;
 				allow_depth_tile = false;
 				plan.swap_bgra16 = info.bgra16;
 				owner            = "VideoOut";
@@ -953,18 +903,22 @@ TextureCache::BuildColorTransfer(const Image& image, BindingType binding,
 		plan.swap_bgra16 = info.bgra16;
 	}

-	plan.layout  = TextureCalcUploadLayout(format, info.extent.width, info.extent.height,
-	                                       info.resources.levels, layers, info.tile_mode,
-	                                       info.data.size, allow_depth_tile, volume, owner);
-	plan.regions = TextureBuildImageCopies(plan.layout);
-	plan.tiled   = static_cast<Prospero::TileMode>(plan.layout.surface.description.tile_mode) !=
-	               Prospero::TileMode::kLinear;
+	plan.layout = TextureCalcUploadLayout(format, info.extent.width, info.extent.height,
+	                                      info.resources.levels, layers, info.pitch, info.tile_mode,
+	                                      info.data.size, allow_depth_tile, volume, owner);
+	plan.regions = TextureBuildImageCopies(plan.layout, info.extent.width, info.extent.height,
+	                                       layers, info.resources.levels, layered, volume);
+	plan.tiled   = static_cast<Prospero::TileMode>(plan.layout.tile) != Prospero::TileMode::kLinear;
 	if (plan.tiled) {
-		if (!TextureBuildGpuTileInfos(info.data.size, plan.regions, plan.layout,
+		// CMASK/FMASK decoding is intentionally deferred.
+		if (plan.layout.tile_family == TileBlockFamily::Depth64KB &&
+		    Prospero::IsFmaskTextureFormat(format)) {
+			return plan;
+		}
+		if (!TextureBuildGpuTileInfos(info.data.size, plan.regions, plan.layout, format, layers,
 		                              info.resources.levels, plan.tiles)) {
 			return plan;
 		}
-		plan.linear_size = GetLinearSize(plan.tiles);
 	}
 	plan.valid = true;
 	return plan;
@@ -1002,20 +956,11 @@ void TextureCache::UploadImage(Image& image, const ImageDesc& desc, Buffer& sour

 	if (desc.type != BindingType::DepthTarget) {
 		auto plan = BuildColorTransfer(image, desc.type, TransferDirection::Upload);
-		if (!plan.valid) {
-			EXIT("TextureCache: invalid color upload: binding=%u addr=0x%016" PRIx64
-			     " size=0x%016" PRIx64 " format=%u tile=%u family=%u extent=%ux%ux%u "
-			     "pitch=%u levels=%u layers=%u samples=%u\n",
-			     static_cast<uint32_t>(desc.type), info.data.address, info.data.size,
-			     info.guest_format, info.tile_mode,
-			     static_cast<uint32_t>(plan.layout.surface.texture.block.family), info.extent.width,
-			     info.extent.height, info.extent.depth, info.pitch, info.resources.levels,
-			     info.resources.layers, info.samples);
-		}
+		EXIT_NOT_IMPLEMENTED(!plan.valid);
 		TileManager::Result linear {source.Handle(), source_offset, info.data.size};
 		if (plan.tiled) {
-			linear = m_tiler->Detile(source.Handle(), source_offset, info.data.size,
-			                         plan.linear_size, plan.tiles);
+			linear = m_tiler->Detile(source.Handle(), source_offset, info.data.size, info.data.size,
+			                         plan.tiles);
 		}
 		if (plan.swap_bgra16) {
 			linear = m_tiler->SwapBgra16(linear);
@@ -1143,7 +1088,8 @@ void TextureCache::RefreshImage(ImageId id, const ImageDesc& desc) {
 }

 void TextureCache::AssociateStencil(ImageId depth_id, GuestRange stencil) {
-	CacheLock lock(*this, m_lock);
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
 	AssociateStencilLocked(depth_id, stencil);
 }

@@ -1186,9 +1132,11 @@ ImageId TextureCache::FindImage(ImageDesc& desc, bool exact_format) {
 	}

 	ImageId result {};
+	bool    inserted_new = false;
 	{
-		CacheLock  lock(*this, m_lock);
-		const auto candidates =
+		std::lock_guard            transaction(m_resource_mutex);
+		CacheLock                  lock(*this, m_lock);
+		const std::vector<ImageId> candidates =
 		    FindImagesInRegion(desc.info.data.address, desc.info.data.size, false);

 		for (const auto id: candidates) {
@@ -1231,12 +1179,19 @@ ImageId TextureCache::FindImage(ImageDesc& desc, bool exact_format) {
 		}
 		if (!result) {
 			result         = InsertImage(desc.info);
+			inserted_new   = true;
 			auto& inserted = ResolveImage(result);
 			if (m_buffer_cache.HasGpuDirtyBytes(inserted.info.data.address,
 			                                    inserted.info.data.size)) {
 				inserted.MarkBufferModified();
 			}
 		}
+		if (inserted_new) {
+			InitializeImage(result, desc);
+		} else {
+			RefreshImage(result, desc);
+		}
+
 		auto& image = ResolveImage(result);
 		if (desc.type == BindingType::VideoOut &&
 		    desc.info.metadata.compression != VideoOutCompression::Uncompressed) {
@@ -1261,13 +1216,6 @@ ImageId TextureCache::FindImage(ImageDesc& desc, bool exact_format) {
 	return result;
 }

-void TextureCache::UpdateImage(ImageId id) {
-	CacheLock lock(*this, m_lock);
-	auto&     image = ResolveImage(id);
-	TouchImage(image);
-	RefreshImage(id, ImageDesc {.info = image.info, .type = UploadBinding(image)});
-}
-
 ImageId TextureCache::FindImageFromRange(uint64_t address, uint64_t size, bool ensure_valid) {
 	if (!GuestRange {address, size}.Valid()) {
 		return {};
@@ -1312,24 +1260,22 @@ ImageId TextureCache::FindImageFromRange(uint64_t address, uint64_t size, bool e
 }

 vk::ImageView TextureCache::FindTexture(ImageId id, const ImageDesc& desc) {
-	CacheLock lock(*this, m_lock);
-	auto&     image = ResolveImage(id);
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
+	auto&           image = ResolveImage(id);
 	TouchImage(image);
 	if (!image.info.data.Empty()) {
 		if (!image.registered || image.depth_id || image.binding.needs_rebind) {
 			EXIT("TextureCache: texture requires rediscovery before final acquisition\n");
 		}
-	}
-	if (desc.type == BindingType::Storage) {
-		image.MarkGpuModified();
-	}
-	if (!image.info.data.Empty()) {
 		RefreshImage(id, desc);
 	}
 	switch (desc.type) {
 		case BindingType::Texture: break;
 		case BindingType::Storage:
-			if (!image.info.data.Empty()) {
+			if (image.info.data.Empty()) {
+				image.MarkGpuModified();
+			} else {
 				if (!image.registered || image.depth_id) {
 					EXIT("TextureCache: cannot acquire an unavailable storage image\n");
 				}
@@ -1348,16 +1294,16 @@ vk::ImageView TextureCache::FindRenderTarget(ImageId id, const ImageDesc& desc)
 	if (desc.type != BindingType::RenderTarget) {
 		EXIT("TextureCache: invalid color-target binding\n");
 	}
-	CacheLock lock(*this, m_lock);
-	auto&     image = ResolveImage(id);
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
+	auto&           image = ResolveImage(id);
 	if (!image.registered || image.depth_id || image.binding.needs_rebind) {
 		EXIT("TextureCache: color target requires rediscovery before final acquisition\n");
 	}
 	TouchImage(image);
-	image.MarkGpuModified();
-	image.usage.render_target = true;
 	RefreshImage(id, desc);
 	CommitGpuWrite(image);
+	image.usage.render_target = true;
 	TrackImageDownloadLocked(id, image);
 	const auto view = image.FindView(desc.view_info);
 	RetainImage(m_scheduler.Current(), id);
@@ -1368,14 +1314,13 @@ vk::ImageView TextureCache::FindDepthTarget(ImageId id, const ImageDesc& desc) {
 	if (desc.type != BindingType::DepthTarget) {
 		EXIT("TextureCache: invalid depth-target binding\n");
 	}
-	CacheLock lock(*this, m_lock);
-	auto&     image = ResolveImage(id);
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
+	auto&           image = ResolveImage(id);
 	if (!image.registered || image.depth_id || image.binding.needs_rebind) {
 		EXIT("TextureCache: depth target requires rediscovery before final acquisition\n");
 	}
 	TouchImage(image);
-	image.MarkGpuModified();
-	image.usage.depth_target = true;
 	RefreshImage(id, desc);
 	if (desc.info.HasMetadata()) {
 		image.info.metadata = desc.info.metadata;
@@ -1383,6 +1328,7 @@ vk::ImageView TextureCache::FindDepthTarget(ImageId id, const ImageDesc& desc) {
 		                            MetaDataInfo {.clear_mask = image.info.htile_clear_mask});
 	}
 	CommitGpuWrite(image);
+	image.usage.depth_target = true;
 	if (desc.info.HasStencil()) {
 		AssociateStencilLocked(id, desc.info.stencil);
 	}
@@ -1392,8 +1338,9 @@ vk::ImageView TextureCache::FindDepthTarget(ImageId id, const ImageDesc& desc) {
 }

 void TextureCache::MarkGpuWritten(ImageId id) {
-	CacheLock lock(*this, m_lock);
-	auto&     image = ResolveImage(id);
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
+	auto&           image = ResolveImage(id);
 	if (!image.registered || image.depth_id) {
 		EXIT("TextureCache: cannot mark an unavailable image GPU-written\n");
 	}
@@ -1417,6 +1364,7 @@ bool TextureCache::ClearImageFromBuffer(CommandBuffer& command, uint64_t address
 	if (command.IsInvalid() || !GuestRange {address, size}.Valid()) {
 		EXIT("TextureCache: invalid image clear\n");
 	}
+	std::lock_guard      transaction(m_resource_mutex);
 	CacheLock            lock(*this, m_lock);
 	ImageId              selected {};
 	vk::ImageAspectFlags aspect {};
@@ -1618,7 +1566,7 @@ void TextureCache::DownloadImageData(Image& image, Buffer& destination, uint64_t
 	}

 	m_tiler->TileImage(image, color.regions, destination.Handle(), destination_offset,
-	                   destination_size, color.linear_size, color.tiles, transform);
+	                   destination_size, destination_size, color.tiles, transform);
 }

 bool BufferCache::SynchronizeBufferFromImage(Buffer& buffer, uint64_t vaddr, uint64_t size) {
@@ -1701,12 +1649,16 @@ bool BufferCache::SynchronizeBufferFromImage(Buffer& buffer, uint64_t vaddr, uin
 			return false;
 		}
 		if (color.tiled) {
+			const auto binding = m_texture_cache.UploadBinding(image);
+			const auto format =
+			    binding == TextureCache::BindingType::RenderTarget
+			        ? ImageOps::RenderTargetTransferFormat(image.info.bytes_per_block)
+			        : image.info.guest_format;
 			color.tiles.clear();
-			if (!TextureBuildGpuTileInfos(copy_size, color.regions, color.layout, levels,
-			                              color.tiles)) {
+			if (!TextureBuildGpuTileInfos(copy_size, color.regions, color.layout, format,
+			                              image.info.TransferLayers(), levels, color.tiles)) {
 				return false;
 			}
-			color.linear_size = GetLinearSize(color.tiles);
 		}
 	}
 	m_texture_cache.DownloadImageData(image, buffer, buf_offset, copy_size, std::move(plan));
@@ -1874,8 +1826,9 @@ bool TextureCache::IsMetaCleared(uint64_t address, uint32_t slice) {
 }

 bool TextureCache::ClearMeta(uint64_t address) {
-	CacheLock  lock(*this, m_lock);
-	const auto found = m_surface_metas.find(address);
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
+	const auto      found = m_surface_metas.find(address);
 	if (found == m_surface_metas.end()) {
 		return false;
 	}
@@ -1901,8 +1854,9 @@ void TextureCache::UnmapMemory(uint64_t address, uint64_t size) {
 	if (!GuestRange {address, size}.Valid()) {
 		EXIT("TextureCache: invalid unmap range\n");
 	}
-	CacheLock lock(*this, m_lock);
-	auto      images = FindImagesInRegion(address, size, false);
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
+	auto            images = FindImagesInRegion(address, size, false);
 	if (!images.empty()) {
 		m_scheduler.Finish();
 	}
@@ -1919,8 +1873,9 @@ void TextureCache::UnmapMemory(uint64_t address, uint64_t size) {
 }

 void TextureCache::RunGarbageCollector() {
-	CacheLock      lock(*this, m_lock);
-	const uint64_t tick = m_gc_tick++;
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
+	const uint64_t  tick = m_gc_tick++;
 	if (m_graphics.CanReportMemoryUsage()) {
 		m_total_used_memory = m_graphics.GetDeviceMemoryUsage();
 	}
@@ -1980,7 +1935,8 @@ void TextureCache::RunGarbageCollector() {
 }

 void TextureCache::ProcessDownloadImages() {
-	CacheLock lock(*this, m_lock);
+	std::lock_guard transaction(m_resource_mutex);
+	CacheLock       lock(*this, m_lock);
 	for (const auto id: m_download_images) {
 		const auto owner = ResolveOwner(id);
 		if (owner != nullptr && owner->registered && owner->IsGpuModified()) {
@@ -26,6 +26,7 @@ class Buffer;
 class BufferCache;
 class CommandBuffer;
 class CommandScheduler;
+class ResourceMutex;
 class RenderExecutor;
 class StreamBuffer;
 class TileManager;
@@ -48,12 +49,11 @@ 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);
@@ -99,8 +99,7 @@ private:
 		int32_t layer = -1;
 	};

-	using ImageIds       = InlinePageOwnerList<ImageId, 16>;
-	using ImagePageTable = MultiLevelPageTable<ImageIds, 20, 40, 10>;
+	using ImageOwnerIndex = MultiRangePageOwnerIndex<ImageId>;

 	[[nodiscard]] Image&                 ResolveImage(ImageId id);
 	[[nodiscard]] const Image&           ResolveImage(ImageId id) const;
@@ -126,9 +125,8 @@ private:
 	[[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,
@@ -168,9 +166,10 @@ private:
 	BlitHelper                                        m_blit_helper;
 	std::unique_ptr<TileManager>                      m_tiler;
 	BufferCache&                                      m_buffer_cache;
+	ResourceMutex&                                    m_resource_mutex;
 	std::vector<Slot>                                 m_slots;
 	std::vector<uint32_t>                             m_free_slots;
-	ImagePageTable                                    m_image_page_table;
+	ImageOwnerIndex                                   m_image_owner_index;
 	std::map<vk::Format, ImageId>                     m_null_images;
 	Common::LeastRecentlyUsedCache<ImageId, uint64_t> m_lru_cache;
 	std::set<ImageId>                                 m_download_images;
@@ -178,10 +177,9 @@ private:
 	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;
@@ -178,10 +178,10 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, RenderCommandB
 		pitch = (rt.pitch.pitch_div8_minus1 + 1u) << 3u;
 	} else if (tile) {
 		if (volume) {
-			pitch = TileGetTexturePitch(transfer_format, width, rt.attrib3.tile_mode);
+			pitch = TileGetTexturePitch(transfer_format, width, levels, rt.attrib3.tile_mode);
 		} else if (standard64) {
 			pitch = TileGetTexturePitch(Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float),
-			                            width, rt.attrib3.tile_mode);
+			                            width, levels, rt.attrib3.tile_mode);
 		} else {
 			pitch = TileGetRenderTargetPitch(width, bytes_per_element, rt.attrib.num_fragments);
 		}
@@ -192,20 +192,13 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, RenderCommandB
 		pitch = width;
 	}

-	TileSizeOffset    mip_sizes[16] {};
-	TilePaddedSize    mip_padded[16] {};
-	TileSurfaceLayout volume_layout {};
-	uint64_t          backing_size = 0;
+	TileSizeOffset   mip_sizes[16] {};
+	TilePaddedSize   mip_padded[16] {};
+	TileVolumeLayout 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)) {
+		if (!tile || !TileGetTextureVolumeLayout(transfer_format, width, height, depth, levels,
+		                                         rt.attrib3.tile_mode, volume_layout)) {
 			EXIT("unsupported 3D render-target layout: %ux%ux%u levels=%u tile=%u\n", width, height,
 			     depth, levels, rt.attrib3.tile_mode);
 		}
@@ -216,7 +209,7 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, RenderCommandB
 		bool          valid_layout = false;
 		if (standard64) {
 			TileGetTextureSize(Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float), width,
-			                   height, levels, rt.attrib3.tile_mode, &layout, mip_sizes,
+			                   height, pitch, levels, rt.attrib3.tile_mode, &layout, mip_sizes,
 			                   mip_padded);
 			valid_layout = layout.size != 0 && layout.align == 65536;
 		} else {
@@ -296,12 +289,11 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, RenderCommandB
 	desc.info.tile_mode       = rt.attrib3.tile_mode;
 	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,
+			    volume_layout.level_offsets[level],
+			    volume_layout.level_sizes[level],
+			    volume_layout.level_widths[level],
+			    volume_layout.level_heights[level],
 			};
 			continue;
 		}
@@ -99,10 +99,7 @@ bool CommandScheduler::InDeferredOperation() noexcept {

 CommandScheduler::CommandScheduler(RenderContext& context, GraphicContext& graphics)
    : m_master(graphics), m_context(context), m_graphics(graphics),
-      m_priority_thread([this](std::stop_token stop) { PriorityOperationsThread(stop); }) {
-	m_buffers.reserve(CommandBufferGrowStep);
-	m_buffer_ticks.reserve(CommandBufferGrowStep);
-}
+      m_priority_thread([this](std::stop_token stop) { PriorityOperationsThread(stop); }) {}

 CommandScheduler::~CommandScheduler() {
 	Shutdown();
@@ -157,7 +154,10 @@ void CommandScheduler::Begin(HW::Context& registers, HW::UserConfig& user_config
 	m_shaders     = &shaders;

 	if (!Active()) {
-		m_current = static_cast<int>(GrowCommandBuffers());
+		for (auto& buffer: m_buffers) {
+			buffer = std::make_unique<RenderCommandBuffer>(*this);
+		}
+		m_current = 0;
 	}

 	BindCurrent();
@@ -235,13 +235,7 @@ void CommandScheduler::Wait(uint64_t tick) {
 }

 void CommandScheduler::PopPendingOperations() {
-	PopPendingOperations(true);
-}
-
-void CommandScheduler::PopPendingOperations(bool refresh_gpu_tick) {
-	if (refresh_gpu_tick) {
-		m_master.Refresh();
-	}
+	m_master.Refresh();
 	for (;;) {
 		Common::UniqueFunction<void> callback;
 		{
@@ -368,7 +362,7 @@ uint64_t CommandScheduler::NextSubmitSequence() noexcept {
 }

 void CommandScheduler::CheckActive() const {
-	EXIT_IF(!Active() || static_cast<size_t>(m_current) >= m_buffers.size());
+	EXIT_IF(!Active() || m_current >= BufferCount);
 }

 RenderCommandBuffer& CommandScheduler::Current() const {
@@ -390,52 +384,15 @@ CommandBuffer& CommandScheduler::SubmitCurrent(SubmitInfo& submit) {
 	const auto signal_tick = m_master.NextTick();
 	submit.AddSignal(m_master.Handle(), signal_tick);
 	submitted.Execute(submit);
-	m_buffer_ticks[static_cast<size_t>(m_current)] = signal_tick;
-	m_recording                                    = false;
+	m_recording = false;
 	return submitted;
 }

-int CommandScheduler::FindReusableBuffer(uint64_t gpu_tick) const {
-	EXIT_IF(m_buffer_ticks.size() != m_buffers.size());
-	const auto buffer_count = m_buffers.size();
-	for (size_t offset = 1; offset <= buffer_count; ++offset) {
-		const auto candidate = (static_cast<size_t>(m_current) + offset) % buffer_count;
-		if (gpu_tick >= m_buffer_ticks[candidate]) {
-			return static_cast<int>(candidate);
-		}
-	}
-	return -1;
-}
-
-size_t CommandScheduler::GrowCommandBuffers() {
-	const auto first = m_buffers.size();
-	const auto end   = first + CommandBufferGrowStep;
-	m_buffers.reserve(end);
-	m_buffer_ticks.reserve(end);
-	for (size_t i = first; i < end; ++i) {
-		m_buffers.emplace_back(std::make_unique<RenderCommandBuffer>(*this));
-		m_buffer_ticks.push_back(0);
-	}
-	return first;
-}
-
 void CommandScheduler::BeginNext() {
 	EXIT_IF(m_recording);
-
-	auto candidate = FindReusableBuffer(m_master.KnownGpuTick());
-	bool refreshed = false;
-	if (candidate < 0) {
-		m_master.Refresh();
-		refreshed = true;
-		candidate = FindReusableBuffer(m_master.KnownGpuTick());
-	}
-	if (candidate < 0) {
-		candidate = static_cast<int>(GrowCommandBuffers());
-	}
-
-	m_current = candidate;
+	m_current = (m_current + 1) % BufferCount;
 	Current().WaitForFenceAndReset();
-	PopPendingOperations(!refreshed);
+	PopPendingOperations();
 	BindCurrent();
 	Current().Begin();
 	m_recording = true;
@@ -16,7 +16,6 @@
 #include <queue>

 #include <thread>
-#include <vector>

 namespace Libs::Graphics {

@@ -32,6 +31,8 @@ struct CommandSlot {

 class CommandScheduler {
 public:
+	static constexpr int BufferCount = 8;
+
 	CommandScheduler(RenderContext& context, GraphicContext& graphics);
 	~CommandScheduler();
 	KYTY_CLASS_NO_COPY(CommandScheduler);
@@ -64,8 +65,6 @@ public:
 	[[nodiscard]] GraphicContext& Graphics() const noexcept { return m_graphics; }

 private:
-	static constexpr size_t CommandBufferGrowStep = 4;
-
 	class CommandPool {
 	public:
 		CommandPool() = default;
@@ -95,34 +94,30 @@ private:
 	void                       BindCurrent() const;
 	CommandBuffer&             SubmitCurrent(SubmitInfo& submit);
 	void                       BeginNext();
-	void                       PopPendingOperations(bool refresh_gpu_tick);
-	[[nodiscard]] int          FindReusableBuffer(uint64_t gpu_tick) const;
-	[[nodiscard]] size_t       GrowCommandBuffers();
 	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;
-	std::vector<std::unique_ptr<RenderCommandBuffer>> m_buffers;
-	std::vector<uint64_t>                             m_buffer_ticks;
-	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;
+	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;
 };
@@ -10,7 +10,6 @@
 #include "graphics/host_gpu/renderer/render.h"

 #include <algorithm>
-#include <array>
 #include <atomic>
 #include <cmath>
 #include <fmt/format.h>
@@ -687,6 +686,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) {
@@ -1060,24 +1067,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;
 		}
@@ -38,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;
@@ -52,17 +49,7 @@ 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");
 	}
 }

@@ -109,11 +96,9 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandB
 	const auto& dc = hw.GetDepthControl();
 	const auto& sc = hw.GetStencilControl();
 	const auto& sm = hw.GetStencilMask();
-	const bool  has_stencil =
-	    z.stencil_info.format != Prospero::GpuEnumValue(Prospero::StencilFormat::kInvalid);
-	const bool depth_active =
+	const bool  depth_active =
 	    dc.z_enable || dc.z_write_enable || dc.depth_bounds_enable || rc.depth_clear_enable;
-	const bool stencil_active = has_stencil && (dc.stencil_enable || rc.stencil_clear_enable);
+	const bool stencil_active = dc.stencil_enable || rc.stencil_clear_enable;
 	if (!depth_active && !stencil_active) {
 		return;
 	}
@@ -154,6 +139,8 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandB
 		}
 		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) {
@@ -169,8 +156,8 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandB
 			DepthFatal("invalid depth view: base=%u last=%u", z.depth_view.slice_start,
 			           z.depth_view.slice_max);
 	}
-	if (rc.resummarize_enable || rc.copy_centroid || rc.copy_sample != 0 ||
-	    z.z_info.expclear_enabled || z.stencil_info.expclear_enabled ||
+	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 ||
@@ -205,6 +192,8 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandB
 		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");
 	}
 	const bool size_xy_valid = z.size.valid;
 	const bool wh_valid      = z.width_height_valid && z.width != 0 && z.height != 0;
@@ -290,12 +279,10 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandB
 	r.depth_min_bounds         = hw.GetDepthBoundsMin();
 	r.depth_max_bounds         = hw.GetDepthBoundsMax();

-	r.stencil_clear_enable = has_stencil && rc.stencil_clear_enable;
+	r.stencil_clear_enable = rc.stencil_clear_enable;
 	r.stencil_clear_value  = hw.GetStencilClearValue();
-	r.stencil_test_enable  = has_stencil && dc.stencil_enable;
-	if (r.stencil_test_enable) {
-		const uint8_t front_write_mask = rc.stencil_clear_enable ? 0 : sm.stencil_writemask;
-		const uint8_t back_write_mask  = rc.stencil_clear_enable ? 0 : sm.stencil_writemask_bf;
+	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)) ||
@@ -307,18 +294,19 @@ void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandB
 			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;
@@ -663,8 +663,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;
 	}
@@ -154,18 +154,17 @@ public:
 	}
 	[[nodiscard]] uint64_t HashGuestEdges() const;

-	ImageInfo        info;
-	VulkanImage      backing;
-	ImageViewCache   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;
@@ -113,6 +113,13 @@ inline void ValidateStorageColorView(vk::Format image_format, vk::Format view_fo

 [[nodiscard]] inline bool
 IsSupportedStorageImageResource(const ShaderRecompiler::IR::ImageResource& resource) noexcept {
+	const bool supported_mip =
+	    (resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::None &&
+	     resource.mip_levels == 1u) ||
+	    (resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::DynamicStorage &&
+	     resource.mip_levels > 0u &&
+	     resource.mip_levels <= ShaderRecompiler::IR::ImageResource::MaxMipLevels &&
+	     !resource.read && !resource.atomic);
 	return (resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImage ||
 	        resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint) &&
 	       (resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim1D ||
@@ -120,7 +127,7 @@ IsSupportedStorageImageResource(const ShaderRecompiler::IR::ImageResource& resou
 	        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.written &&
+	       supported_mip && resource.written &&
 	       (!resource.atomic ||
 	        (resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint &&
 	         resource.read)) &&
@@ -22,10 +22,6 @@ struct RenderTargetFormatMapping {
 };

 constexpr RenderTargetFormatMapping kRenderTargetFormats[] = {
-    {Prospero::ChannelLayout::k8,
-     Prospero::ChannelType::kUInt,
-     Prospero::ChannelOrder::kStandard,
-     {vk::Format::eR8Uint, 1}},
    {Prospero::ChannelLayout::k8_8,
     Prospero::ChannelType::kUNorm,
     Prospero::ChannelOrder::kStandard,
@@ -168,6 +164,14 @@ RenderTargetFormatInfo TextureGetRenderTargetFormat(uint32_t raw_layout, uint32_

 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;
 }
@@ -180,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;
@@ -219,11 +237,12 @@ vk::Format TextureGetFormat(uint32_t fmt) {

 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) {
@@ -236,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) {
@@ -271,123 +303,141 @@ uint64_t SetLinearUploadLevels(TextureUploadMipLayout*         mips,

 } // namespace

-TextureUploadLayout TextureCalcUploadLayout(uint32_t fmt, uint32_t width, uint32_t height,
-                                            uint32_t levels, uint32_t depth, uint32_t tile,
-                                            uint64_t upload_size, bool allow_depth_tile,
-                                            bool volume_texture, const char* owner) {
+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 = {
-	    fmt,
-	    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   = static_cast<Prospero::TileMode>(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 (fmt == 0) {
-		EXIT("%s: legacy texture upload format unsupported: fmt=0 tile=%u size=%" PRIu64
-		     " extent=%ux%u levels=%u\n",
-		     owner, description.tile_mode, upload_size, width, height, levels);
-	}
-
-	switch (tile_mode) {
-		case Prospero::TileMode::kLinear:
-			if (!TileGetTextureElementLayout(fmt, element)) {
-				EXIT("%s: unsupported linear texture format: fmt=%u\n", owner, fmt);
+	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>(fmt), 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>(fmt), 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(fmt, width, description.tile_mode);
-	if (tile_mode == Prospero::TileMode::kLinear) {
-		TileSizeOffset level_sizes[16] {};
-		TilePaddedSize padded_sizes[16] {};
-		TileGetTextureSize(fmt, 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 && static_cast<Prospero::TileMode>(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       = static_cast<Prospero::TileMode>(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);
 		}
@@ -406,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;
@@ -414,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);
@@ -455,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 =
@@ -500,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);
 			}
 		}
@@ -19,32 +19,34 @@ struct RenderTargetFormatInfo {
 	Prospero::ColorComponentMapping export_mapping;
 };

-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);
 vk::Format             TextureGetFormat(uint32_t fmt);
 RenderTargetFormatInfo TextureGetRenderTargetFormat(uint32_t layout, uint32_t type, uint32_t order);
-TextureUploadLayout    TextureCalcUploadLayout(uint32_t fmt, uint32_t width, uint32_t height,
-                                               uint32_t levels, uint32_t depth, uint32_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);
+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,
+                                                         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

@@ -94,10 +94,11 @@ vk::DescriptorBufferInfo BufferInfo(const BufferView& view) {

 } // 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};
+vk::DescriptorImageInfo DescriptorCache::MakeImageInfo(const TextureBinding& texture,
+                                                       uint32_t              mip) {
+	const auto view = texture.mip_views.empty() ? texture.image_view : texture.mip_views.at(mip);
+	EXIT_IF(!texture.image_id || view == nullptr || texture.layout == vk::ImageLayout::eUndefined);
+	return {nullptr, view, texture.layout};
 }

 DescriptorCache::~DescriptorCache() {
@@ -154,7 +155,8 @@ void DescriptorCache::CreatePool() {
 	     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::eStorageImage, MaxSets * ShaderRecompiler::IR::ShaderInfo::MaxImages *
+	                                            ShaderRecompiler::IR::ImageResource::MaxMipLevels},
 	    {vk::DescriptorType::eSampler, MaxSets * ShaderRecompiler::IR::ShaderInfo::MaxSamplers},
 	};
 	vk::DescriptorPoolCreateInfo info {};
@@ -229,8 +231,10 @@ VulkanDescriptorSet& DescriptorCache::GetDescriptor(Stage
 	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;
+	uint32_t descriptor_count = 0;
+	for (const auto& binding: program.bindings.descriptors) {
+		descriptor_count += DescriptorCount(binding);
+	}
 	std::vector<vk::DescriptorBufferInfo> buffer_infos;
 	std::vector<vk::DescriptorImageInfo>  image_infos;
 	std::vector<vk::WriteDescriptorSet>   writes;
@@ -238,6 +242,7 @@ VulkanDescriptorSet& DescriptorCache::GetDescriptor(Stage
 	image_infos.reserve(descriptor_count);
 	writes.reserve(program.bindings.descriptors.size());

+	std::vector<uint32_t> image_mips(program.info.images.size());
 	for (const auto& binding: program.bindings.descriptors) {
 		vk::WriteDescriptorSet write {};
 		write.sType             = vk::StructureType::eWriteDescriptorSet;
@@ -273,7 +278,11 @@ VulkanDescriptorSet& DescriptorCache::GetDescriptor(Stage
 			default: {
 				for (const auto resource: binding.resources) {
 					const auto& texture = data.images.at(resource);
-					image_infos.push_back(MakeImageInfo(texture));
+					const auto  mip     = program.info.images.at(resource).mip_mode ==
+					                              ShaderRecompiler::IR::ImageMipMode::DynamicStorage
+					                          ? image_mips.at(resource)++
+					                          : 0u;
+					image_infos.push_back(MakeImageInfo(texture, mip));
 				}
 				break;
 			}
@@ -47,10 +47,11 @@ 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;
+		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 {
@@ -94,7 +95,7 @@ private:
 		int                next_free_pool = -1;
 	};

-	static vk::DescriptorImageInfo MakeImageInfo(const TextureBinding& texture);
+	static vk::DescriptorImageInfo MakeImageInfo(const TextureBinding& texture, uint32_t mip = 0);
 	void                           CreatePool();
 	VulkanDescriptorSet* Allocate(Stage stage, const ShaderRecompiler::IR::Program& program);
 	vk::DescriptorSetLayout
@@ -239,7 +239,7 @@ bool IsSupportedDepthTargetDescriptor(const ShaderTextureResource& descriptor, c
 	const auto samples      = multisampled ? 1u << descriptor.LastLevel() : 1u;
 	const auto pitch =
 	    multisampled ? TileGetDepthPitch(width, image.info.bytes_per_block, descriptor.LastLevel())
-	                 : TileGetTexturePitch(descriptor.Format(), width, descriptor.TileMode());
+	                 : TileGetTexturePitch(descriptor.Format(), width, 1, descriptor.TileMode());
 	const bool supported_2d    = type == Prospero::ImageType::kColor2D &&
 	                             image.info.resources.layers == 1 && descriptor.Depth() == 0 &&
 	                             descriptor.BaseArray5() == 0;
@@ -321,7 +321,7 @@ static void ValidateDepthTargetBinding(const ShaderRecompiler::IR::ImageResource
 		return;
 	}
 	const auto descriptor_pitch =
-	    TileGetTexturePitch(descriptor.Format(), static_cast<uint32_t>(descriptor.Width5()) + 1u,
+	    TileGetTexturePitch(descriptor.Format(), static_cast<uint32_t>(descriptor.Width5()) + 1u, 1,
 	                        descriptor.TileMode());
 	EXIT("unsupported sampled depth target: resource=%d descriptor=%d encoding=%d format=%d "
 	     "kind=%u dimension=%u mip_mode=%u read=%d written=%d atomic=%d compare=%d "
@@ -373,38 +373,34 @@ static bool IsSupportedStorageTextureDescriptor(const ShaderRecompiler::IR::Imag
 	const bool is_3d = resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim3D &&
 	                   descriptor.Type() == Prospero::GpuEnumValue(Prospero::ImageType::kColor3D) &&
 	                   descriptor.BaseArray5() == 0;
-	TileTextureBlockLayout tile_layout {};
-	bool                   supported_tile = false;
-	switch (static_cast<Prospero::TileMode>(tile)) {
-		case Prospero::TileMode::kLinear: supported_tile = true; break;
-		case Prospero::TileMode::kDepth:
-			supported_tile =
-			    !resource.read && !Prospero::IsFmaskTextureFormat(descriptor.Format()) &&
-			    (is_2d || is_2d_array) &&
-			    TileGetTextureBlockLayout(descriptor.Format(), tile, false, tile_layout);
-			break;
-		case Prospero::TileMode::kStandard256B:
-			supported_tile =
-			    (is_2d || is_2d_array) &&
-			    TileGetTextureBlockLayout(descriptor.Format(), tile, false, tile_layout);
-			break;
-		case Prospero::TileMode::kStandard4KB:
-		case Prospero::TileMode::kStandard64KB:
-			supported_tile =
-			    TileGetTextureBlockLayout(descriptor.Format(), tile, is_3d, tile_layout);
-			break;
-		case Prospero::TileMode::kRenderTarget:
-			supported_tile =
-			    TileGetTextureBlockLayout(descriptor.Format(), tile, false, tile_layout);
-			break;
-		default: break;
-	}
-	const auto swizzle = descriptor.DstSelXYZW();
+	TileBlockLayout depth_block {};
+	const auto      depth_bpe = Prospero::RenderTargetBytesPerElement(descriptor.Format());
+	const bool      supported_depth_tile =
+	    tile == Prospero::GpuEnumValue(Prospero::TileMode::kDepth) && !resource.read &&
+	    !Prospero::IsFmaskTextureFormat(descriptor.Format()) && (is_2d || is_2d_array) &&
+	    TileGetBlockLayout(TileBlockFamily::Depth64KB, depth_bpe, depth_block);
+	const bool supported_standard_tile =
+	    (tile == Prospero::GpuEnumValue(Prospero::TileMode::kStandard4KB) &&
+	     TileIsStandard4KBTextureSupported(descriptor.Format())) ||
+	    (tile == Prospero::GpuEnumValue(Prospero::TileMode::kStandard64KB) &&
+	     TileIsStandard64KBTextureSupported(descriptor.Format()));
+	const bool supported_tile = tile == Prospero::GpuEnumValue(Prospero::TileMode::kLinear) ||
+	                            tile == Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget) ||
+	                            supported_depth_tile || supported_standard_tile;
+	const auto swizzle        = descriptor.DstSelXYZW();
 	const bool supported_swizzle =
 	    IsValidImageSwizzle(swizzle) &&
 	    (swizzle == DstSel(4, 5, 6, 7) || !resource.read || resource.atomic);
+	const auto base_level = static_cast<uint32_t>(descriptor.BaseLevel());
+	const auto last_level = static_cast<uint32_t>(descriptor.LastLevel());
+	const auto mip_levels = last_level >= base_level ? last_level - base_level + 1u : 0u;
+	const bool dynamic_mip =
+	    resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::DynamicStorage;
+	const bool supported_mip_view = descriptor.BaseLevel() == 0 || is_1d || is_2d;
 	return (is_1d || is_1d_array || is_2d || is_2d_array || is_3d) && supported_tile &&
-	       descriptor.BaseLevel() == descriptor.LastLevel() &&
+	       supported_mip_view && mip_levels != 0u &&
+	       ((dynamic_mip && mip_levels == resource.mip_levels) ||
+	        (!dynamic_mip && descriptor.BaseLevel() == descriptor.LastLevel())) &&
 	       descriptor.LastLevel() <= descriptor.MaxMip() && descriptor.MinLod() == 0 &&
 	       supported_swizzle && descriptor.BCSwizzle() == 0 && !descriptor.MsaaDepth();
 }
@@ -505,20 +501,18 @@ static TextureCache::ImageDesc NullTextureDesc(const ShaderRecompiler::IR::Image

 static void PopulateTextureMipLayout(ImageInfo& info) {
 	if (info.IsVolume() && info.tile_mode != Prospero::GpuEnumValue(Prospero::TileMode::kLinear)) {
-		TileSurfaceLayout            surface {};
-		const TileSurfaceDescription description {
-		    info.guest_format,  info.tile_mode,    TileSurfaceDimension::Dim3D, info.extent.width,
-		    info.extent.height, info.extent.depth, info.resources.levels,       1};
-		if (!TileGetTiledTextureLayout(description, surface)) {
+		TileVolumeLayout volume {};
+		if (!TileGetTextureVolumeLayout(info.guest_format, info.extent.width, info.extent.height,
+		                                info.extent.depth, info.resources.levels, info.tile_mode,
+		                                volume)) {
 			EXIT("unsupported normalized volume texture layout\n");
 		}
 		for (uint32_t level = 0; level < info.resources.levels; level++) {
-			const auto& mip        = surface.mips[level];
 			info.mip_layout[level] = {
-			    mip.offset,
-			    mip.size,
-			    mip.padded_width,
-			    mip.padded_height,
+			    volume.level_offsets[level],
+			    volume.level_sizes[level],
+			    volume.level_widths[level],
+			    volume.level_heights[level],
 			};
 		}
 		return;
@@ -526,7 +520,7 @@ static void PopulateTextureMipLayout(ImageInfo& info) {

 	TileSizeOffset levels[16] {};
 	TilePaddedSize padded[16] {};
-	TileGetTextureSize(info.guest_format, info.extent.width, info.extent.height,
+	TileGetTextureSize(info.guest_format, info.extent.width, info.extent.height, info.pitch,
 	                   info.resources.levels, info.tile_mode, nullptr, levels, padded);
 	for (uint32_t level = 0; level < info.resources.levels; level++) {
 		const auto offset =
@@ -653,7 +647,10 @@ RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageResource&   reso
 	}
 	const auto samples = multisampled ? 1u << last_level : 1u;
 	const auto view_levels =
-	    multisampled ? 1u : static_cast<uint32_t>(last_level - base_level) + 1u;
+	    multisampled ||
+	            (storage && resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::DynamicStorage)
+	        ? 1u
+	        : static_cast<uint32_t>(last_level - base_level) + 1u;
 	const auto depth  = static_cast<uint32_t>(descriptor.Depth()) + 1u;
 	const auto format = descriptor.Format();
 	const bool sampled_numeric_class =
@@ -684,9 +681,9 @@ RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageResource&   reso
 		}
 		size.size *= image_layers;
 	} else {
-		pitch = TileGetTexturePitch(format, width, tile);
-		TileGetTextureTotalSize(format, width, height, volume ? depth : image_layers, levels, tile,
-		                        volume, size);
+		pitch = TileGetTexturePitch(format, width, levels, tile);
+		TileGetTextureTotalSize(format, width, height, volume ? depth : image_layers, pitch, levels,
+		                        tile, volume, size);
 	}
 	EXIT_NOT_IMPLEMENTED(size.size == 0 || size.align == 0 ||
 	                     (address & (static_cast<uint64_t>(size.align) - 1u)) != 0);
@@ -908,7 +905,17 @@ void RenderExecutor::RebindImages(CommandBuffer&                     buffer,
 		}
 		auto& binding      = images[i];
 		binding.image_view = texture_cache.FindTexture(binding.image_id, binding.desc);
-		auto&      image   = texture_cache.GetImage(binding.image_id);
+		auto& image        = texture_cache.GetImage(binding.image_id);
+		binding.mip_views.clear();
+		if (program.info.images[i].mip_mode == ShaderRecompiler::IR::ImageMipMode::DynamicStorage) {
+			binding.mip_views.reserve(program.info.images[i].mip_levels);
+			for (uint32_t mip = 0; mip < program.info.images[i].mip_levels; mip++) {
+				auto view = binding.desc.view_info;
+				view.base_level += mip;
+				view.level_count = 1;
+				binding.mip_views.push_back(mip == 0 ? binding.image_view : image.FindView(view));
+			}
+		}
 		const bool storage = binding.desc.type == TextureCache::BindingType::Storage;
 		image.usage.storage |= storage;
 		image.usage.texture |= !storage;
@@ -933,21 +940,22 @@ RenderExecutor::PrepareGraphicsBindings(CommandBuffer& buffer, const ShaderStage
 	return bindings;
 }

-static void RetainBindings(CommandBuffer& buffer, DescriptorCache::NativeDescriptors& resources) {
+static void RetainBindings(CommandBuffer&                            buffer,
+                           const DescriptorCache::NativeDescriptors& resources) {
 	if (resources.flattened_srt.owner != nullptr) {
-		buffer.RetainResourceUntilFence(std::move(resources.flattened_srt.owner));
+		buffer.RetainResourceUntilFence(resources.flattened_srt.owner);
 	}
 	if (resources.user_data.owner != nullptr) {
-		buffer.RetainResourceUntilFence(std::move(resources.user_data.owner));
+		buffer.RetainResourceUntilFence(resources.user_data.owner);
 	}
-	for (auto& view: resources.buffers) {
+	for (const auto& view: resources.buffers) {
 		if (view.owner != nullptr) {
-			buffer.RetainResourceUntilFence(std::move(view.owner));
+			buffer.RetainResourceUntilFence(view.owner);
 		}
 	}
-	for (auto& view: resources.addresses) {
+	for (const auto& view: resources.addresses) {
 		if (view.owner != nullptr) {
-			buffer.RetainResourceUntilFence(std::move(view.owner));
+			buffer.RetainResourceUntilFence(view.owner);
 		}
 	}
 }
@@ -985,7 +993,11 @@ void RenderExecutor::CommitBindings(CommandBuffer&                     buffer,
 		auto&       image   = m_context.GetTextureCache().GetImage(descriptors.images[i].image_id);
 		auto&       binding = descriptors.images[i];
 		const auto& view    = binding.desc.view_info;
-		const ImageSubresourceRange range {view.base_level, view.level_count, view.base_layer,
+		const auto  level_count =
+		    program.info.images[i].mip_mode == ShaderRecompiler::IR::ImageMipMode::DynamicStorage
+		        ? program.info.images[i].mip_levels
+		        : view.level_count;
+		const ImageSubresourceRange range {view.base_level, level_count, view.base_layer,
 		                                   view.layer_count};
 		const bool storage = binding.desc.type == TextureCache::BindingType::Storage;
 		if (image.info.data.Empty()) {
@@ -154,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++) {
@@ -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);

@@ -100,21 +84,6 @@ bool HasShaderBufferWrites(const ShaderStageRuntime& 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);
-}
-
 void ShaderWriteBarrier(vk::CommandBuffer vk_buffer, vk::PipelineStageFlags source_stages) {
 	EXIT_IF(vk_buffer == nullptr || !source_stages);
 	const auto barrier = MakeShaderWriteDependency();
@@ -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::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
@@ -14,7 +14,6 @@
 #include "graphics/host_gpu/renderer/renderTarget.h"
 #include "graphics/host_gpu/vulkanCommon.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
-#include "graphics/shader/rectListShader.h"
 #include "graphics/shader/shader.h"

 #include <algorithm>
@@ -464,12 +463,8 @@ void CreatePipelineInternal(
    uint32_t ps_hash0, uint32_t ps_crc32, bool ps_active) {
 	EXIT_IF(ps_active && ps_input_info == nullptr);

-	const bool rect_list = static_params.topology == vk::PrimitiveTopology::ePatchList;
-
-	vk::ShaderModule vert_shader_module         = nullptr;
-	vk::ShaderModule tess_control_shader_module = nullptr;
-	vk::ShaderModule tess_eval_shader_module    = nullptr;
-	vk::ShaderModule frag_shader_module         = nullptr;
+	vk::ShaderModule vert_shader_module = nullptr;
+	vk::ShaderModule frag_shader_module = nullptr;

 	vk::ShaderModuleCreateInfo create_info {};

@@ -496,33 +491,8 @@ void CreatePipelineInternal(
 		}
 		EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
 	}
-	if (rect_list) {
-		const auto shaders =
-		    BuildRectListShaders(vs_input_info, ps_active ? ps_input_info : nullptr);
-		create_info.codeSize = shaders.control.size() * 4;
-		create_info.pCode    = shaders.control.data();
-		result =
-		    graphics.device.createShaderModule(&create_info, nullptr, &tess_control_shader_module);
-		if (graphics_debug_dump_enabled()) {
-			LOGF("PipelineTrace: vkCreateShaderModule RectList TCS done result=%s module=%p\n",
-			     VulkanToString(result).c_str(), static_cast<void*>(tess_control_shader_module));
-		}
-		EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
-
-		create_info.codeSize = shaders.evaluation.size() * 4;
-		create_info.pCode    = shaders.evaluation.data();
-		result =
-		    graphics.device.createShaderModule(&create_info, nullptr, &tess_eval_shader_module);
-		if (graphics_debug_dump_enabled()) {
-			LOGF("PipelineTrace: vkCreateShaderModule RectList TES done result=%s module=%p\n",
-			     VulkanToString(result).c_str(), static_cast<void*>(tess_eval_shader_module));
-		}
-		EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
-	}

 	EXIT_NOT_IMPLEMENTED(vert_shader_module == nullptr);
-	EXIT_NOT_IMPLEMENTED(
-	    rect_list && (tess_control_shader_module == nullptr || tess_eval_shader_module == nullptr));
 	EXIT_NOT_IMPLEMENTED(ps_active && frag_shader_module == nullptr);

 	vk::PipelineShaderStageCreateInfo                     vert_shader_stage_info {};
@@ -555,28 +525,9 @@ void CreatePipelineInternal(
 		                      frag_shader_stage_info);
 	}

-	vk::PipelineShaderStageCreateInfo tess_control_shader_stage_info {};
-	tess_control_shader_stage_info.sType  = vk::StructureType::ePipelineShaderStageCreateInfo;
-	tess_control_shader_stage_info.stage  = vk::ShaderStageFlagBits::eTessellationControl;
-	tess_control_shader_stage_info.module = tess_control_shader_module;
-	tess_control_shader_stage_info.pName  = "main";
-
-	vk::PipelineShaderStageCreateInfo tess_eval_shader_stage_info {};
-	tess_eval_shader_stage_info.sType  = vk::StructureType::ePipelineShaderStageCreateInfo;
-	tess_eval_shader_stage_info.stage  = vk::ShaderStageFlagBits::eTessellationEvaluation;
-	tess_eval_shader_stage_info.module = tess_eval_shader_module;
-	tess_eval_shader_stage_info.pName  = "main";
-
-	vk::PipelineShaderStageCreateInfo shader_stages[4]   = {};
-	uint32_t                          shader_stage_count = 0;
-	shader_stages[shader_stage_count++]                  = vert_shader_stage_info;
-	if (rect_list) {
-		shader_stages[shader_stage_count++] = tess_control_shader_stage_info;
-		shader_stages[shader_stage_count++] = tess_eval_shader_stage_info;
-	}
-	if (ps_active) {
-		shader_stages[shader_stage_count++] = frag_shader_stage_info;
-	}
+	vk::PipelineShaderStageCreateInfo shader_stages[]    = {vert_shader_stage_info,
+	                                                        frag_shader_stage_info};
+	const uint32_t                    shader_stage_count = ps_active ? 2u : 1u;

 	vk::VertexInputAttributeDescription input_attr[ShaderVertexInputInfo::RES_MAX];
 	vk::VertexInputBindingDescription   input_desc[ShaderVertexInputInfo::RES_MAX];
@@ -947,23 +898,15 @@ void CreatePipelineInternal(
 	    vk::DynamicState::eViewport,
 	    vk::DynamicState::eScissor,
 	    vk::DynamicState::eLineWidth,
-	    vk::DynamicState::eDepthBiasEnable,
-	    vk::DynamicState::eDepthBias,
 	    vk::DynamicState::eStencilCompareMask,
 	    vk::DynamicState::eStencilReference,
 	    vk::DynamicState::eStencilWriteMask,
 #if !defined(__APPLE__)
-	    // Keep last so depth-only pipelines can omit this dynamic state.
 	    vk::DynamicState::eColorWriteEnableEXT, // unsupported by MoltenVK; static mask instead
 #endif
 	};
-	auto dynamic_states_count =
+	const auto dynamic_states_count =
 	    static_cast<uint32_t>(sizeof(dynamic_states) / sizeof(dynamic_states[0]));
-#if !defined(__APPLE__)
-	if (static_params.color_count == 0) {
-		dynamic_states_count--;
-	}
-#endif

 	vk::PipelineDynamicStateCreateInfo dynamic_state {};
 	dynamic_state.sType             = vk::StructureType::ePipelineDynamicStateCreateInfo;
@@ -986,13 +929,10 @@ void CreatePipelineInternal(
 	pipeline_info.pStages                  = shader_stages;
 	pipeline_info.pVertexInputState        = &vertex_input_info;
 	pipeline_info.pInputAssemblyState      = &input_assembly;
-	vk::PipelineTessellationStateCreateInfo tessellation_state {};
-	tessellation_state.sType              = vk::StructureType::ePipelineTessellationStateCreateInfo;
-	tessellation_state.patchControlPoints = 3;
-	pipeline_info.pTessellationState      = (rect_list ? &tessellation_state : nullptr);
-	pipeline_info.pViewportState          = &viewport_state;
-	pipeline_info.pRasterizationState     = &rasterizer;
-	pipeline_info.pMultisampleState       = &multisampling;
+	pipeline_info.pTessellationState       = nullptr;
+	pipeline_info.pViewportState           = &viewport_state;
+	pipeline_info.pRasterizationState      = &rasterizer;
+	pipeline_info.pMultisampleState        = &multisampling;
 	pipeline_info.pDepthStencilState = (static_params.with_depth ? &depth_stencil_info : nullptr);
 	pipeline_info.pColorBlendState   = &color_blending;
 	pipeline_info.pDynamicState      = &dynamic_state;
@@ -1028,12 +968,6 @@ void CreatePipelineInternal(
 	if (frag_shader_module != nullptr) {
 		graphics.device.destroyShaderModule(frag_shader_module, nullptr);
 	}
-	if (tess_control_shader_module != nullptr) {
-		graphics.device.destroyShaderModule(tess_control_shader_module, nullptr);
-	}
-	if (tess_eval_shader_module != nullptr) {
-		graphics.device.destroyShaderModule(tess_eval_shader_module, nullptr);
-	}
 	graphics.device.destroyShaderModule(vert_shader_module, nullptr);
 }

@@ -325,6 +325,9 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, RenderCommandBuffer& buf

 	auto vk_buffer = buffer.Handle();
 	CommitBindings(buffer, vk::PipelineBindPoint::eCompute, pipeline.pipeline_layout, bindings);
+	vk_buffer.bindPipeline(vk::PipelineBindPoint::eCompute, pipeline.pipeline);
+	vk_buffer.dispatch(thread_group_x, thread_group_y, thread_group_z);
+
 	bool has_storage_writes = HasShaderBufferWrites(input_info.stage);
 	has_storage_writes =
 	    std::any_of(program.info.images.begin(), program.info.images.end(),
@@ -335,15 +338,8 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, RenderCommandBuffer& buf
 	                }) ||
 	    has_storage_writes;
 	if (has_storage_writes) {
-		// A host fence used to serialize every dispatch. Preserve its read-before-write ordering
-		// while allowing the queue to execute asynchronously.
-		ShaderWriteHazardBarrier(vk_buffer, vk::PipelineStageFlagBits::eComputeShader);
+		ShaderWriteBarrier(vk_buffer, vk::PipelineStageFlagBits::eComputeShader);
 	}
-	vk_buffer.bindPipeline(vk::PipelineBindPoint::eCompute, pipeline.pipeline);
-	vk_buffer.dispatch(thread_group_x, thread_group_y, thread_group_z);
-
-	// The removed host fence also ordered read-only dispatches before later writers.
-	ShaderAccessBarrier(vk_buffer, vk::PipelineStageFlagBits::eComputeShader);
 	ResetBindings();
 }

@@ -2,6 +2,7 @@

 #include "common/assert.h"
 #include "common/common.h"
+#include "common/emulatorConfig.h"
 #include "common/file.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
@@ -64,32 +65,12 @@ int32_t ResolveVertexOffset(uint32_t index_offset, const ShaderVertexInputInfo&
 	return 0;
 }

-static std::atomic<uint32_t> g_draw_state_log_count   = 0;
-static std::atomic<uint32_t> g_draw_input_log_count   = 0;
-static std::atomic<uint32_t> g_mrt_state_log_count    = 0;
-static std::atomic<uint32_t> g_shader_stage_log_count = 0;
-
+static std::atomic<uint32_t> g_draw_state_log_count       = 0;
+static std::atomic<uint32_t> g_draw_input_log_count       = 0;
+static std::atomic<uint32_t> g_mrt_state_log_count        = 0;
+static std::atomic<uint32_t> g_shader_stage_log_count     = 0;
 static std::atomic<uint32_t> g_framebuffer_skip_log_count = 0;

-static float ConvertPolygonOffsetConstantFactor(float guest_factor, const HW::PolyOffset& offset,
-                                                vk::Format host_depth_format) {
-	if (offset.db_is_float_fmt) {
-		return guest_factor;
-	}
-
-	int host_depth_bits = 0;
-	switch (host_depth_format) {
-		case vk::Format::eD16Unorm:
-		case vk::Format::eD16UnormS8Uint: host_depth_bits = 16; break;
-		case vk::Format::eD24UnormS8Uint: host_depth_bits = 24; break;
-		default:
-			// A fixed-point guest bias cannot be represented exactly by a floating-point host
-			// attachment without VK_EXT_depth_bias_control.
-			return guest_factor;
-	}
-	return std::ldexp(guest_factor, host_depth_bits + offset.neg_num_db_bits);
-}
-
 static const char* RenderColorTypeName(RenderColorType type) {
 	switch (type) {
 		case RenderColorType::NoColorOutput: return "NoColorOutput";
@@ -355,22 +336,6 @@ static PipelineDynamicParameters BuildGraphicsDynamicParams(const RenderCommandB
 	ret.stencil_front      = depth.stencil_dynamic_front;
 	ret.stencil_back       = depth.stencil_dynamic_back;

-	const auto& mode        = ctx.GetModeControl();
-	const auto& poly_offset = ctx.GetPolyOffset();
-	const bool  use_front   = mode.poly_offset_front_enable && !mode.cull_front;
-	const bool  use_back    = mode.poly_offset_back_enable && !mode.cull_back;
-	ret.depth_bias_enable   = use_front || use_back;
-	if (ret.depth_bias_enable) {
-		// Vulkan has one bias for both faces. Prefer a visible front face when both are enabled.
-		const float guest_constant_factor =
-		    use_front ? poly_offset.front_offset : poly_offset.back_offset;
-		ret.depth_bias_constant_factor =
-		    ConvertPolygonOffsetConstantFactor(guest_constant_factor, poly_offset, depth.format);
-		ret.depth_bias_clamp = poly_offset.clamp;
-		ret.depth_bias_slope_factor =
-		    (use_front ? poly_offset.front_scale : poly_offset.back_scale) / 16.0f;
-	}
-
 	// CB_COLOR_CONTROL.operation controls special CB operations, not the normal color component
 	// write mask. Use CB_TARGET_MASK here so scanout passes with mode=Disable do not go black.
 	for (uint32_t i = 0; i < RENDER_COLOR_ATTACHMENTS_MAX; i++) {
@@ -415,13 +380,6 @@ static void SetDynamicParams(const RenderCommandBuffer& buffer, vk::CommandBuffe
 	}
 	vk_buffer.setLineWidth(line_width);

-	vk_buffer.setDepthBiasEnable(dynamic_params.depth_bias_enable ? VK_TRUE : VK_FALSE);
-	if (dynamic_params.depth_bias_enable) {
-		vk_buffer.setDepthBias(dynamic_params.depth_bias_constant_factor,
-		                       dynamic_params.depth_bias_clamp,
-		                       dynamic_params.depth_bias_slope_factor);
-	}
-
 	if (dynamic_params.stencil_test_enable) {
 		vk_buffer.setStencilCompareMask(vk::StencilFaceFlagBits::eFront,
 		                                dynamic_params.stencil_front.compareMask);
@@ -692,9 +650,11 @@ static bool ConsumeMetadataColorOperation(const RenderCommandBuffer& buffer) {
 }

 struct DrawEmitInfo {
-	bool     indexed       = false;
-	int32_t  vertex_offset = 0;
-	uint32_t first_vertex  = 0;
+	bool     indexed           = false;
+	bool     draw_prim7_as_ngg = false;
+	uint32_t draw_vertex_count = 0;
+	int32_t  vertex_offset     = 0;
+	uint32_t first_vertex      = 0;
 };

 struct DrawIndexBufferSource {
@@ -707,10 +667,12 @@ struct DrawIndexBufferSource {

 struct PreparedIndexBuffer {
 	std::shared_ptr<void> owner;
-	vk::Buffer            buffer = nullptr;
-	uint64_t              size   = 0;
-	vk::DeviceSize        offset = 0;
-	vk::IndexType         type   = vk::IndexType::eUint16;
+	vk::Buffer            buffer   = nullptr;
+	uint64_t              address  = 0;
+	uint64_t              size     = 0;
+	vk::DeviceSize        offset   = 0;
+	vk::IndexType         type     = vk::IndexType::eUint16;
+	bool                  streamed = false;
 };

 static uint64_t VertexBufferDescriptorSize(const ShaderVertexInputBuffer& buffer) {
@@ -727,24 +689,11 @@ struct VertexBufferRange {
 	[[nodiscard]] uint64_t RequestedSize() const { return requested_end - base_address; }
 };

-struct PreparedVertexBuffers {
-	static constexpr uint32_t MaxBuffers = ShaderVertexInputInfo::RES_MAX;
-
-	std::array<vk::Buffer, MaxBuffers>            buffers {};
-	std::array<vk::DeviceSize, MaxBuffers>        offsets {};
-	std::array<std::shared_ptr<void>, MaxBuffers> owners {};
-	uint32_t                                      count       = 0;
-	uint32_t                                      owner_count = 0;
-};
-
-static PreparedVertexBuffers AcquireVertexBuffers(RenderCommandBuffer&         buffer,
-                                                  const ShaderVertexInputInfo& vs_input_info) {
-	EXIT_IF(vs_input_info.buffers_num < 0 ||
-	        vs_input_info.buffers_num > ShaderVertexInputInfo::RES_MAX);
-
+static std::vector<BufferBinding> AcquireVertexBuffers(RenderCommandBuffer&         buffer,
+                                                       const ShaderVertexInputInfo& vs_input_info) {
 	// Collect the non-empty guest vertex ranges.
-	std::array<VertexBufferRange, ShaderVertexInputInfo::RES_MAX> ranges {};
-	uint32_t                                                      range_count = 0;
+	std::vector<VertexBufferRange> ranges;
+	ranges.reserve(vs_input_info.buffers_num);
 	for (int i = 0; i < vs_input_info.buffers_num; i++) {
 		const auto& vertex = vs_input_info.buffers[i];
 		const auto  size   = VertexBufferDescriptorSize(vertex);
@@ -755,31 +704,27 @@ static PreparedVertexBuffers AcquireVertexBuffers(RenderCommandBuffer&         b
 			EXIT("invalid vertex buffer range: addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
 			     vertex.addr, size);
 		}
-		ranges[range_count++] = {vertex.addr, vertex.addr + size};
+		ranges.push_back({vertex.addr, vertex.addr + size});
 	}

-	std::sort(ranges.begin(), ranges.begin() + range_count,
-	          [](const VertexBufferRange& left, const VertexBufferRange& right) {
-		          return left.base_address < right.base_address;
-	          });
+	std::ranges::sort(ranges, [](const VertexBufferRange& left, const VertexBufferRange& right) {
+		return left.base_address < right.base_address;
+	});

 	// Merge overlapping or touching ranges before acquiring host buffers.
-	std::array<VertexBufferRange, ShaderVertexInputInfo::RES_MAX> merged_ranges {};
-	uint32_t                                                      merged_count = 0;
-	for (uint32_t i = 0; i < range_count; i++) {
-		const auto& range = ranges[i];
-		if (merged_count != 0 &&
-		    merged_ranges[merged_count - 1].requested_end >= range.base_address) {
-			merged_ranges[merged_count - 1].requested_end =
-			    std::max(merged_ranges[merged_count - 1].requested_end, range.requested_end);
+	std::vector<VertexBufferRange> merged_ranges;
+	merged_ranges.reserve(ranges.size());
+	for (const auto& range: ranges) {
+		if (!merged_ranges.empty() && merged_ranges.back().requested_end >= range.base_address) {
+			merged_ranges.back().requested_end =
+			    std::max(merged_ranges.back().requested_end, range.requested_end);
 			continue;
 		}
-		merged_ranges[merged_count++] = {range.base_address, range.requested_end};
+		merged_ranges.push_back(range);
 	}

 	auto& cache = buffer.GetContext().GetBufferCache();
-	for (uint32_t i = 0; i < merged_count; i++) {
-		auto& range = merged_ranges[i];
+	for (auto& range: merged_ranges) {
 		// PPSA20298
 		const auto size =
 		    Libs::LibKernel::Memory::ClampRangeSize(range.base_address, range.RequestedSize());
@@ -788,47 +733,30 @@ static PreparedVertexBuffers AcquireVertexBuffers(RenderCommandBuffer&         b
 	}

 	// Rebuild slot bindings, offsetting non-empty slots into their acquired merged range.
-	PreparedVertexBuffers prepared;
-	prepared.count = static_cast<uint32_t>(vs_input_info.buffers_num);
-	std::shared_ptr<Buffer> null_owner;
-	vk::Buffer              null_buffer = nullptr;
+	std::vector<BufferBinding> bindings;
+	bindings.reserve(vs_input_info.buffers_num);
 	for (int i = 0; i < vs_input_info.buffers_num; i++) {
 		const auto& vertex = vs_input_info.buffers[i];
 		const auto  size   = VertexBufferDescriptorSize(vertex);
 		if (size == 0) {
-			if (null_owner == nullptr) {
-				null_owner  = cache.ObtainNullBuffer();
-				null_buffer = null_owner->Handle();
-			}
-			prepared.buffers[i] = null_buffer;
-			prepared.offsets[i] = 0;
+			auto owner = cache.ObtainNullBuffer();
+			bindings.push_back({owner, owner->Handle(), 0});
 			continue;
 		}

-		const auto range = std::find_if(merged_ranges.begin(), merged_ranges.begin() + merged_count,
-		                                [&](const VertexBufferRange& value) {
-			                                return vertex.addr >= value.base_address &&
-			                                       vertex.addr < value.acquired_end;
-		                                });
-		if (range == merged_ranges.begin() + merged_count) {
+		const auto range = std::ranges::find_if(merged_ranges, [&](const VertexBufferRange& value) {
+			return vertex.addr >= value.base_address && vertex.addr < value.acquired_end;
+		});
+		if (range == merged_ranges.end()) {
 			EXIT("vertex buffer address is outside the acquired range: addr=0x%016" PRIx64 "\n",
 			     vertex.addr);
 		}

-		prepared.buffers[i] = range->binding.buffer;
-		prepared.offsets[i] = range->binding.offset + vertex.addr - range->base_address;
+		auto binding = range->binding;
+		binding.offset += vertex.addr - range->base_address;
+		bindings.push_back(std::move(binding));
 	}
-
-	if (null_owner != nullptr) {
-		prepared.owners[prepared.owner_count++] = std::move(null_owner);
-	}
-	for (uint32_t i = 0; i < merged_count; i++) {
-		if (merged_ranges[i].binding.owner != nullptr) {
-			EXIT_IF(prepared.owner_count >= PreparedVertexBuffers::MaxBuffers);
-			prepared.owners[prepared.owner_count++] = std::move(merged_ranges[i].binding.owner);
-		}
-	}
-	return prepared;
+	return bindings;
 }

 static void SetDrawDebugPhase(RenderCommandBuffer& buffer, uint64_t submit_id,
@@ -839,7 +767,7 @@ static void SetDrawDebugPhase(RenderCommandBuffer& buffer, uint64_t submit_id,
 	                    draw.flags, draw.instance_count, draw.first_instance);
 }

-static bool GetDrawTopology(const HW::UserConfig& ucfg, bool auto_draw,
+static bool GetDrawTopology(const HW::UserConfig& ucfg, bool auto_draw, bool use_ngg_rectlist_draw,
                            vk::PrimitiveTopology& topology) {

 	topology = vk::PrimitiveTopology::ePointList;
@@ -863,7 +791,8 @@ static bool GetDrawTopology(const HW::UserConfig& ucfg, bool auto_draw,
 			topology = vk::PrimitiveTopology::eTriangleStrip;
 			break;
 		case Prospero::PrimitiveType::kRectList:
-			topology = vk::PrimitiveTopology::ePatchList;
+			topology = (auto_draw && use_ngg_rectlist_draw ? vk::PrimitiveTopology::eTriangleStrip
+			                                               : vk::PrimitiveTopology::eTriangleList);
 			break;
 		case Prospero::PrimitiveType::kRectListLegacy:
 			if (!auto_draw) {
@@ -960,9 +889,10 @@ static void RefreshShaders(RenderCommandBuffer& buffer, const DrawCallInfo& draw
 	}
 }

-static PreparedVertexBuffers PrepareVertexBuffers(uint64_t submit_id, RenderCommandBuffer& buffer,
-                                                  const DrawCallInfo&          draw,
-                                                  const ShaderVertexInputInfo& vs_input_info) {
+static std::vector<BufferBinding> PrepareVertexBuffers(uint64_t                     submit_id,
+                                                       RenderCommandBuffer&         buffer,
+                                                       const DrawCallInfo&          draw,
+                                                       const ShaderVertexInputInfo& vs_input_info) {
 	EXIT_IF(draw.name == nullptr);
 	(void)submit_id;

@@ -970,6 +900,12 @@ static PreparedVertexBuffers PrepareVertexBuffers(uint64_t submit_id, RenderComm
 	return AcquireVertexBuffers(buffer, vs_input_info);
 }

+static void RebindVertexBuffers(RenderCommandBuffer&         buffer,
+                                const ShaderVertexInputInfo& vs_input_info,
+                                std::vector<BufferBinding>&  bindings) {
+	bindings = AcquireVertexBuffers(buffer, vs_input_info);
+}
+
 static PreparedIndexBuffer PrepareIndexBuffer(RenderCommandBuffer&         buffer,
                                              const DrawIndexBufferSource& source) {
 	PreparedIndexBuffer prepared;
@@ -977,14 +913,16 @@ static PreparedIndexBuffer PrepareIndexBuffer(RenderCommandBuffer&         buffe
 		return prepared;
 	}
 	EXIT_IF(source.size == 0);
-	prepared.size = source.size;
-	prepared.type = source.type;
+	prepared.address = source.address;
+	prepared.size    = source.size;
+	prepared.type    = source.type;
 	if (source.host_data != nullptr) {
 		auto binding =
 		    buffer.GetContext().GetBufferCache().UploadTransient(source.host_data, source.size, 16);
-		prepared.owner  = std::move(binding.owner);
-		prepared.buffer = binding.buffer;
-		prepared.offset = binding.offset;
+		prepared.owner    = std::move(binding.owner);
+		prepared.buffer   = binding.buffer;
+		prepared.offset   = binding.offset;
+		prepared.streamed = true;
 	} else {
 		auto binding =
 		    buffer.GetContext().GetBufferCache().ObtainBuffer(buffer, source.address, source.size);
@@ -995,29 +933,36 @@ static PreparedIndexBuffer PrepareIndexBuffer(RenderCommandBuffer&         buffe
 	return prepared;
 }

+static void RebindIndexBuffer(RenderCommandBuffer& buffer, PreparedIndexBuffer& prepared) {
+	if (prepared.size == 0 || prepared.streamed) {
+		return;
+	}
+	auto binding =
+	    buffer.GetContext().GetBufferCache().ObtainBuffer(buffer, prepared.address, prepared.size);
+	prepared.owner  = std::move(binding.owner);
+	prepared.buffer = binding.buffer;
+	prepared.offset = binding.offset;
+}
+
 static void CommitVertexBuffers(RenderCommandBuffer& buffer, vk::CommandBuffer vk_buffer,
-                                PreparedVertexBuffers& prepared) {
-	for (uint32_t i = 0; i < prepared.owner_count; i++) {
-		if (prepared.owners[i] != nullptr) {
-			buffer.RetainResourceUntilFence(std::move(prepared.owners[i]));
+                                std::vector<BufferBinding>& bindings) {
+	for (uint32_t slot = 0; slot < bindings.size(); slot++) {
+		auto& binding = bindings[slot];
+		if (binding.owner != nullptr) {
+			buffer.RetainResourceUntilFence(binding.owner);
 		}
-	}
-	for (uint32_t i = 0; i < prepared.count; i++) {
-		EXIT_IF(prepared.buffers[i] == nullptr);
-	}
-	if (prepared.count != 0) {
-		vk_buffer.bindVertexBuffers(0, prepared.count, prepared.buffers.data(),
-		                            prepared.offsets.data());
+		EXIT_IF(binding.buffer == nullptr);
+		vk_buffer.bindVertexBuffers(slot, 1, &binding.buffer, &binding.offset);
 	}
 }

 static void CommitIndexBuffer(RenderCommandBuffer& buffer, vk::CommandBuffer vk_buffer,
-                              PreparedIndexBuffer& prepared) {
+                              const PreparedIndexBuffer& prepared) {
 	if (prepared.size == 0) {
 		return;
 	}
 	if (prepared.owner != nullptr) {
-		buffer.RetainResourceUntilFence(std::move(prepared.owner));
+		buffer.RetainResourceUntilFence(prepared.owner);
 	}
 	EXIT_IF(prepared.buffer == nullptr);
 	vk_buffer.bindIndexBuffer(prepared.buffer, prepared.offset, prepared.type);
@@ -1046,6 +991,20 @@ static void LogDrawStateIfNeeded(const RenderCommandBuffer& buffer, const DrawCa
 	// LogDrawTextureState(draw.name, state.color_info[0], state.ps_input_info);
 }

+static bool IsHostExpandedRectListDrawSupported(const ShaderVertexInputInfo& vs_input_info,
+                                                const DrawCallInfo&          draw,
+                                                const DrawEmitInfo&          emit) {
+	if (!emit.draw_prim7_as_ngg) {
+		return true;
+	}
+
+	if (vs_input_info.buffers_num != 0) {
+		return false;
+	}
+
+	return draw.index_count == 3 || draw.index_count == emit.draw_vertex_count;
+}
+
 static void EmitDrawPrimitives(const HW::UserConfig& ucfg, vk::CommandBuffer vk_buffer,
                               const ShaderVertexInputInfo& vs_input_info, const DrawCallInfo& draw,
                               const DrawEmitInfo& emit) {
@@ -1058,7 +1017,6 @@ static void EmitDrawPrimitives(const HW::UserConfig& ucfg, vk::CommandBuffer vk_
 		case Prospero::PrimitiveType::kTriList:
 		case Prospero::PrimitiveType::kTriFan:
 		case Prospero::PrimitiveType::kTriStrip:
-		case Prospero::PrimitiveType::kRectList:
 			if (emit.indexed) {
 				vk_buffer.drawIndexed(draw.index_count, draw.instance_count, 0, emit.vertex_offset,
 				                      draw.first_instance);
@@ -1067,6 +1025,17 @@ static void EmitDrawPrimitives(const HW::UserConfig& ucfg, vk::CommandBuffer vk_
 				               draw.first_instance);
 			}
 			break;
+		case Prospero::PrimitiveType::kRectList:
+			if (emit.indexed) {
+				vk_buffer.drawIndexed(draw.index_count, draw.instance_count, 0, emit.vertex_offset,
+				                      draw.first_instance);
+			} else {
+				EXIT_NOT_IMPLEMENTED(
+				    !IsHostExpandedRectListDrawSupported(vs_input_info, draw, emit));
+				vk_buffer.draw(emit.draw_vertex_count, draw.instance_count, emit.first_vertex,
+				               draw.first_instance);
+			}
+			break;
 		case Prospero::PrimitiveType::kRectListLegacy:
 			if (emit.indexed) {
 				EXIT("unknown primitive type: %u\n", ucfg.GetPrimType());
@@ -1105,6 +1074,8 @@ void RenderExecutor::ExecutePreparedDraw(uint64_t submit_id, RenderCommandBuffer
 	                                               state.ps_input_info.stage, state.ps_active);
 	auto vertex_bindings = PrepareVertexBuffers(submit_id, buffer, draw, state.vs_input_info);
 	auto index_binding   = PrepareIndexBuffer(buffer, index_source);
+	RebindVertexBuffers(buffer, state.vs_input_info, vertex_bindings);
+	RebindIndexBuffer(buffer, index_binding);
 	state.rendering =
 	    AcquireRenderTargets(buffer, state.color_info, state.color_count, state.depth_info);

@@ -1188,7 +1159,7 @@ void RenderExecutor::DrawIndex(uint64_t submit_id, RenderCommandBuffer& buffer,
 	                    reinterpret_cast<uint64_t>(index_addr));

 	Common::LockGuard lock(m_context.GetMutex());
-	if (index_count == 0 || instance_count == 0) {
+	if (index_count == 0) {
 		return;
 	}

@@ -1230,7 +1201,7 @@ void RenderExecutor::DrawIndex(uint64_t submit_id, RenderCommandBuffer& buffer,
 	hw_check(buffer);

 	vk::PrimitiveTopology topology = vk::PrimitiveTopology::ePointList;
-	if (!GetDrawTopology(ucfg, false, topology)) {
+	if (!GetDrawTopology(ucfg, false, false, topology)) {
 		return;
 	}

@@ -1258,6 +1229,10 @@ void RenderExecutor::DrawIndex(uint64_t submit_id, RenderCommandBuffer& buffer,

 	EXIT_NOT_IMPLEMENTED(flags != 0);
 	EXIT_NOT_IMPLEMENTED(type != 1);
+	if (instance_count == 0) {
+		instance_count = 1;
+	}
+
 	const DrawCallInfo    draw {"DrawIndex",    CommandBufferDebugOp::DrawIndex,
 	                            index_count,    flags,
 	                            instance_count, first_instance};
@@ -1317,7 +1292,7 @@ void RenderExecutor::DrawAuto(uint64_t submit_id, RenderCommandBuffer& buffer, u
 	                    index_count, flags, first_vertex, instance_count, first_instance);

 	Common::LockGuard lock(m_context.GetMutex());
-	if (index_count == 0 || instance_count == 0) {
+	if (index_count == 0) {
 		return;
 	}

@@ -1355,6 +1330,10 @@ void RenderExecutor::DrawAuto(uint64_t submit_id, RenderCommandBuffer& buffer, u
 	hw_check(buffer);

 	EXIT_NOT_IMPLEMENTED(flags != 0);
+	if (instance_count == 0) {
+		instance_count = 1;
+	}
+
 	const DrawCallInfo draw {"DrawIndexAuto", CommandBufferDebugOp::DrawIndexAuto,
 	                         index_count,     flags,
 	                         instance_count,  first_instance};
@@ -1366,15 +1345,20 @@ void RenderExecutor::DrawAuto(uint64_t submit_id, RenderCommandBuffer& buffer, u
 		return;
 	}

-	vk::PrimitiveTopology topology = vk::PrimitiveTopology::ePointList;
-	if (!GetDrawTopology(ucfg, true, topology)) {
+	vk::PrimitiveTopology topology              = vk::PrimitiveTopology::ePointList;
+	const bool            use_ngg_rectlist_draw = Config::NggRectlistDrawEnabled();
+
+	if (!GetDrawTopology(ucfg, true, use_ngg_rectlist_draw, topology)) {
 		ResetBindings();
 		return;
 	}
+	const bool draw_prim7_as_ngg =
+	    (use_ngg_rectlist_draw &&
+	     ucfg.GetPrimType() == Prospero::GpuEnumValue(Prospero::PrimitiveType::kRectList));
+
 	RefreshShaders(buffer, draw, false, state);

-	const bool rect_list = topology == vk::PrimitiveTopology::ePatchList;
-	if (rect_list && state.vs_input_info.buffers_num == 0 &&
+	if (draw_prim7_as_ngg && state.vs_input_info.buffers_num == 0 &&
 	    state.vs_input_info.param_export_mask == 0 && state.ps_input_info.input_num != 0) {
 		if (graphics_debug_dump_enabled()) {
 			LOGF("DrawIndexAuto: skipping rect-list draw with no VS param exports and PS inputs: "
@@ -1391,10 +1375,13 @@ void RenderExecutor::DrawAuto(uint64_t submit_id, RenderCommandBuffer& buffer, u
 	                         Prospero::GpuEnumValue(Prospero::PrimitiveType::kRectListLegacy),
 	                     0, nullptr);

-	const auto   vertex_offset = ResolveVertexOffset(ucfg.GetIndexOffset(), state.vs_input_info) +
-	                             static_cast<int32_t>(first_vertex);
-	DrawEmitInfo emit {};
-	emit.first_vertex = static_cast<uint32_t>(vertex_offset);
+	const uint32_t draw_vertex_count = (draw_prim7_as_ngg ? 4u : index_count);
+	const auto     vertex_offset = ResolveVertexOffset(ucfg.GetIndexOffset(), state.vs_input_info) +
+	                               static_cast<int32_t>(first_vertex);
+	DrawEmitInfo   emit {};
+	emit.draw_prim7_as_ngg = draw_prim7_as_ngg;
+	emit.draw_vertex_count = draw_vertex_count;
+	emit.first_vertex      = static_cast<uint32_t>(vertex_offset);

 	DrawIndexBufferSource index_source {};
 	ExecutePreparedDraw(submit_id, buffer, draw, state, topology, emit, index_source, false, false,
@@ -15,16 +15,12 @@ struct ShaderVertexInputInfo;

 struct PipelineDynamicParameters {
 	bool stencil_test_enable = false;
-	bool depth_bias_enable   = false;

 	float viewport_scale[3]  = {};
 	float viewport_offset[3] = {};
 	int   scissor_ltrb[4]    = {0};

 	float    line_width                                       = 1.0f;
-	float    depth_bias_constant_factor                       = 0.0f;
-	float    depth_bias_clamp                                 = 0.0f;
-	float    depth_bias_slope_factor                          = 0.0f;
 	uint32_t color_write_count                                = 1;
 	bool     color_write_enable[RENDER_COLOR_ATTACHMENTS_MAX] = {true, true};

@@ -37,6 +33,10 @@ struct PipelineDynamicParameters {
 static_assert(std::is_trivially_copyable_v<PipelineDynamicParameters>);
 static_assert(std::is_standard_layout_v<PipelineDynamicParameters>);
 static_assert(alignof(PipelineDynamicParameters) == 1);
+static_assert(sizeof(PipelineDynamicParameters) ==
+              sizeof(bool) + sizeof(float[3]) + sizeof(float[3]) + sizeof(int[4]) + sizeof(float) +
+                  sizeof(uint32_t) + sizeof(bool[RENDER_COLOR_ATTACHMENTS_MAX]) +
+                  sizeof(PipelineStencilDynamicState) * 2);

 [[nodiscard]] int32_t ResolveVertexOffset(uint32_t                     index_offset,
                                          const ShaderVertexInputInfo& vs_input_info);
@@ -1,42 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_PRESENTATION_IMEOVERLAY_H_
-#define EMULATOR_SRC_GRAPHICS_PRESENTATION_IMEOVERLAY_H_
-
-#include "common/common.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <memory>
-
-union SDL_Event;
-
-namespace Libs::Graphics {
-
-struct GraphicContext;
-
-struct ImeVisualState {
-	bool     active;
-	uint64_t revision;
-};
-
-void           InitializeImeInput();
-void           ShutdownImeInput();
-bool           ProcessImeInput(const SDL_Event& event);
-ImeVisualState GetImeVisualState() noexcept;
-
-class ImeOverlay final {
-public:
-	explicit ImeOverlay(GraphicContext& graphics);
-	~ImeOverlay();
-	KYTY_CLASS_NO_COPY(ImeOverlay);
-
-	[[nodiscard]] bool PrepareFrame(vk::Extent2D extent, vk::Format format, uint32_t image_count);
-	void               Record(vk::CommandBuffer command, vk::ImageView target);
-	void               ReleaseVulkan();
-
-private:
-	struct Impl;
-	std::unique_ptr<Impl> m_impl;
-};
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_PRESENTATION_IMEOVERLAY_H_
@@ -25,7 +25,6 @@ public:
 	                                               CommandBuffer* producer = nullptr);
 	[[nodiscard]] Frame*         PrepareLastFrame();
 	[[nodiscard]] bool           IsGuestPaused() const noexcept;
-	[[nodiscard]] bool           NeedsImeRefresh() const noexcept;
 	[[nodiscard]] RenderContext& Renderer() const noexcept;
 	void                         Present(Frame& frame, bool reuse = false);
 	void                         Discard(Frame& frame);
@@ -128,7 +128,8 @@ static bool BindRenderDocApi(HMODULE module) {
 	g_api    = static_cast<RenderDocApi*>(api);

 	g_api->SetCaptureFilePathTemplate("_RenderDoc/kyty");
-	g_api->SetCaptureKeys(nullptr, 0);
+	static RenderDocInputButton capture_keys[] = {eRENDERDOC_Key_F1};
+	g_api->SetCaptureKeys(capture_keys, 1);
 	g_api->UnloadCrashHandler();

 	char module_path[MAX_PATH] = {};
@@ -169,7 +170,8 @@ static bool BindRenderDocApi(HMODULE module) {
 	g_api    = static_cast<RenderDocApi*>(api);

 	g_api->SetCaptureFilePathTemplate("_RenderDoc/kyty");
-	g_api->SetCaptureKeys(nullptr, 0);
+	static RenderDocInputButton capture_keys[] = {eRENDERDOC_Key_F1};
+	g_api->SetCaptureKeys(capture_keys, 1);
 	g_api->UnloadCrashHandler();

 	Dl_info info {};
@@ -537,10 +537,10 @@ Graphics::ImageInfo BufferAttributeGroup::ImageInfo(const VideoOutBuffer& buffer
 	const auto tile_mode =
 	    Graphics::Prospero::GpuEnumValue(Graphics::Prospero::TileMode::kRenderTarget);
 	const auto pitch =
-	    Graphics::TileGetTexturePitch(pixel_format.guest_format, attribute.width, tile_mode);
+	    Graphics::TileGetTexturePitch(pixel_format.guest_format, attribute.width, 1, tile_mode);
 	Graphics::TileSizeAlign total {};
 	Graphics::TileGetTextureTotalSize(pixel_format.guest_format, attribute.width, attribute.height,
-	                                  1, 1, tile_mode, false, total);
+	                                  1, pitch, 1, tile_mode, false, total);
 	if (total.size == 0 || total.align != 65536 ||
 	    (buffer.data_address & (total.align - 1u)) != 0) {
 		EXIT("invalid video-out surface footprint or alignment\n");
@@ -788,10 +788,14 @@ void VideoOutDriver::Impl::PresentThread(std::stop_token token) {
 	while (!token.stop_requested()) {
 		const auto sleep_begin = Common::Timer::QueryPerformanceCounter();
 		if (total_wait > 0) {
-			const auto remaining_us =
-			    (static_cast<uint64_t>(total_wait) * 1000000u + frequency - 1) / frequency;
-			Common::Thread::SleepMicro(static_cast<uint32_t>(
-			    std::clamp<uint64_t>(remaining_us, 1, std::numeric_limits<uint32_t>::max())));
+			const auto sleep_end = sleep_begin + static_cast<uint64_t>(total_wait);
+			auto       now       = sleep_begin;
+			while (!token.stop_requested() && now < sleep_end) {
+				const auto remaining_us = (sleep_end - now) * 1000000u / frequency;
+				Common::Thread::SleepMicro(
+				    static_cast<uint32_t>(std::clamp<uint64_t>(remaining_us, 1, 1000)));
+				now = Common::Timer::QueryPerformanceCounter();
+			}
 		}
 		if (token.stop_requested()) {
 			break;
@@ -813,24 +817,7 @@ void VideoOutDriver::Impl::PresentThread(std::stop_token token) {
 		}

 		VblankBegin();
-		bool presented = m_flip_queue.Flip(0);
-		if (!presented && m_presenter.NeedsImeRefresh()) {
-			if (auto* frame = m_presenter.PrepareLastFrame(); frame != nullptr) {
-				m_presenter.Present(*frame, true);
-				presented = true;
-			} else {
-				uint32_t width  = 0;
-				uint32_t height = 0;
-				{
-					Common::LockGuard lock(m_mutex);
-					width  = m_video_out_ctx[0].width;
-					height = m_video_out_ctx[0].height;
-				}
-				auto& blank = m_presenter.PrepareBlankFrame(width, height, true);
-				m_presenter.Present(blank);
-				presented = true;
-			}
-		}
+		const bool presented = m_flip_queue.Flip(0);
 		if (!presented && total_wait < 0) {
 			bool     any_open = false;
 			uint32_t width    = 0;
@@ -1,305 +0,0 @@
-#include "graphics/presentation/window/hostInput.h"
-
-#include "SDL_keyboard.h"
-#include "SDL_keycode.h"
-#include "SDL_mouse.h"
-#include "common/assert.h"
-#include "common/emulatorConfig.h"
-#include "libs/controller.h"
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <string>
-#include <string_view>
-#include <utility>
-
-namespace Libs::Graphics {
-
-namespace {
-
-struct ControlInfo {
-	std::string_view name;
-	uint32_t         button   = 0;
-	Controller::Axis axis     = Controller::Axis::AxisMax;
-	bool             positive = false;
-};
-
-static constexpr std::array CONTROL_INFO = {
-    ControlInfo {"L3", Controller::PAD_BUTTON_L3},
-    ControlInfo {"R3", Controller::PAD_BUTTON_R3},
-    ControlInfo {"Options", Controller::PAD_BUTTON_OPTIONS},
-    ControlInfo {"Up", Controller::PAD_BUTTON_UP},
-    ControlInfo {"Right", Controller::PAD_BUTTON_RIGHT},
-    ControlInfo {"Down", Controller::PAD_BUTTON_DOWN},
-    ControlInfo {"Left", Controller::PAD_BUTTON_LEFT},
-    ControlInfo {"L2", Controller::PAD_BUTTON_L2},
-    ControlInfo {"R2", Controller::PAD_BUTTON_R2},
-    ControlInfo {"L1", Controller::PAD_BUTTON_L1},
-    ControlInfo {"R1", Controller::PAD_BUTTON_R1},
-    ControlInfo {"Triangle", Controller::PAD_BUTTON_TRIANGLE},
-    ControlInfo {"Circle", Controller::PAD_BUTTON_CIRCLE},
-    ControlInfo {"Cross", Controller::PAD_BUTTON_CROSS},
-    ControlInfo {"Square", Controller::PAD_BUTTON_SQUARE},
-    ControlInfo {"TouchPad", Controller::PAD_BUTTON_TOUCH_PAD},
-    ControlInfo {"LeftStickLeft", 0, Controller::Axis::LeftX, false},
-    ControlInfo {"LeftStickRight", 0, Controller::Axis::LeftX, true},
-    ControlInfo {"LeftStickUp", 0, Controller::Axis::LeftY, false},
-    ControlInfo {"LeftStickDown", 0, Controller::Axis::LeftY, true},
-    ControlInfo {"RightStickLeft", 0, Controller::Axis::RightX, false},
-    ControlInfo {"RightStickRight", 0, Controller::Axis::RightX, true},
-    ControlInfo {"RightStickUp", 0, Controller::Axis::RightY, false},
-    ControlInfo {"RightStickDown", 0, Controller::Axis::RightY, true},
-};
-
-constexpr std::size_t INVALID_CONTROL = CONTROL_INFO.size();
-
-struct Binding {
-	SDL_Keycode key          = SDLK_UNKNOWN;
-	uint8_t     mouse_button = 0;
-	std::size_t control      = INVALID_CONTROL;
-};
-
-std::size_t ControlFromName(std::string_view name) {
-	const auto info = std::find_if(CONTROL_INFO.begin(), CONTROL_INFO.end(),
-	                               [name](const auto& item) { return item.name == name; });
-	return static_cast<std::size_t>(std::distance(CONTROL_INFO.begin(), info));
-}
-
-const ControlInfo& Info(std::size_t control) {
-	EXIT_IF(control >= CONTROL_INFO.size());
-	return CONTROL_INFO[control];
-}
-
-SDL_Keycode NormalizeKey(SDL_Keycode key) {
-	switch (key) {
-		case SDLK_RSHIFT: return SDLK_LSHIFT;
-		case SDLK_RCTRL: return SDLK_LCTRL;
-		case SDLK_RALT: return SDLK_LALT;
-		case SDLK_RGUI: return SDLK_LGUI;
-		default: return key;
-	}
-}
-
-uint8_t MouseButtonFromName(std::string_view name) {
-	static constexpr std::array buttons = {
-	    std::pair {std::string_view("Mouse:Left"), uint8_t {SDL_BUTTON_LEFT}},
-	    std::pair {std::string_view("Mouse:Middle"), uint8_t {SDL_BUTTON_MIDDLE}},
-	    std::pair {std::string_view("Mouse:Right"), uint8_t {SDL_BUTTON_RIGHT}},
-	    std::pair {std::string_view("Mouse:X1"), uint8_t {SDL_BUTTON_X1}},
-	    std::pair {std::string_view("Mouse:X2"), uint8_t {SDL_BUTTON_X2}},
-	};
-
-	const auto button = std::find_if(buttons.begin(), buttons.end(),
-	                                 [name](const auto& item) { return item.first == name; });
-	return button != buttons.end() ? button->second : 0;
-}
-
-bool Conflicts(const Binding& first, const Binding& second) {
-	return first.control == second.control ||
-	       (first.key != SDLK_UNKNOWN && first.key == second.key) ||
-	       (first.mouse_button != 0 && first.mouse_button == second.mouse_button);
-}
-
-class InputMap {
-public:
-	InputMap(): m_custom(!Config::GetKeymap().empty()) {
-		for (const auto& value: Config::GetKeymap()) {
-			const std::string_view entry = value;
-			const auto             split = entry.find('=');
-
-			Binding binding;
-			if (split != std::string_view::npos) {
-				binding.control       = ControlFromName(entry.substr(0, split));
-				const auto host_input = entry.substr(split + 1);
-				binding.mouse_button  = MouseButtonFromName(host_input);
-				if (binding.mouse_button == 0) {
-					binding.key = NormalizeKey(SDL_GetKeyFromName(std::string(host_input).c_str()));
-				}
-			}
-
-			const bool reserved =
-			    binding.key == SDLK_ESCAPE || binding.key == SDLK_SPACE || binding.key == SDLK_F1;
-			if (binding.control == INVALID_CONTROL || reserved ||
-			    (binding.key == SDLK_UNKNOWN && binding.mouse_button == 0)) {
-				EXIT("Invalid input mapping: %s\n", value.c_str());
-			}
-			Add(binding);
-		}
-	}
-	[[nodiscard]] bool Custom() const { return m_custom; }
-
-	[[nodiscard]] std::size_t FindKey(int key_code) const {
-		key_code = NormalizeKey(static_cast<SDL_Keycode>(key_code));
-		const auto binding =
-		    std::find_if(m_bindings.begin(), m_bindings.begin() + m_size,
-		                 [key_code](const auto& item) { return item.key == key_code; });
-		return binding != m_bindings.begin() + m_size ? binding->control : INVALID_CONTROL;
-	}
-
-	[[nodiscard]] std::size_t FindMouseButton(uint8_t mouse_button) const {
-		const auto binding = std::find_if(
-		    m_bindings.begin(), m_bindings.begin() + m_size,
-		    [mouse_button](const auto& item) { return item.mouse_button == mouse_button; });
-		return binding != m_bindings.begin() + m_size ? binding->control : INVALID_CONTROL;
-	}
-
-private:
-	void Add(const Binding& binding) {
-		for (std::size_t index = 0; index < m_size;) {
-			if (Conflicts(m_bindings[index], binding)) {
-				m_bindings[index] = m_bindings[--m_size];
-			} else {
-				index++;
-			}
-		}
-		EXIT_IF(m_size >= m_bindings.size());
-		m_bindings[m_size++] = binding;
-	}
-
-	std::array<Binding, CONTROL_INFO.size()> m_bindings {};
-	std::size_t                              m_size = 0;
-	bool                                     m_custom;
-};
-
-const InputMap& GetInputMap() {
-	static const InputMap map;
-	return map;
-}
-
-void SetButton(uint32_t button, bool down) {
-	if (button == Controller::PAD_BUTTON_L2) {
-		Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID,
-		                           Controller::Axis::TriggerLeft, down ? 255 : 0);
-	} else if (button == Controller::PAD_BUTTON_R2) {
-		Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID,
-		                           Controller::Axis::TriggerRight, down ? 255 : 0);
-	} else if (button != 0) {
-		Controller::ControllerButton(Controller::HOST_INPUT_CONTROLLER_ID, button, down);
-	}
-}
-
-uint32_t DefaultKeyboardButton(int key_code) {
-	switch (NormalizeKey(static_cast<SDL_Keycode>(key_code))) {
-		case SDLK_UP: return Controller::PAD_BUTTON_UP;
-		case SDLK_LEFT: return Controller::PAD_BUTTON_LEFT;
-		case SDLK_DOWN: return Controller::PAD_BUTTON_DOWN;
-		case SDLK_RIGHT: return Controller::PAD_BUTTON_RIGHT;
-		case SDLK_j: return Controller::PAD_BUTTON_CROSS;
-		case SDLK_i: return Controller::PAD_BUTTON_TRIANGLE;
-		case SDLK_k: return Controller::PAD_BUTTON_SQUARE;
-		case SDLK_l: return Controller::PAD_BUTTON_CIRCLE;
-		case SDLK_q: return Controller::PAD_BUTTON_L1;
-		case SDLK_e: return Controller::PAD_BUTTON_R1;
-		case SDLK_LSHIFT: return Controller::PAD_BUTTON_L3;
-		case SDLK_LCTRL: return Controller::PAD_BUTTON_R3;
-		case SDLK_RETURN:
-		case SDLK_RETURN2: return Controller::PAD_BUTTON_OPTIONS;
-		case SDLK_BACKSPACE:
-		case SDLK_TAB: return Controller::PAD_BUTTON_TOUCH_PAD;
-		default: return 0;
-	}
-}
-
-struct StickKeys {
-	bool left  = false;
-	bool right = false;
-	bool up    = false;
-	bool down  = false;
-};
-
-void SetStickAxis(Controller::Axis axis, bool negative, bool positive) {
-	const int value = negative == positive ? 128 : negative ? 0 : 255;
-	Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID, axis, value);
-}
-
-void SetControl(std::size_t control, bool down) {
-	if (control == INVALID_CONTROL) {
-		return;
-	}
-
-	const auto& info = Info(control);
-	if (info.button != 0) {
-		SetButton(info.button, down);
-		return;
-	}
-
-	struct AxisKeys {
-		bool negative = false;
-		bool positive = false;
-	};
-	static std::array<AxisKeys, 4> axes;
-
-	const auto axis = static_cast<std::size_t>(info.axis);
-	EXIT_IF(axis >= axes.size());
-	if (info.positive) {
-		axes[axis].positive = down;
-	} else {
-		axes[axis].negative = down;
-	}
-	SetStickAxis(info.axis, axes[axis].negative, axes[axis].positive);
-}
-
-void DefaultKeyboardInput(int key_code, bool down) {
-	static StickKeys left;
-	static StickKeys right;
-
-	switch (NormalizeKey(static_cast<SDL_Keycode>(key_code))) {
-		case SDLK_a:
-			left.left = down;
-			SetStickAxis(Controller::Axis::LeftX, left.left, left.right);
-			return;
-		case SDLK_d:
-			left.right = down;
-			SetStickAxis(Controller::Axis::LeftX, left.left, left.right);
-			return;
-		case SDLK_w:
-			left.up = down;
-			SetStickAxis(Controller::Axis::LeftY, left.up, left.down);
-			return;
-		case SDLK_s:
-			left.down = down;
-			SetStickAxis(Controller::Axis::LeftY, left.up, left.down);
-			return;
-		case SDLK_f:
-			right.left = down;
-			SetStickAxis(Controller::Axis::RightX, right.left, right.right);
-			return;
-		case SDLK_h:
-			right.right = down;
-			SetStickAxis(Controller::Axis::RightX, right.left, right.right);
-			return;
-		case SDLK_t:
-			right.up = down;
-			SetStickAxis(Controller::Axis::RightY, right.up, right.down);
-			return;
-		case SDLK_g:
-			right.down = down;
-			SetStickAxis(Controller::Axis::RightY, right.up, right.down);
-			return;
-		default: SetButton(DefaultKeyboardButton(key_code), down); return;
-	}
-}
-} // namespace
-
-void HostInputInit() {
-	GetInputMap();
-}
-
-void HostInputKey(int key_code, bool down) {
-	const auto& map = GetInputMap();
-	if (map.Custom()) {
-		SetControl(map.FindKey(key_code), down);
-	} else {
-		DefaultKeyboardInput(key_code, down);
-	}
-}
-
-void HostInputMouseButton(uint8_t mouse_button, bool down) {
-	const auto& map = GetInputMap();
-	if (map.Custom() && mouse_button != 0) {
-		SetControl(map.FindMouseButton(mouse_button), down);
-	}
-}
-
-} // namespace Libs::Graphics
@@ -1,14 +0,0 @@
-#ifndef KYTY_GRAPHICS_PRESENTATION_WINDOW_HOST_INPUT_H_
-#define KYTY_GRAPHICS_PRESENTATION_WINDOW_HOST_INPUT_H_
-
-#include <cstdint>
-
-namespace Libs::Graphics {
-
-void HostInputInit();
-void HostInputKey(int key_code, bool down);
-void HostInputMouseButton(uint8_t mouse_button, bool down);
-
-} // namespace Libs::Graphics
-
-#endif /* KYTY_GRAPHICS_PRESENTATION_WINDOW_HOST_INPUT_H_ */
@@ -31,7 +31,6 @@
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vma.h"
 #include "graphics/host_gpu/vulkanCommon.h"
-#include "graphics/presentation/imeOverlay.h"
 #include "graphics/presentation/presenter.h"
 #include "graphics/presentation/renderDoc.h"
 #include "graphics/presentation/videoOut.h"
@@ -330,9 +329,8 @@ public:
 	void                 Create();
 	void                 Recreate(bool surface_lost = false);
 	[[nodiscard]] Status AcquireNextImage();
-	[[nodiscard]] bool   PrepareImeOverlay();
-	void RecordPresentCommands(CommandBuffer& command, VulkanImage& source, bool draw_ime_overlay);
-	void Submit(CommandBuffer& command);
+	void                 RecordPresentCommands(CommandBuffer& command, VulkanImage& source);
+	void                 Submit(CommandBuffer& command);
 	[[nodiscard]] Status Present();

 	[[nodiscard]] uint32_t ImageCount() const noexcept {
@@ -344,17 +342,16 @@ private:
 	void Destroy();
 	void RefreshSurfaceSize();

-	WindowContext&              m_window;
-	vk::SwapchainKHR            m_handle = nullptr;
-	vk::Format                  m_format = vk::Format::eUndefined;
-	vk::Extent2D                m_extent {};
-	std::vector<vk::Image>      m_images;
-	std::vector<vk::ImageView>  m_image_views;
-	std::vector<vk::Semaphore>  m_image_acquired;
-	std::vector<vk::Semaphore>  m_render_complete;
-	std::unique_ptr<ImeOverlay> m_ime_overlay;
-	uint32_t                    m_image_index = static_cast<uint32_t>(-1);
-	uint32_t                    m_frame_index = 0;
+	WindowContext&             m_window;
+	vk::SwapchainKHR           m_handle = nullptr;
+	vk::Format                 m_format = vk::Format::eUndefined;
+	vk::Extent2D               m_extent {};
+	std::vector<vk::Image>     m_images;
+	std::vector<vk::ImageView> m_image_views;
+	std::vector<vk::Semaphore> m_image_acquired;
+	std::vector<vk::Semaphore> m_render_complete;
+	uint32_t                   m_image_index = static_cast<uint32_t>(-1);
+	uint32_t                   m_frame_index = 0;
 };

 struct Presenter::Impl {
@@ -386,20 +383,17 @@ struct Presenter::Impl {
 		desc.view_info.usage       = vk::ImageUsageFlagBits::eTransferSrc;
 		desc.type                  = TextureCache::BindingType::VideoOut;

-		auto&      cache      = renderer.GetTextureCache();
-		const auto image_id   = cache.FindImage(desc);
-		auto&      image      = cache.GetImage(image_id);
+		auto& cache           = renderer.GetTextureCache();
+		auto& image           = cache.GetImage(cache.FindImage(desc));
 		image.usage.video_out = true;
-		cache.UpdateImage(image_id);
 		return image;
 	}

-	RenderContext&        renderer;
-	WindowContext&        window;
-	Swapchain             swapchain;
-	CommandScheduler      present_scheduler;
-	FramePool             frames;
-	std::atomic<uint64_t> presented_ime_revision {0};
+	RenderContext&   renderer;
+	WindowContext&   window;
+	Swapchain        swapchain;
+	CommandScheduler present_scheduler;
+	FramePool        frames;
 };

 void Swapchain::Create() {
@@ -528,9 +522,6 @@ void Swapchain::Destroy() {
 		Common::LockGuard queue_lock(graphics.queue_mutex);
 		RequireVulkanSuccess(graphics.queue.waitIdle(), "wait for swapchain queue");
 	}
-	if (m_ime_overlay != nullptr) {
-		m_ime_overlay->ReleaseVulkan();
-	}

 	for (const auto semaphore: m_image_acquired) {
 		if (semaphore != nullptr) {
@@ -615,15 +606,7 @@ Swapchain::Status Swapchain::AcquireNextImage() {
 	return Status::Success;
 }

-bool Swapchain::PrepareImeOverlay() {
-	if (m_ime_overlay == nullptr) {
-		m_ime_overlay = std::make_unique<ImeOverlay>(m_window.graphic_ctx);
-	}
-	return m_ime_overlay->PrepareFrame(m_extent, m_format, ImageCount());
-}
-
-void Swapchain::RecordPresentCommands(CommandBuffer& command, VulkanImage& source,
-                                      bool draw_ime_overlay) {
+void Swapchain::RecordPresentCommands(CommandBuffer& command, VulkanImage& source) {
 	if (source.state.layout != vk::ImageLayout::eTransferSrcOptimal) {
 		EXIT("invalid prepared presentation image, vk_image=%p layout=%d\n",
 		     static_cast<void*>(source.image), static_cast<int>(source.state.layout));
@@ -669,14 +652,11 @@ void Swapchain::RecordPresentCommands(CommandBuffer& command, VulkanImage& sourc
 	                     vk::Filter::eLinear);

 	vk::ImageMemoryBarrier to_present {};
-	to_present.sType         = vk::StructureType::eImageMemoryBarrier;
-	to_present.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
-	to_present.dstAccessMask = draw_ime_overlay ? vk::AccessFlagBits::eColorAttachmentRead |
-	                                                  vk::AccessFlagBits::eColorAttachmentWrite
-	                                            : vk::AccessFlagBits::eMemoryRead;
-	to_present.oldLayout     = vk::ImageLayout::eTransferDstOptimal;
-	to_present.newLayout     = draw_ime_overlay ? vk::ImageLayout::eColorAttachmentOptimal
-	                                            : vk::ImageLayout::ePresentSrcKHR;
+	to_present.sType                           = vk::StructureType::eImageMemoryBarrier;
+	to_present.srcAccessMask                   = vk::AccessFlagBits::eTransferWrite;
+	to_present.dstAccessMask                   = vk::AccessFlagBits::eMemoryRead;
+	to_present.oldLayout                       = vk::ImageLayout::eTransferDstOptimal;
+	to_present.newLayout                       = vk::ImageLayout::ePresentSrcKHR;
 	to_present.srcQueueFamilyIndex             = VK_QUEUE_FAMILY_IGNORED;
 	to_present.dstQueueFamilyIndex             = VK_QUEUE_FAMILY_IGNORED;
 	to_present.image                           = m_images[m_image_index];
@@ -685,22 +665,9 @@ void Swapchain::RecordPresentCommands(CommandBuffer& command, VulkanImage& sourc
 	to_present.subresourceRange.levelCount     = 1;
 	to_present.subresourceRange.baseArrayLayer = 0;
 	to_present.subresourceRange.layerCount     = 1;
-	vk_command.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
-	                           draw_ime_overlay ? vk::PipelineStageFlagBits::eColorAttachmentOutput
-	                                            : vk::PipelineStageFlagBits::eAllCommands,
-	                           vk::DependencyFlagBits::eByRegion, 0, nullptr, 0, nullptr, 1,
-	                           &to_present);
-	if (draw_ime_overlay) {
-		m_ime_overlay->Record(vk_command, m_image_views[m_image_index]);
-		to_present.srcAccessMask = vk::AccessFlagBits::eColorAttachmentWrite;
-		to_present.dstAccessMask = vk::AccessFlagBits::eMemoryRead;
-		to_present.oldLayout     = vk::ImageLayout::eColorAttachmentOptimal;
-		to_present.newLayout     = vk::ImageLayout::ePresentSrcKHR;
-		vk_command.pipelineBarrier(vk::PipelineStageFlagBits::eColorAttachmentOutput,
-		                           vk::PipelineStageFlagBits::eAllCommands,
-		                           vk::DependencyFlagBits::eByRegion, 0, nullptr, 0, nullptr, 1,
-		                           &to_present);
-	}
+	vk_command.pipelineBarrier(
+	    vk::PipelineStageFlagBits::eAllCommands, vk::PipelineStageFlagBits::eAllCommands,
+	    vk::DependencyFlagBits::eByRegion, 0, nullptr, 0, nullptr, 1, &to_present);
 	command.End();
 }

@@ -805,12 +772,6 @@ bool Presenter::IsGuestPaused() const noexcept {
 	return m_impl->window.loop.paused.load(std::memory_order_acquire);
 }

-bool Presenter::NeedsImeRefresh() const noexcept {
-	const auto visual = GetImeVisualState();
-	return visual.active ||
-	       visual.revision != m_impl->presented_ime_revision.load(std::memory_order_acquire);
-}
-
 RenderContext& Presenter::Renderer() const noexcept {
 	return m_impl->renderer;
 }
@@ -828,22 +789,19 @@ void Presenter::Present(Frame& frame, bool reuse) {
 		    [&window] {
 			    window.UpdateIcon();
 			    SDL_ShowWindow(window.window);
-			    SDL_RaiseWindow(window.window);
 		    },
 		    true);
 #else
 		window.UpdateIcon();

 		SDL_ShowWindow(window.window);
-		SDL_RaiseWindow(window.window);
 #endif

 		window.window_hidden = false;
 		m_impl->RecoverSwapchain(Swapchain::Status::Recreate);
 	}

-	const auto ime_visual = GetImeVisualState();
-	auto&      swapchain  = m_impl->swapchain;
+	auto& swapchain = m_impl->swapchain;
 	for (uint32_t attempt = 0; attempt < 2; attempt++) {
 		auto status = swapchain.AcquireNextImage();
 		if (status != Swapchain::Status::Success) {
@@ -856,9 +814,8 @@ void Presenter::Present(Frame& frame, bool reuse) {
 		{
 			Common::LockGuard render_lock(m_impl->renderer.GetMutex());
 			frame.present_commands->WaitForFenceAndReset();
-			auto&      command          = *frame.present_commands;
-			const bool draw_ime_overlay = ime_visual.active && swapchain.PrepareImeOverlay();
-			swapchain.RecordPresentCommands(command, frame.image, draw_ime_overlay);
+			auto& command = *frame.present_commands;
+			swapchain.RecordPresentCommands(command, frame.image);
 			swapchain.Submit(command);
 		}
 		status = swapchain.Present();
@@ -868,7 +825,6 @@ void Presenter::Present(Frame& frame, bool reuse) {
 		}

 		RenderDocOnPresent();
-		m_impl->presented_ime_revision.store(ime_visual.revision, std::memory_order_release);
 		window.UpdateTitle();
 		m_impl->frames.Release(&frame, true);
 		return;
@@ -31,7 +31,6 @@
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vma.h"
 #include "graphics/host_gpu/vulkanCommon.h"
-#include "graphics/presentation/imeOverlay.h"
 #include "graphics/presentation/presenter.h"
 #include "graphics/presentation/renderDoc.h"
 #include "graphics/presentation/videoOut.h"
@@ -260,10 +259,6 @@ static void VulkanFindPhysicalDevice(vk::Instance instance, vk::SurfaceKHR surfa
 			LOGF("sampleRateShading is not supported\n");
 			skip_device = true;
 		}
-		if (device_features2.features.depthBiasClamp != VK_TRUE) {
-			LOGF("depthBiasClamp is not supported\n");
-			skip_device = true;
-		}

 		if (device_features2.features.fragmentStoresAndAtomics != VK_TRUE) {
 			LOGF("fragmentStoresAndAtomics is not supported\n");
@@ -292,6 +287,10 @@ static void VulkanFindPhysicalDevice(vk::Instance instance, vk::SurfaceKHR surfa
 			LOGF("shaderStorageImageReadWithoutFormat is not supported\n");
 			skip_device = true;
 		}
+		if (features12.shaderStorageImageArrayNonUniformIndexing != VK_TRUE) {
+			LOGF("shaderStorageImageArrayNonUniformIndexing is not supported\n");
+			skip_device = true;
+		}

 		if (device_features2.features.shaderImageGatherExtended != VK_TRUE) {
 			LOGF("shaderImageGatherExtended is not supported\n");
@@ -519,6 +518,7 @@ static vk::Device VulkanCreateDevice(vk::PhysicalDevice physical_device, const V
 	features12.sType                    = vk::StructureType::ePhysicalDeviceVulkan12Features;
 	features12.pNext                    = &depth_clip_control;
 	features12.samplerMirrorClampToEdge = VK_TRUE;
+	features12.shaderStorageImageArrayNonUniformIndexing = VK_TRUE;

 	vk::PhysicalDeviceSubgroupSizeControlFeatures subgroup_size_control {};
 	subgroup_size_control.sType = vk::StructureType::ePhysicalDeviceSubgroupSizeControlFeatures;
@@ -553,7 +553,6 @@ static vk::Device VulkanCreateDevice(vk::PhysicalDevice physical_device, const V
 	EXIT_NOT_IMPLEMENTED(required_features13.synchronization2 == VK_TRUE &&
 	                     supported_features13.synchronization2 != VK_TRUE);
 	EXIT_NOT_IMPLEMENTED(supported_features2.features.sampleRateShading != VK_TRUE);
-	EXIT_NOT_IMPLEMENTED(supported_features2.features.depthBiasClamp != VK_TRUE);
 	features12.timelineSemaphore = VK_TRUE;

 	vk::PhysicalDeviceFeatures device_features {};
@@ -569,7 +568,6 @@ static vk::Device VulkanCreateDevice(vk::PhysicalDevice physical_device, const V
 	device_features.independentBlend                     = VK_TRUE;
 	device_features.tessellationShader                   = VK_TRUE;
 	device_features.sampleRateShading                    = VK_TRUE;
-	device_features.depthBiasClamp                       = VK_TRUE;
 	graphics.sample_rate_shading_enabled                 = true;
 	device_features.vertexPipelineStoresAndAtomics =
 	    supported_features2.features.vertexPipelineStoresAndAtomics;
@@ -607,6 +605,10 @@ static vk::Device VulkanCreateDevice(vk::PhysicalDevice physical_device, const V
 	create_info.flags                = {};
 	create_info.pQueueCreateInfos    = &queue_create_info;
 	create_info.queueCreateInfoCount = 1;
+	create_info.enabledLayerCount =
+	    (r.enable_validation_layers ? static_cast<uint32_t>(r.required_layers.size()) : 0);
+	create_info.ppEnabledLayerNames =
+	    (r.enable_validation_layers ? r.required_layers.data() : nullptr);
 	create_info.enabledExtensionCount   = static_cast<uint32_t>(device_extensions.size());
 	create_info.ppEnabledExtensionNames = device_extensions.data();
 	create_info.pEnabledFeatures        = &device_features;
@@ -1011,7 +1013,6 @@ void WindowContext::RecreateSurface() {
 }

 WindowContext::~WindowContext() {
-	ShutdownImeInput();
 	presenter.reset();
 	LibKernel::Memory::InstallGpuResources(nullptr);
 	render_context.reset();
@@ -31,11 +31,8 @@
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/vma.h"
 #include "graphics/host_gpu/vulkanCommon.h"
-#include "graphics/presentation/imeOverlay.h"
 #include "graphics/presentation/renderDoc.h"
-#include "graphics/presentation/window/hostInput.h"
 #include "graphics/presentation/window/windowInternal.h"
-#include "kytyGitVersion.h"
 #include "libs/controller.h"
 #include "loader/systemContent.h"

@@ -61,6 +58,8 @@

 namespace Libs::Graphics {

+constexpr int KEYBOARD_CONTROLLER_ID = -1000;
+
 struct EventKeyboard {
 	bool     down;
 	bool     up;
@@ -73,6 +72,26 @@ struct EventKeyboard {
 	double   timestamp_seconds;
 };

+static uint32_t KeyboardKeyToPadButton(int key_code) {
+	switch (key_code) {
+		case SDLK_w: return Controller::PAD_BUTTON_UP;
+		case SDLK_a: return Controller::PAD_BUTTON_LEFT;
+		case SDLK_s: return Controller::PAD_BUTTON_DOWN;
+		case SDLK_d: return Controller::PAD_BUTTON_RIGHT;
+		case SDLK_j: return Controller::PAD_BUTTON_CROSS;
+		case SDLK_i: return Controller::PAD_BUTTON_TRIANGLE;
+		case SDLK_k: return Controller::PAD_BUTTON_SQUARE;
+		case SDLK_l: return Controller::PAD_BUTTON_CIRCLE;
+		case SDLK_q: return Controller::PAD_BUTTON_L1;
+		case SDLK_e: return Controller::PAD_BUTTON_R1;
+		case SDLK_RETURN:
+		case SDLK_RETURN2: return Controller::PAD_BUTTON_OPTIONS;
+		case SDLK_BACKSPACE:
+		case SDLK_TAB: return Controller::PAD_BUTTON_TOUCH_PAD;
+		default: return 0;
+	}
+}
+
 static uint32_t ControllerButtonToPadButton(int button) {
 	switch (button) {
 		case SDL_CONTROLLER_BUTTON_A: return Controller::PAD_BUTTON_CROSS;
@@ -241,11 +260,16 @@ static void GameEventKeyboard(WindowLoopState& game, const EventKeyboard& key) {
 		}
 	}

-#endif
-
-	if ((key.down || key.up) && !key.repeat) {
-		HostInputKey(key.key_code, key.down);
+	const auto button = KeyboardKeyToPadButton(key.key_code);
+	if (button != 0 && (key.down || key.up) && !key.repeat) {
+		static bool keyboard_connected = false;
+		if (!keyboard_connected) {
+			Controller::ControllerConnect(KEYBOARD_CONTROLLER_ID);
+			keyboard_connected = true;
+		}
+		Controller::ControllerButton(KEYBOARD_CONTROLLER_ID, button, key.down);
 	}
+#endif
 }

 static void GameEventMouse([[maybe_unused]] const EventMouse& mb) {
@@ -267,23 +291,6 @@ static void GameEventMouse([[maybe_unused]] const EventMouse& mb) {
 		     mb.x, mb.y);
 	}
 #endif
-
-	if (mb.down || mb.up) {
-		uint8_t mouse_button = 0;
-		if (mb.left) {
-			mouse_button = SDL_BUTTON_LEFT;
-		} else if (mb.middle) {
-			mouse_button = SDL_BUTTON_MIDDLE;
-		} else if (mb.right) {
-			mouse_button = SDL_BUTTON_RIGHT;
-		} else if (mb.x1) {
-			mouse_button = SDL_BUTTON_X1;
-		} else if (mb.x2) {
-			mouse_button = SDL_BUTTON_X2;
-		}
-
-		HostInputMouseButton(mouse_button, mb.down);
-	}
 }

 static void GameEventFinger([[maybe_unused]] const EventFinger& f) {
@@ -477,9 +484,6 @@ void WindowContext::ProcessEvent(double time_s) {
 	auto& game  = loop;
 	auto* event = &game.event;
 	EXIT_IF(SDL_GetEventState(SDL_DISPLAYEVENT) != SDL_ENABLE);
-	if (ProcessImeInput(*event)) {
-		return;
-	}

 	switch (event->type) {
 		case SDL_QUIT: GameEventQuit(game); break;
@@ -752,18 +756,26 @@ void WindowContext::Run() {
 #if defined(__APPLE__)
 		DrainMainThreadTasks();
 #endif
+		if (SDL_PollEvent(&loop.event) != 0) {
+			ProcessEvent(timer.GetTimeS());
+			continue;
+		}
+
 		if (loop.paused.load(std::memory_order_acquire)) {
 			if (!timer.IsPaused()) {
 				timer.Pause();
 			}
-		} else if (timer.IsPaused()) {
-			timer.Resume();
+			if (SDL_WaitEvent(&loop.event) == 0) {
+				EXIT("%s\n", SDL_GetError());
+			}
+			ProcessEvent(timer.GetTimeS());
+			continue;
 		}

-		if (SDL_WaitEvent(&loop.event) == 0) {
-			EXIT("%s\n", SDL_GetError());
+		if (timer.IsPaused()) {
+			timer.Resume();
 		}
-		ProcessEvent(timer.GetTimeS());
+		Common::Thread::SleepMicro(1000);
 	}
 }

@@ -782,15 +794,10 @@ static void WindowCreate(WindowContext& context) {
 	if (SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) < 0) {
 		EXIT("%s\n", SDL_GetError());
 	}
-	HostInputInit();
-	InitializeImeInput();

 	LOGF("WindowCreate(): width = %d, height = %d\n", width, height);

 	uint32_t window_flags = KYTY_SDL_WINDOW_FLAGS;
-	if (Config::FullscreenEnabled()) {
-		window_flags |= static_cast<uint32_t>(SDL_WINDOW_FULLSCREEN_DESKTOP);
-	}
 #if defined(__APPLE__)
 	// macOS 26 window chrome (CoreUI asset decode, SwiftUI titlebar) has been observed
 	// throwing NSExceptions under Rosetta during the first CATransaction commit. A
@@ -930,14 +937,6 @@ void WindowContext::UpdateTitle() {
 	static uint64_t fps_frames  = 0;
 	static double   current_fps = 0.0;

-#if KYTY_BUILD == KYTY_BUILD_DEBUG
-	static constexpr auto build_type = "Debug";
-#elif KYTY_BUILD == KYTY_BUILD_RELEASE
-	static constexpr auto build_type = "Release";
-#else
-	static constexpr auto build_type = "Unknown";
-#endif
-
 	const auto now       = Common::Timer::QueryPerformanceCounter();
 	const auto frequency = Common::Timer::QueryPerformanceFrequency();
 	frame_num++;
@@ -949,11 +948,11 @@ void WindowContext::UpdateTitle() {
 		fps_frames  = 0;
 	}

-	auto fps = fmt::format(
-	    "[{} | {}] {}{}{}{}{}{}[{}] [{}], frame: {}, fps: {:f}", KYTY_BUILD_LABEL, build_type,
-	    (has_title ? title : ""), (has_title ? ", " : ""), (has_title_id ? title_id : ""),
-	    (has_title_id ? ", " : ""), (has_app_ver ? app_ver : ""), (has_app_ver ? " " : ""),
-	    device_name, processor_name, frame_num, current_fps);
+	auto fps =
+	    fmt::format("{}{}{}{}{}{}[{}] [{}], frame: {}, fps: {:f}", (has_title ? title : ""),
+	                (has_title ? ", " : ""), (has_title_id ? title_id : ""),
+	                (has_title_id ? ", " : ""), (has_app_ver ? app_ver : ""),
+	                (has_app_ver ? " " : ""), device_name, processor_name, frame_num, current_fps);

 #if defined(__APPLE__)
 	// AppKit traps on title changes off the main thread; fire-and-forget keeps present pacing.
@@ -84,8 +84,6 @@ bool InstructionMaySplitSpirvBlock(const IR::Instruction& inst) {
 		case IR::Opcode::AtomicAndU32:
 		case IR::Opcode::AtomicOrU32:
 		case IR::Opcode::AtomicXorU32:
-		case IR::Opcode::AtomicFMinF32:
-		case IR::Opcode::AtomicFMaxF32:
 		case IR::Opcode::FlatLoadUbyte:
 		case IR::Opcode::FlatLoadSbyte:
 		case IR::Opcode::FlatLoadUshort:
@@ -57,8 +57,6 @@ constexpr MemoryOpcodeInfo MUBUF_OPS[] = {
    {0x39u, Opcode::BufferAtomicAnd, 1, 32},
    {0x3au, Opcode::BufferAtomicOr, 1, 32},
    {0x3bu, Opcode::BufferAtomicXor, 1, 32},
-    {0x3fu, Opcode::BufferAtomicFMin, 1, 32},
-    {0x40u, Opcode::BufferAtomicFMax, 1, 32},
 };

 constexpr MemoryOpcodeInfo MTBUF_OPS[] = {
@@ -1,45 +0,0 @@
-#ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_RECOMPILER_DECOMPILER_OPCODETABLE_H_
-#define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_RECOMPILER_DECOMPILER_OPCODETABLE_H_
-
-#include "graphics/shader/recompiler/decompiler/ShaderDecoder.h"
-
-#include <cstddef>
-
-namespace Libs::Graphics::ShaderRecompiler::Decoder::Detail {
-
-struct OpcodeMap {
-	uint32_t encoding = 0;
-	Opcode   decoded  = Opcode::Unknown;
-};
-
-template <typename Entry, size_t N>
-constexpr const Entry* FindOpcode(const Entry (&table)[N], uint32_t encoding) {
-	for (const auto& entry: table) {
-		if (entry.encoding == encoding) {
-			return &entry;
-		}
-	}
-	return nullptr;
-}
-
-template <typename Entry, size_t N>
-constexpr Opcode LookupOpcode(const Entry (&table)[N], uint32_t encoding) {
-	const auto* entry = FindOpcode(table, encoding);
-	return entry != nullptr ? entry->decoded : Opcode::Unsupported;
-}
-
-template <typename Entry, size_t N>
-constexpr bool HasUniqueEncodings(const Entry (&table)[N]) {
-	for (size_t i = 0; i < N; i++) {
-		for (size_t j = i + 1; j < N; j++) {
-			if (table[i].encoding == table[j].encoding) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-} // namespace Libs::Graphics::ShaderRecompiler::Decoder::Detail
-
-#endif // EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_RECOMPILER_DECOMPILER_OPCODETABLE_H_
@@ -1,11 +1,14 @@
 #include "graphics/shader/recompiler/decompiler/ScalarAluOps.h"

-#include "graphics/shader/recompiler/decompiler/OpcodeTable.h"
+#include <iterator>

 namespace Libs::Graphics::ShaderRecompiler::Decoder {
 namespace {

-using Detail::OpcodeMap;
+struct OpcodeMap {
+	uint32_t opcode = 0;
+	Opcode   ir     = Opcode::Unknown;
+};

 constexpr OpcodeMap SOP2_OPS[] = {
    {0x00u, Opcode::SAddU32},       {0x01u, Opcode::SSubU32},       {0x02u, Opcode::SAddI32},
@@ -55,8 +58,7 @@ constexpr OpcodeMap SOPC_OPS[] = {
    {0x03u, Opcode::SCmpGeI32},   {0x04u, Opcode::SCmpLtI32},   {0x05u, Opcode::SCmpLeI32},
    {0x06u, Opcode::SCmpEqU32},   {0x07u, Opcode::SCmpLgU32},   {0x08u, Opcode::SCmpGtU32},
    {0x09u, Opcode::SCmpGeU32},   {0x0au, Opcode::SCmpLtU32},   {0x0bu, Opcode::SCmpLeU32},
-    {0x0cu, Opcode::SBitcmp0B32}, {0x0du, Opcode::SBitcmp1B32}, {0x12u, Opcode::SCmpEqU64},
-    {0x13u, Opcode::SCmpLgU64},
+    {0x0cu, Opcode::SBitcmp0B32}, {0x0du, Opcode::SBitcmp1B32}, {0x13u, Opcode::SCmpLgU64},
 };

 constexpr OpcodeMap SOPK_OPS[] = {
@@ -76,11 +78,15 @@ constexpr OpcodeMap SOPP_OPS[] = {
    {0x0au, Opcode::SBarrier},      {0x0cu, Opcode::SWaitcnt},      {0x0eu, Opcode::SSleep},
    {0x10u, Opcode::SSendmsg},      {0x16u, Opcode::STtraceData},   {0x20u, Opcode::SInstPrefetch},
 };
-static_assert(Detail::HasUniqueEncodings(SOP1_OPS));
-static_assert(Detail::HasUniqueEncodings(SOP2_OPS));
-static_assert(Detail::HasUniqueEncodings(SOPK_OPS));
-static_assert(Detail::HasUniqueEncodings(SOPC_OPS));
-static_assert(Detail::HasUniqueEncodings(SOPP_OPS));
+
+Opcode Lookup(const OpcodeMap* ops, uint32_t count, uint32_t opcode) {
+	for (uint32_t i = 0; i < count; i++) {
+		if (ops[i].opcode == opcode) {
+			return ops[i].ir;
+		}
+	}
+	return Opcode::Unsupported;
+}

 bool DecodeBinarySources(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index,
                         Instruction& inst, uint32_t ssrc0, uint32_t ssrc1, std::string* error) {
@@ -105,7 +111,7 @@ bool DecodeSop1(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::SOP1;
 	inst.opcode_id = opcode;
-	inst.opcode    = Detail::LookupOpcode(SOP1_OPS, opcode);
+	inst.opcode    = Lookup(SOP1_OPS, static_cast<uint32_t>(std::size(SOP1_OPS)), opcode);
 	SetRawWords(inst, code, word_index, 1);

 	if (inst.opcode == Opcode::Unsupported) {
@@ -147,7 +153,7 @@ bool DecodeSop2(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::SOP2;
 	inst.opcode_id = opcode;
-	inst.opcode    = Detail::LookupOpcode(SOP2_OPS, opcode);
+	inst.opcode    = Lookup(SOP2_OPS, static_cast<uint32_t>(std::size(SOP2_OPS)), opcode);
 	SetRawWords(inst, code, word_index, 1);

 	if (inst.opcode == Opcode::Unsupported) {
@@ -174,7 +180,7 @@ bool DecodeSopk(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word            = word;
 	inst.family          = Family::SOPK;
 	inst.opcode_id       = opcode;
-	inst.opcode          = Detail::LookupOpcode(SOPK_OPS, opcode);
+	inst.opcode          = Lookup(SOPK_OPS, static_cast<uint32_t>(std::size(SOPK_OPS)), opcode);
 	inst.src0.kind       = OperandKind::IntegerInlineConstant;
 	inst.src0.signed_val = imm;
 	inst.src0.value      = static_cast<uint32_t>(imm);
@@ -231,7 +237,7 @@ bool DecodeSopc(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::SOPC;
 	inst.opcode_id = opcode;
-	inst.opcode    = Detail::LookupOpcode(SOPC_OPS, opcode);
+	inst.opcode    = Lookup(SOPC_OPS, static_cast<uint32_t>(std::size(SOPC_OPS)), opcode);
 	inst.dst.kind  = OperandKind::Scc;
 	SetRawWords(inst, code, word_index, 1);

@@ -255,7 +261,7 @@ bool DecodeSopp(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word            = word;
 	inst.family          = Family::SOPP;
 	inst.opcode_id       = opcode;
-	inst.opcode          = Detail::LookupOpcode(SOPP_OPS, opcode);
+	inst.opcode          = Lookup(SOPP_OPS, static_cast<uint32_t>(std::size(SOPP_OPS)), opcode);
 	inst.src0.kind       = OperandKind::LiteralConstant;
 	inst.src0.value      = simm;
 	inst.src0.signed_val = static_cast<int16_t>(simm);
@@ -77,16 +77,6 @@ std::string FormatBinary(const Instruction& inst) {
 	return text;
 }

-std::string FormatSources(const Instruction& inst) {
-	std::string    text      = fmt::format("0x{:08x}: {}", inst.pc, OpcodeToString(inst.opcode));
-	const Operand* sources[] = {&inst.src0, &inst.src1, &inst.src2, &inst.src3};
-	for (uint32_t i = 0; i < inst.src_count && i < 4u; i++) {
-		text += i == 0 ? " " : ", ";
-		text += OperandToString(*sources[i]);
-	}
-	return text;
-}
-
 std::string FormatMemory(const Instruction& inst) {
 	std::string text = fmt::format("0x{:08x}: {} {}", inst.pc, OpcodeToString(inst.opcode).c_str(),
 	                               OperandToString(inst.dst).c_str());
@@ -521,7 +511,6 @@ std::string OpcodeToString(Opcode opcode) {
 		case Opcode::SCmpGeU32: return "s_cmp_ge_u32";
 		case Opcode::SCmpLtU32: return "s_cmp_lt_u32";
 		case Opcode::SCmpLeU32: return "s_cmp_le_u32";
-		case Opcode::SCmpEqU64: return "s_cmp_eq_u64";
 		case Opcode::SCmpLgU64: return "s_cmp_lg_u64";
 		case Opcode::VNop: return "v_nop";
 		case Opcode::VMovB32: return "v_mov_b32";
@@ -777,7 +766,6 @@ std::string OpcodeToString(Opcode opcode) {
 		case Opcode::VCmpNeU32: return "v_cmp_ne_u32";
 		case Opcode::VCmpGeU32: return "v_cmp_ge_u32";
 		case Opcode::VCmpTU32: return "v_cmp_t_u32";
-		case Opcode::VCmpEqI64: return "v_cmp_eq_i64";
 		case Opcode::VCmpNeU64: return "v_cmp_ne_u64";
 		case Opcode::VCmpxLtU32: return "v_cmpx_lt_u32";
 		case Opcode::VCmpxEqU32: return "v_cmpx_eq_u32";
@@ -835,8 +823,6 @@ std::string OpcodeToString(Opcode opcode) {
 		case Opcode::BufferAtomicAnd: return "buffer_atomic_and";
 		case Opcode::BufferAtomicOr: return "buffer_atomic_or";
 		case Opcode::BufferAtomicXor: return "buffer_atomic_xor";
-		case Opcode::BufferAtomicFMin: return "buffer_atomic_fmin";
-		case Opcode::BufferAtomicFMax: return "buffer_atomic_fmax";
 		case Opcode::FlatLoadUbyte: return "flat_load_ubyte";
 		case Opcode::FlatLoadSbyte: return "flat_load_sbyte";
 		case Opcode::FlatLoadUshort: return "flat_load_ushort";
@@ -997,9 +983,6 @@ std::string InstructionToString(const Instruction& inst) {
 		                   inst.pc, FamilyToString(inst.family).c_str(), inst.opcode_id,
 		                   RawWordsToString(inst).c_str(), inst.unsupported_reason.c_str());
 	}
-	if (inst.family == Family::SOPC) {
-		return WithUnsupportedReason(inst, FormatSources(inst));
-	}

 	switch (inst.opcode) {
 		case Opcode::SMovB32:
@@ -1127,8 +1110,6 @@ std::string InstructionToString(const Instruction& inst) {
 		case Opcode::BufferAtomicAnd:
 		case Opcode::BufferAtomicOr:
 		case Opcode::BufferAtomicXor:
-		case Opcode::BufferAtomicFMin:
-		case Opcode::BufferAtomicFMax:
 		case Opcode::BufferLoadSbyte:
 		case Opcode::BufferLoadSshort:
 		case Opcode::FlatLoadUbyte:
@@ -1190,6 +1171,25 @@ std::string InstructionToString(const Instruction& inst) {
 		case Opcode::DsWriteB128:
 		case Opcode::DsWriteAddtidB32:
 		case Opcode::DsReadAddtidB32: return WithUnsupportedReason(inst, FormatMemory(inst));
+		case Opcode::SCmpEqU32:
+		case Opcode::SCmpEqI32:
+		case Opcode::SCmpLgU32:
+		case Opcode::SCmpLgI32:
+		case Opcode::SCmpGtU32:
+		case Opcode::SCmpGtI32:
+		case Opcode::SCmpGeU32:
+		case Opcode::SCmpGeI32:
+		case Opcode::SCmpLtU32:
+		case Opcode::SCmpLtI32:
+		case Opcode::SCmpLeU32:
+		case Opcode::SCmpLeI32:
+		case Opcode::SBitcmp0B32:
+		case Opcode::SBitcmp1B32:
+		case Opcode::SCmpLgU64:
+			return WithUnsupportedReason(inst, fmt::format("0x{:08x}: {} {}, {}", inst.pc,
+			                                               OpcodeToString(inst.opcode).c_str(),
+			                                               OperandToString(inst.src0).c_str(),
+			                                               OperandToString(inst.src1).c_str()));
 		default: return WithUnsupportedReason(inst, FormatBinary(inst));
 	}
 }
@@ -118,7 +118,6 @@ enum class Opcode {
 	SCmpGeU32,
 	SCmpLtU32,
 	SCmpLeU32,
-	SCmpEqU64,
 	SCmpLgU64,

 	VNop,
@@ -375,7 +374,6 @@ enum class Opcode {
 	VCmpNeU32,
 	VCmpGeU32,
 	VCmpTU32,
-	VCmpEqI64,
 	VCmpNeU64,
 	VCmpxLtU32,
 	VCmpxEqU32,
@@ -434,8 +432,6 @@ enum class Opcode {
 	BufferAtomicAnd,
 	BufferAtomicOr,
 	BufferAtomicXor,
-	BufferAtomicFMin,
-	BufferAtomicFMax,
 	FlatLoadUbyte,
 	FlatLoadSbyte,
 	FlatLoadUshort,
@@ -1,91 +1,43 @@
 #include "graphics/shader/recompiler/decompiler/VectorAluOps.h"

-#include "graphics/shader/recompiler/decompiler/OpcodeTable.h"
-
 #include <fmt/format.h>
+#include <iterator>

 namespace Libs::Graphics::ShaderRecompiler::Decoder {
 namespace {

-using Detail::OpcodeMap;
-
-// These profiles describe the selectors that the current lowering implements. They are not
-// architectural SDWA legality classes.
-enum class Vop2SdwaProfile {
-	None,
-	Cndmask,
-	Float32,
-	Float16,
-	IntegerFullDestination,
-	IntegerPartialDestination,
-	ReverseLogicalRight,
-	ReverseLogicalLeft,
-	Bitwise,
-	Count,
+struct OpcodeMap {
+	uint32_t opcode = 0;
+	Opcode   ir     = Opcode::Unknown;
 };

-struct Vop2OpcodeInfo {
-	uint32_t        encoding     = 0;
-	Opcode          decoded      = Opcode::Unknown;
-	Vop2SdwaProfile sdwa_profile = Vop2SdwaProfile::None;
+constexpr OpcodeMap VOP2_OPS[] = {
+    {0x01u, Opcode::VCndmaskB32},    {0x02u, Opcode::VDot2cF32F16},
+    {0x03u, Opcode::VAddF32},        {0x04u, Opcode::VSubF32},
+    {0x05u, Opcode::VSubrevF32},     {0x08u, Opcode::VMulF32},
+    {0x09u, Opcode::VMulI32I24},     {0x0bu, Opcode::VMulU32U24},
+    {0x0fu, Opcode::VMinF32},        {0x10u, Opcode::VMaxF32},
+    {0x11u, Opcode::VMinI32},        {0x12u, Opcode::VMaxI32},
+    {0x13u, Opcode::VMinU32},        {0x14u, Opcode::VMaxU32},
+    {0x15u, Opcode::VLshrB32},       {0x16u, Opcode::VLshrrevB32},
+    {0x17u, Opcode::VAshrI32},       {0x18u, Opcode::VAshrrevI32},
+    {0x19u, Opcode::VLshlB32},       {0x1au, Opcode::VLshlrevB32},
+    {0x1bu, Opcode::VAndB32},        {0x1cu, Opcode::VOrB32},
+    {0x1du, Opcode::VXorB32},        {0x1eu, Opcode::VXnorB32},
+    {0x1fu, Opcode::VMacF32},        {0x20u, Opcode::VMadmkF32},
+    {0x21u, Opcode::VMadakF32},      {0x22u, Opcode::VBcntU32B32},
+    {0x23u, Opcode::VMbcntLoU32B32}, {0x24u, Opcode::VMbcntHiU32B32},
+    {0x25u, Opcode::VAddNcU32},      {0x28u, Opcode::VAddcU32},
+    {0x26u, Opcode::VSubNcU32},      {0x27u, Opcode::VSubrevNcU32},
+    {0x2bu, Opcode::VMacF32},        {0x2cu, Opcode::VMadmkF32},
+    {0x2du, Opcode::VMadakF32},      {0x2fu, Opcode::VCvtPkrtzF16F32},
+    {0x32u, Opcode::VAddF16},        {0x33u, Opcode::VSubF16},
+    {0x34u, Opcode::VSubrevF16},     {0x35u, Opcode::VMulF16},
+    {0x36u, Opcode::VFmacF16},       {0x37u, Opcode::VFmamkF16},
+    {0x38u, Opcode::VFmaakF16},      {0x39u, Opcode::VMaxF16},
+    {0x3au, Opcode::VMinF16},        {0x3cu, Opcode::VPkFmacF16},
 };

-constexpr Vop2OpcodeInfo VOP2_OPS[] = {
-    {0x01u, Opcode::VCndmaskB32, Vop2SdwaProfile::Cndmask},
-    {0x02u, Opcode::VDot2cF32F16},
-    {0x03u, Opcode::VAddF32, Vop2SdwaProfile::Float32},
-    {0x04u, Opcode::VSubF32, Vop2SdwaProfile::Float32},
-    {0x05u, Opcode::VSubrevF32},
-    {0x08u, Opcode::VMulF32, Vop2SdwaProfile::Float32},
-    {0x09u, Opcode::VMulI32I24, Vop2SdwaProfile::IntegerFullDestination},
-    {0x0bu, Opcode::VMulU32U24, Vop2SdwaProfile::IntegerFullDestination},
-    {0x0fu, Opcode::VMinF32},
-    {0x10u, Opcode::VMaxF32},
-    {0x11u, Opcode::VMinI32},
-    {0x12u, Opcode::VMaxI32},
-    {0x13u, Opcode::VMinU32, Vop2SdwaProfile::IntegerPartialDestination},
-    {0x14u, Opcode::VMaxU32, Vop2SdwaProfile::IntegerFullDestination},
-    {0x15u, Opcode::VLshrB32},
-    {0x16u, Opcode::VLshrrevB32, Vop2SdwaProfile::ReverseLogicalRight},
-    {0x17u, Opcode::VAshrI32},
-    {0x18u, Opcode::VAshrrevI32},
-    {0x19u, Opcode::VLshlB32},
-    {0x1au, Opcode::VLshlrevB32, Vop2SdwaProfile::ReverseLogicalLeft},
-    {0x1bu, Opcode::VAndB32, Vop2SdwaProfile::Bitwise},
-    {0x1cu, Opcode::VOrB32, Vop2SdwaProfile::Bitwise},
-    {0x1du, Opcode::VXorB32, Vop2SdwaProfile::Bitwise},
-    {0x1eu, Opcode::VXnorB32, Vop2SdwaProfile::Bitwise},
-    {0x1fu, Opcode::VMacF32},
-    {0x20u, Opcode::VMadmkF32},
-    {0x21u, Opcode::VMadakF32},
-    {0x22u, Opcode::VBcntU32B32},
-    {0x23u, Opcode::VMbcntLoU32B32},
-    {0x24u, Opcode::VMbcntHiU32B32},
-    {0x25u, Opcode::VAddNcU32, Vop2SdwaProfile::IntegerFullDestination},
-    {0x28u, Opcode::VAddcU32},
-    {0x26u, Opcode::VSubNcU32, Vop2SdwaProfile::IntegerPartialDestination},
-    {0x27u, Opcode::VSubrevNcU32, Vop2SdwaProfile::IntegerFullDestination},
-    {0x2bu, Opcode::VMacF32},
-    {0x2cu, Opcode::VMadmkF32},
-    {0x2du, Opcode::VMadakF32},
-    {0x2fu, Opcode::VCvtPkrtzF16F32},
-    {0x32u, Opcode::VAddF16, Vop2SdwaProfile::Float16},
-    {0x33u, Opcode::VSubF16, Vop2SdwaProfile::Float16},
-    {0x34u, Opcode::VSubrevF16, Vop2SdwaProfile::Float16},
-    {0x35u, Opcode::VMulF16, Vop2SdwaProfile::Float16},
-    {0x36u, Opcode::VFmacF16},
-    {0x37u, Opcode::VFmamkF16},
-    {0x38u, Opcode::VFmaakF16},
-    {0x39u, Opcode::VMaxF16, Vop2SdwaProfile::Float16},
-    {0x3au, Opcode::VMinF16, Vop2SdwaProfile::Float16},
-    {0x3cu, Opcode::VPkFmacF16},
-};
-static_assert(Detail::HasUniqueEncodings(VOP2_OPS));
-
-constexpr Opcode LookupVop2Opcode(uint32_t encoding) {
-	return Detail::LookupOpcode(VOP2_OPS, encoding);
-}
-
 constexpr OpcodeMap VOP1_OPS[] = {
    {0x00u, Opcode::VNop},
    {0x01u, Opcode::VMovB32},
@@ -183,59 +135,37 @@ constexpr OpcodeMap VOP3_ENCODED_VOP1_OPS[] = {
    {0x5eu, Opcode::VRndneF16},
 };

-struct VopcOpcodeInfo {
-	uint32_t encoding     = 0;
-	Opcode   decoded      = Opcode::Unknown;
-	bool     supports_dpp = true;
+constexpr OpcodeMap VOPC_OPS[] = {
+    {0x00u, Opcode::VCmpFF32},     {0x01u, Opcode::VCmpLtF32},   {0x02u, Opcode::VCmpEqF32},
+    {0x03u, Opcode::VCmpLeF32},    {0x04u, Opcode::VCmpGtF32},   {0x05u, Opcode::VCmpLgF32},
+    {0x06u, Opcode::VCmpGeF32},    {0x07u, Opcode::VCmpOF32},    {0x08u, Opcode::VCmpUF32},
+    {0x09u, Opcode::VCmpNgeF32},   {0x0au, Opcode::VCmpNlgF32},  {0x0bu, Opcode::VCmpNgtF32},
+    {0x0cu, Opcode::VCmpNleF32},   {0x0du, Opcode::VCmpNeqF32},  {0x0eu, Opcode::VCmpNltF32},
+    {0x0fu, Opcode::VCmpTruF32},   {0x11u, Opcode::VCmpxLtF32},  {0x12u, Opcode::VCmpxEqF32},
+    {0x13u, Opcode::VCmpxLeF32},   {0x14u, Opcode::VCmpxGtF32},  {0x15u, Opcode::VCmpxLgF32},
+    {0x16u, Opcode::VCmpxGeF32},   {0x19u, Opcode::VCmpxNgeF32}, {0x1au, Opcode::VCmpxNlgF32},
+    {0x1bu, Opcode::VCmpxNgtF32},  {0x1cu, Opcode::VCmpxNleF32}, {0x1du, Opcode::VCmpxNeqF32},
+    {0x1eu, Opcode::VCmpxNltF32},  {0x80u, Opcode::VCmpFI32},    {0x81u, Opcode::VCmpLtI32},
+    {0x82u, Opcode::VCmpEqI32},    {0x83u, Opcode::VCmpLeI32},   {0x84u, Opcode::VCmpGtI32},
+    {0x85u, Opcode::VCmpNeI32},    {0x86u, Opcode::VCmpGeI32},   {0x87u, Opcode::VCmpTI32},
+    {0x88u, Opcode::VCmpClassF32}, {0x89u, Opcode::VCmpLtI16},   {0x8au, Opcode::VCmpEqI16},
+    {0x8bu, Opcode::VCmpLeI16},    {0x8cu, Opcode::VCmpGtI16},   {0x8du, Opcode::VCmpNeI16},
+    {0x8eu, Opcode::VCmpGeI16},    {0x91u, Opcode::VCmpxLtI32},  {0x92u, Opcode::VCmpxEqI32},
+    {0x93u, Opcode::VCmpxLeI32},   {0x94u, Opcode::VCmpxGtI32},  {0x95u, Opcode::VCmpxNeI32},
+    {0x96u, Opcode::VCmpxGeI32},   {0xa9u, Opcode::VCmpLtU16},   {0xaau, Opcode::VCmpEqU16},
+    {0xabu, Opcode::VCmpLeU16},    {0xacu, Opcode::VCmpGtU16},   {0xadu, Opcode::VCmpNeU16},
+    {0xaeu, Opcode::VCmpGeU16},    {0xc0u, Opcode::VCmpFU32},    {0xc1u, Opcode::VCmpLtU32},
+    {0xc2u, Opcode::VCmpEqU32},    {0xc3u, Opcode::VCmpLeU32},   {0xc4u, Opcode::VCmpGtU32},
+    {0xc5u, Opcode::VCmpNeU32},    {0xc6u, Opcode::VCmpGeU32},   {0xc7u, Opcode::VCmpTU32},
+    {0xd1u, Opcode::VCmpxLtU32},   {0xd2u, Opcode::VCmpxEqU32},  {0xd3u, Opcode::VCmpxLeU32},
+    {0xd4u, Opcode::VCmpxGtU32},   {0xd5u, Opcode::VCmpxNeU32},  {0xd6u, Opcode::VCmpxGeU32},
+    {0xe5u, Opcode::VCmpNeU64},    {0xc9u, Opcode::VCmpLtF16},   {0xcau, Opcode::VCmpEqF16},
+    {0xcbu, Opcode::VCmpLeF16},    {0xccu, Opcode::VCmpGtF16},   {0xcdu, Opcode::VCmpLgF16},
+    {0xceu, Opcode::VCmpGeF16},    {0xedu, Opcode::VCmpNeqF16},  {0xd9u, Opcode::VCmpxLtF16},
+    {0xdau, Opcode::VCmpxEqF16},   {0xdbu, Opcode::VCmpxLeF16},  {0xdcu, Opcode::VCmpxGtF16},
+    {0xdeu, Opcode::VCmpxGeF16},   {0xfdu, Opcode::VCmpxNeqF16}, {0xfeu, Opcode::VCmpxNltF16},
 };

-constexpr VopcOpcodeInfo VOPC_OPS[] = {
-    {0x00u, Opcode::VCmpFF32},         {0x01u, Opcode::VCmpLtF32},
-    {0x02u, Opcode::VCmpEqF32},        {0x03u, Opcode::VCmpLeF32},
-    {0x04u, Opcode::VCmpGtF32},        {0x05u, Opcode::VCmpLgF32},
-    {0x06u, Opcode::VCmpGeF32},        {0x07u, Opcode::VCmpOF32},
-    {0x08u, Opcode::VCmpUF32},         {0x09u, Opcode::VCmpNgeF32},
-    {0x0au, Opcode::VCmpNlgF32},       {0x0bu, Opcode::VCmpNgtF32},
-    {0x0cu, Opcode::VCmpNleF32},       {0x0du, Opcode::VCmpNeqF32},
-    {0x0eu, Opcode::VCmpNltF32},       {0x0fu, Opcode::VCmpTruF32},
-    {0x11u, Opcode::VCmpxLtF32},       {0x12u, Opcode::VCmpxEqF32},
-    {0x13u, Opcode::VCmpxLeF32},       {0x14u, Opcode::VCmpxGtF32},
-    {0x15u, Opcode::VCmpxLgF32},       {0x16u, Opcode::VCmpxGeF32},
-    {0x19u, Opcode::VCmpxNgeF32},      {0x1au, Opcode::VCmpxNlgF32},
-    {0x1bu, Opcode::VCmpxNgtF32},      {0x1cu, Opcode::VCmpxNleF32},
-    {0x1du, Opcode::VCmpxNeqF32},      {0x1eu, Opcode::VCmpxNltF32},
-    {0x80u, Opcode::VCmpFI32},         {0x81u, Opcode::VCmpLtI32},
-    {0x82u, Opcode::VCmpEqI32},        {0x83u, Opcode::VCmpLeI32},
-    {0x84u, Opcode::VCmpGtI32},        {0x85u, Opcode::VCmpNeI32},
-    {0x86u, Opcode::VCmpGeI32},        {0x87u, Opcode::VCmpTI32},
-    {0x88u, Opcode::VCmpClassF32},     {0x89u, Opcode::VCmpLtI16},
-    {0x8au, Opcode::VCmpEqI16},        {0x8bu, Opcode::VCmpLeI16},
-    {0x8cu, Opcode::VCmpGtI16},        {0x8du, Opcode::VCmpNeI16},
-    {0x8eu, Opcode::VCmpGeI16},        {0x91u, Opcode::VCmpxLtI32},
-    {0x92u, Opcode::VCmpxEqI32},       {0x93u, Opcode::VCmpxLeI32},
-    {0x94u, Opcode::VCmpxGtI32},       {0x95u, Opcode::VCmpxNeI32},
-    {0x96u, Opcode::VCmpxGeI32},       {0xa9u, Opcode::VCmpLtU16},
-    {0xaau, Opcode::VCmpEqU16},        {0xabu, Opcode::VCmpLeU16},
-    {0xacu, Opcode::VCmpGtU16},        {0xadu, Opcode::VCmpNeU16},
-    {0xaeu, Opcode::VCmpGeU16},        {0xc0u, Opcode::VCmpFU32},
-    {0xc1u, Opcode::VCmpLtU32},        {0xc2u, Opcode::VCmpEqU32},
-    {0xc3u, Opcode::VCmpLeU32},        {0xc4u, Opcode::VCmpGtU32},
-    {0xc5u, Opcode::VCmpNeU32},        {0xc6u, Opcode::VCmpGeU32},
-    {0xc7u, Opcode::VCmpTU32},         {0xa2u, Opcode::VCmpEqI64, false},
-    {0xd1u, Opcode::VCmpxLtU32},       {0xd2u, Opcode::VCmpxEqU32},
-    {0xd3u, Opcode::VCmpxLeU32},       {0xd4u, Opcode::VCmpxGtU32},
-    {0xd5u, Opcode::VCmpxNeU32},       {0xd6u, Opcode::VCmpxGeU32},
-    {0xe5u, Opcode::VCmpNeU64, false}, {0xc9u, Opcode::VCmpLtF16},
-    {0xcau, Opcode::VCmpEqF16},        {0xcbu, Opcode::VCmpLeF16},
-    {0xccu, Opcode::VCmpGtF16},        {0xcdu, Opcode::VCmpLgF16},
-    {0xceu, Opcode::VCmpGeF16},        {0xedu, Opcode::VCmpNeqF16},
-    {0xd9u, Opcode::VCmpxLtF16},       {0xdau, Opcode::VCmpxEqF16},
-    {0xdbu, Opcode::VCmpxLeF16},       {0xdcu, Opcode::VCmpxGtF16},
-    {0xdeu, Opcode::VCmpxGeF16},       {0xfdu, Opcode::VCmpxNeqF16},
-    {0xfeu, Opcode::VCmpxNltF16},
-};
-static_assert(Detail::HasUniqueEncodings(VOPC_OPS));
-
 constexpr OpcodeMap VOP3_OPS[] = {
    {0x141u, Opcode::VMadF32},          {0x142u, Opcode::VMadI32I24},
    {0x143u, Opcode::VMadU32U24},       {0x176u, Opcode::VMadU64U32},
@@ -284,6 +214,16 @@ constexpr OpcodeMap VOP3P_OPS[] = {
    {0x22u, Opcode::VMadMixhiF16},
 };

+Opcode Lookup(const OpcodeMap* ops, uint32_t count, uint32_t opcode) {
+	for (uint32_t i = 0; i < count; i++) {
+		const auto& op = ops[i];
+		if (op.opcode == opcode) {
+			return op.ir;
+		}
+	}
+	return Opcode::Unsupported;
+}
+
 bool IsVop2LiteralMadOpcode(uint32_t opcode) {
 	return opcode == 0x20u || opcode == 0x21u || opcode == 0x2cu || opcode == 0x2du;
 }
@@ -294,23 +234,24 @@ bool IsUnsupportedVop3EncodedVop2Alias(uint32_t opcode) {
 }

 Opcode LookupVop3Opcode(uint32_t opcode) {
-	const auto direct = Detail::LookupOpcode(VOP3_OPS, opcode);
+	const auto direct = Lookup(VOP3_OPS, static_cast<uint32_t>(std::size(VOP3_OPS)), opcode);
 	if (direct != Opcode::Unsupported) {
 		return direct;
 	}
 	if (opcode <= 0xffu) {
-		return Detail::LookupOpcode(VOPC_OPS, opcode);
+		return Lookup(VOPC_OPS, static_cast<uint32_t>(std::size(VOPC_OPS)), opcode);
 	}
 	if (opcode >= 0x100u && opcode <= 0x13fu) {
 		if (IsUnsupportedVop3EncodedVop2Alias(opcode - 0x100u)) {
 			return Opcode::Unsupported;
 		}
-		return LookupVop2Opcode(opcode - 0x100u);
+		return Lookup(VOP2_OPS, static_cast<uint32_t>(std::size(VOP2_OPS)), opcode - 0x100u);
 	}
 	if (opcode >= 0x180u && opcode <= 0x1ffu) {
-		return Detail::LookupOpcode(VOP3_ENCODED_VOP1_OPS, opcode - 0x180u);
+		return Lookup(VOP3_ENCODED_VOP1_OPS,
+		              static_cast<uint32_t>(std::size(VOP3_ENCODED_VOP1_OPS)), opcode - 0x180u);
 	}
-	return Detail::LookupOpcode(VOP3_OPS, opcode);
+	return Lookup(VOP3_OPS, static_cast<uint32_t>(std::size(VOP3_OPS)), opcode);
 }

 bool IsVop3EncodedVopc(uint32_t opcode) {
@@ -850,6 +791,7 @@ Vop2SdwaFields DecodeVop2SdwaFields(uint32_t modifier) {
 }

 struct Vop2SdwaRule {
+	Opcode   opcode           = Opcode::Unknown;
 	uint32_t dst_selectors    = SdwaSelFull();
 	uint32_t src0_selectors   = SdwaSelFull();
 	uint32_t src1_selectors   = SdwaSelFull();
@@ -862,27 +804,46 @@ constexpr uint32_t SdwaSelAll() {
 }

 constexpr Vop2SdwaRule VOP2_SDWA_RULES[] = {
-    {},
-    {SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
-     true, false},
-    {SdwaSelFull(), SdwaSelFull(), SdwaSelFull(), false, true},
-    {SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
-     true, true},
-    {SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
-    {SdwaSelAll(), SdwaSelAll(), SdwaSelAll(), true, false},
-    {SdwaSelFull(), SdwaSelFull(), SdwaSelWords() | SdwaSelFull(), false, false},
-    {SdwaSelFull(), SdwaSelFull(), SdwaSelAll(), false, false},
-    {SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
+    {Opcode::VCndmaskB32, SdwaSelWords(), SdwaSelWords() | SdwaSelFull(),
+     SdwaSelWords() | SdwaSelFull(), true, false},
+    {Opcode::VAddF32, SdwaSelFull(), SdwaSelFull(), SdwaSelFull(), false, true},
+    {Opcode::VSubF32, SdwaSelFull(), SdwaSelFull(), SdwaSelFull(), false, true},
+    {Opcode::VMulF32, SdwaSelFull(), SdwaSelFull(), SdwaSelFull(), false, true},
+    {Opcode::VAddF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
+     SdwaSelWords() | SdwaSelFull(), true, true},
+    {Opcode::VSubF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
+     SdwaSelWords() | SdwaSelFull(), true, true},
+    {Opcode::VSubrevF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
+     SdwaSelWords() | SdwaSelFull(), true, true},
+    {Opcode::VMulF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
+     SdwaSelWords() | SdwaSelFull(), true, true},
+    {Opcode::VMaxF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
+     SdwaSelWords() | SdwaSelFull(), true, true},
+    {Opcode::VMinF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
+     SdwaSelWords() | SdwaSelFull(), true, true},
+    {Opcode::VMulI32I24, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
+    {Opcode::VMulU32U24, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
+    {Opcode::VMinU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
+    {Opcode::VMaxU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
+    {Opcode::VLshrrevB32, SdwaSelFull(), SdwaSelFull(), SdwaSelWords() | SdwaSelFull(), false,
+     false},
+    {Opcode::VLshlrevB32, SdwaSelFull(), SdwaSelFull(), SdwaSelAll(), false, false},
+    {Opcode::VAndB32, SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
+    {Opcode::VOrB32, SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
+    {Opcode::VXorB32, SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
+    {Opcode::VXnorB32, SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
+    {Opcode::VAddNcU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
+    {Opcode::VSubNcU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
+    {Opcode::VSubrevNcU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
 };
-static_assert(sizeof(VOP2_SDWA_RULES) / sizeof(VOP2_SDWA_RULES[0]) ==
-              static_cast<size_t>(Vop2SdwaProfile::Count));

-const Vop2SdwaRule* FindVop2SdwaRule(uint32_t encoding) {
-	const auto* info = Detail::FindOpcode(VOP2_OPS, encoding);
-	if (info == nullptr || info->sdwa_profile == Vop2SdwaProfile::None) {
-		return nullptr;
+const Vop2SdwaRule* FindVop2SdwaRule(Opcode opcode) {
+	for (const auto& rule: VOP2_SDWA_RULES) {
+		if (rule.opcode == opcode) {
+			return &rule;
+		}
 	}
-	return &VOP2_SDWA_RULES[static_cast<size_t>(info->sdwa_profile)];
+	return nullptr;
 }

 bool IsVop2SdwaDestinationSupported(const Vop2SdwaRule& rule, const Vop2SdwaFields& fields) {
@@ -920,7 +881,7 @@ bool ValidateVop2Sdwa(Instruction& inst, uint32_t opcode, const Vop2SdwaFields&
 		return true;
 	}

-	const auto* rule = FindVop2SdwaRule(opcode);
+	const auto* rule = FindVop2SdwaRule(inst.opcode);
 	if (rule == nullptr) {
 		SetUnsupported(inst, Family::VOP2, opcode,
 		               "VOP2 SDWA modifier is not supported for opcode");
@@ -1174,11 +1135,6 @@ bool DecodeVopcDpp(uint32_t pc, std::span<const uint32_t> code, uint32_t word_in
 		SetUnsupported(inst, Family::VOPC, opcode, "VOPC opcode is not implemented");
 		return true;
 	}
-	const auto* info = Detail::FindOpcode(VOPC_OPS, opcode);
-	if (info == nullptr || !info->supports_dpp) {
-		SetUnsupported(inst, Family::VOPC, opcode, "VOPC DPP modifier is not supported for opcode");
-		return true;
-	}
 	if (!DecodeScalarSource(src0 + 256u, pc, inst.src0, error) ||
 	    !DecodeVectorGpr(vsrc1, inst.src1, error)) {
 		return false;
@@ -1471,7 +1427,7 @@ bool DecodeVop2(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::VOP2;
 	inst.opcode_id = opcode;
-	inst.opcode    = LookupVop2Opcode(opcode);
+	inst.opcode    = Lookup(VOP2_OPS, static_cast<uint32_t>(std::size(VOP2_OPS)), opcode);
 	SetRawWords(inst, code, word_index, 1);

 	switch (opcode) {
@@ -1512,7 +1468,7 @@ bool DecodeVop1(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::VOP1;
 	inst.opcode_id = opcode;
-	inst.opcode    = Detail::LookupOpcode(VOP1_OPS, opcode);
+	inst.opcode    = Lookup(VOP1_OPS, static_cast<uint32_t>(std::size(VOP1_OPS)), opcode);
 	SetRawWords(inst, code, word_index, 1);

 	if (inst.opcode == Opcode::Unsupported) {
@@ -1553,7 +1509,7 @@ bool DecodeVopc(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::VOPC;
 	inst.opcode_id = opcode;
-	inst.opcode    = Detail::LookupOpcode(VOPC_OPS, opcode);
+	inst.opcode    = Lookup(VOPC_OPS, static_cast<uint32_t>(std::size(VOPC_OPS)), opcode);
 	inst.dst.kind  = IsVopcCompareExec(inst.opcode) ? OperandKind::ExecLo : OperandKind::VccLo;
 	SetRawWords(inst, code, word_index, 1);

@@ -1767,7 +1723,7 @@ bool DecodeVop3p(uint32_t pc, std::span<const uint32_t> code, uint32_t word_inde
 	inst.word      = word0;
 	inst.family    = Family::VOP3P;
 	inst.opcode_id = opcode;
-	inst.opcode    = Detail::LookupOpcode(VOP3P_OPS, opcode);
+	inst.opcode    = Lookup(VOP3P_OPS, static_cast<uint32_t>(std::size(VOP3P_OPS)), opcode);
 	SetRawWords(inst, code, word_index, 2);

 	if (inst.opcode == Opcode::Unsupported) {
@@ -19,7 +19,7 @@ static void AppendInstructionWords(std::vector<uint32_t>& section, const uint32_
 	section.insert(section.end(), words + 1, words + words_num);
 }

-Builder::Builder(uint32_t version): m_version(version) {
+Builder::Builder() {
 	m_debug.reserve(InitialSpirvSectionReserve);
 	m_annotations.reserve(InitialSpirvSectionReserve);
 	m_types.reserve(InitialSpirvSectionReserve);
@@ -138,7 +138,7 @@ std::vector<uint32_t> Builder::Build() const {
 	               m_debug.size() + m_annotations.size() + m_types.size() + m_functions.size());

 	module.push_back(0x07230203u);
-	module.push_back(m_version);
+	module.push_back(0x00010300u);
 	module.push_back(0u);
 	module.push_back(m_next_id);
 	module.push_back(0u);
@@ -10,7 +10,7 @@ namespace Libs::Graphics::ShaderRecompiler::Spirv {

 class Builder {
 public:
-	explicit Builder(uint32_t version = 0x00010300u);
+	Builder();
 	~Builder() = default;
 	KYTY_CLASS_DEFAULT_COPY(Builder);

@@ -39,7 +39,6 @@ private:
 	static void AppendString(std::vector<uint32_t>& words, const char* text);

 	uint32_t              m_next_id = 1;
-	uint32_t              m_version = 0;
 	std::vector<uint32_t> m_capabilities;
 	std::vector<uint32_t> m_extensions;
 	std::vector<uint32_t> m_ext_inst_imports;
@@ -131,9 +131,7 @@ bool IsAtomic(IR::Opcode op) {
 		case IR::Opcode::AtomicUMaxU32:
 		case IR::Opcode::AtomicAndU32:
 		case IR::Opcode::AtomicOrU32:
-		case IR::Opcode::AtomicXorU32:
-		case IR::Opcode::AtomicFMinF32:
-		case IR::Opcode::AtomicFMaxF32: return true;
+		case IR::Opcode::AtomicXorU32: return true;
 		default: return false;
 	}
 }
@@ -143,9 +141,6 @@ uint32_t BufferAddressOperandCount(const IR::Instruction& inst) {
 }

 bool ValidateInstructionContract(const IR::Instruction& inst, std::string* error) {
-	if (static_cast<size_t>(inst.op) >= static_cast<size_t>(IR::Opcode::Count)) {
-		return Fail(error, "IR instruction opcode is out of range");
-	}
 	if (inst.src_count > std::size(inst.src)) {
 		return Fail(error, "instruction source count exceeds fixed IR storage");
 	}
@@ -205,12 +200,6 @@ bool ValidateInstructionContract(const IR::Instruction& inst, std::string* error
 	     inst.src_count != 2)) {
 		return Fail(error, "storage image instruction has an invalid resource class");
 	}
-	const auto float_atomic =
-	    inst.op == IR::Opcode::AtomicFMinF32 || inst.op == IR::Opcode::AtomicFMaxF32;
-	if (float_atomic &&
-	    (kind != IR::ResourceKind::Buffer || inst.src_count != buffer_address_count + 1u)) {
-		return Fail(error, "floating-point atomic instruction must target a buffer");
-	}
 	if (IsAtomic(inst.op) &&
 	    !((kind == IR::ResourceKind::Buffer && inst.src_count == buffer_address_count + 1u) ||
 	      ((kind == IR::ResourceKind::Lds || kind == IR::ResourceKind::Gds) &&
@@ -248,8 +237,14 @@ bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
 		if (!ImageBinding(program.info.images[i], kind)) {
 			return Fail(error, "native shader plan has an invalid image class");
 		}
+		const auto bindings = program.info.images[i].NumBindings();
+		if (bindings == 0 || bindings > IR::ImageResource::MaxMipLevels) {
+			return Fail(error, "native shader plan has an invalid image descriptor count");
+		}
 		present[static_cast<size_t>(kind)] = true;
-		expected[static_cast<size_t>(kind)].push_back(i);
+		for (uint32_t binding = 0; binding < bindings; binding++) {
+			expected[static_cast<size_t>(kind)].push_back(i);
+		}
 	}
 	if (!program.info.samplers.empty()) {
 		Expect(Kind::Samplers, Dense(program.info.samplers.size()));
@@ -327,6 +322,11 @@ bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
 			         inst.memory.image_dimension)) {
 				return Fail(error, "image instruction has an invalid dense resource");
 			}
+			if (inst.op == IR::Opcode::ImageStore &&
+			    ((program.info.images[inst.memory.resource].mip_mode ==
+			      IR::ImageMipMode::DynamicStorage) != inst.memory.image_has_mip)) {
+				return Fail(error, "storage image mip mode does not match the instruction");
+			}
 			const bool address =
 			    inst.op == IR::Opcode::SLoadDword || memory == IR::ResourceKind::Flat ||
 			    memory == IR::ResourceKind::Global || memory == IR::ResourceKind::Scratch;
@@ -400,7 +400,7 @@ bool ProgramRequiresExactSubgroupSize(const IR::Program& program) {
 			if (Emitter::InstructionHasDppSource(inst)) {
 				return true;
 			}
-			if (IR::IsCompareOpcode(inst.op) && !Emitter::IsSccOperand(inst.dst)) {
+			if (Emitter::IsCompareOpcode(inst.op) && !Emitter::IsSccOperand(inst.dst)) {
 				return true;
 			}
 			if ((IsExecDestination(inst.dst) || IsExecDestination(inst.dst2)) &&
@@ -499,13 +499,6 @@ bool EmitProgram(const IR::Program& program, const IR::ResourceSnapshot& resourc
 	AllocateBlockLabels(state, program);
 	AllocateDispatcherState(state, program);
 	EmitFunction(state, program);
-	if (state.unsupported_ir_instruction) {
-		char pc[9] {};
-		std::snprintf(pc, sizeof(pc), "%08x", state.unsupported_ir_pc);
-		return Fail(error, "SPIR-V emitter has no handler for IR opcode " +
-		                       std::string(IR::OpcodeName(state.unsupported_ir_opcode)) +
-		                       " at pc 0x" + pc);
-	}

 	ReportReserveExceeded(program, "registers", state.registers.size());
 	ReportReserveExceeded(program, "inputs", state.inputs.size());
@@ -1486,20 +1486,17 @@ void EmitBitCompareB32(EmitterState& state, const IR::Instruction& inst, bool bi
 	EmitStoreU32(state, inst.dst, ret);
 }

-void EmitCompareU64(EmitterState& state, const IR::Instruction& inst) {
-	const bool equal      = inst.op == IR::Opcode::CompareEqU64;
-	const auto lhs_low    = EmitSequentialValueLoad(state, inst.src[0], 0);
-	const auto lhs_high   = EmitSequentialValueLoad(state, inst.src[0], 1);
-	const auto rhs_low    = EmitSequentialValueLoad(state, inst.src[1], 0);
-	const auto rhs_high   = EmitSequentialValueLoad(state, inst.src[1], 1);
-	const auto low        = state.builder.AllocateId();
-	const auto high       = state.builder.AllocateId();
-	const auto cond       = state.builder.AllocateId();
-	const auto compare_op = equal ? OpIEqual : OpINotEqual;
-	state.builder.AddFunction({compare_op, state.bool_type, low, lhs_low, rhs_low});
-	state.builder.AddFunction({compare_op, state.bool_type, high, lhs_high, rhs_high});
-	state.builder.AddFunction(
-	    {equal ? OpLogicalAnd : OpLogicalOr, state.bool_type, cond, low, high});
+void EmitCompareNeU64(EmitterState& state, const IR::Instruction& inst) {
+	const auto lhs_low  = EmitSequentialValueLoad(state, inst.src[0], 0);
+	const auto lhs_high = EmitSequentialValueLoad(state, inst.src[0], 1);
+	const auto rhs_low  = EmitSequentialValueLoad(state, inst.src[1], 0);
+	const auto rhs_high = EmitSequentialValueLoad(state, inst.src[1], 1);
+	const auto ne_low   = state.builder.AllocateId();
+	const auto ne_high  = state.builder.AllocateId();
+	const auto cond     = state.builder.AllocateId();
+	state.builder.AddFunction({OpINotEqual, state.bool_type, ne_low, lhs_low, rhs_low});
+	state.builder.AddFunction({OpINotEqual, state.bool_type, ne_high, lhs_high, rhs_high});
+	state.builder.AddFunction({OpLogicalOr, state.bool_type, cond, ne_low, ne_high});
 	EmitCompareResult(state, inst.dst, cond);
 }

@@ -7,30 +7,51 @@ namespace Libs::Graphics::ShaderRecompiler::Spirv::Emitter {

 uint32_t PixelParameterMappedLocation(const EmitterState& state, uint32_t attr) {
 	const auto* ps = state.pixel_input_info;
-	if (state.stage != ShaderType::Pixel || ps == nullptr) {
+	if (state.stage != ShaderType::Pixel || ps == nullptr || attr >= ps->input_num) {
 		return attr;
 	}
-	return ShaderPixelParameterMappedLocation(*ps, attr);
+	// VINTRP ATTR selects the PS input slot. SPI_PS_INPUT_CNTL maps that slot to a
+	// VS parameter export, which is the SPIR-V location we must link against.
+	return ps->interpolator_settings[attr] & PsInputOffsetMask;
 }

 uint32_t PixelParameterLocation(const EmitterState& state, uint32_t attr) {
-	std::array<uint32_t, 32> active_inputs {};
-	uint32_t                 active_count = 0;
+	bool used_locations[32] = {};
+
 	for (const auto& input: state.inputs) {
-		if (input.kind == IR::StageInputKind::Parameter) {
-			active_inputs[active_count++] = input.location;
+		if (input.kind != IR::StageInputKind::Parameter) {
+			continue;
+		}
+
+		auto location = PixelParameterMappedLocation(state, input.location);
+		if (location < std::size(used_locations) && used_locations[location]) {
+			auto fallback_location = input.location;
+			while (fallback_location < std::size(used_locations) &&
+			       used_locations[fallback_location]) {
+				fallback_location++;
+			}
+			EXIT_NOT_IMPLEMENTED(fallback_location >= std::size(used_locations));
+			location = fallback_location;
+		}
+
+		if (input.location == attr) {
+			return location;
+		}
+
+		if (location < std::size(used_locations)) {
+			used_locations[location] = true;
 		}
 	}
-	return state.stage == ShaderType::Pixel && state.pixel_input_info != nullptr
-	           ? ShaderPixelParameterLocation(*state.pixel_input_info,
-	                                          {active_inputs.data(), active_count}, attr)
-	           : attr;
+
+	return PixelParameterMappedLocation(state, attr);
 }

 bool PixelParameterIsFlat(const EmitterState& state, uint32_t attr) {
 	const auto* ps = state.pixel_input_info;
-	return state.stage == ShaderType::Pixel && ps != nullptr &&
-	       ShaderPixelParameterIsFlat(*ps, attr);
+	if (state.stage != ShaderType::Pixel || ps == nullptr || attr >= ps->input_num) {
+		return false;
+	}
+	return (ps->interpolator_settings[attr] & PsInputFlatShade) != 0;
 }

 void SetError(std::string* error, const char* message) {
@@ -75,6 +96,8 @@ bool IsSccOperand(const IR::Operand& operand) {
 	return operand.kind == IR::OperandKind::Register && operand.reg.file == IR::RegisterFile::Scc;
 }

+bool IsCompareOpcode(IR::Opcode op);
+
 void CollectMaskStateRegisters(std::vector<RegisterBinding>& registers) {
 	CollectRegister(registers, {IR::RegisterFile::Exec, 0});
 	CollectRegister(registers, {IR::RegisterFile::Exec, 1});
@@ -187,11 +210,11 @@ void CollectRegisters(const IR::Program& program, std::vector<RegisterBinding>&
 			if (inst.op == IR::Opcode::BitCountU64 || inst.op == IR::Opcode::FindMsbFromHighU64) {
 				CollectSequentialRegisters(registers, inst.src[0], 2);
 			}
-			if (IR::IsCompare64Opcode(inst.op)) {
+			if (inst.op == IR::Opcode::CompareNeU64) {
 				CollectSequentialRegisters(registers, inst.src[0], 2);
 				CollectSequentialRegisters(registers, inst.src[1], 2);
 			}
-			if (IR::IsCompareOpcode(inst.op) && inst.dst.kind == IR::OperandKind::Register &&
+			if (IsCompareOpcode(inst.op) && inst.dst.kind == IR::OperandKind::Register &&
 			    inst.dst.reg.file != IR::RegisterFile::Scc) {
 				CollectSequentialRegisters(registers, inst.dst, 2);
 			}
@@ -382,6 +405,93 @@ bool ProgramNeedsSubgroupShuffle(const IR::Program& program) {
 	return false;
 }

+bool IsCompareOpcode(IR::Opcode op) {
+	switch (op) {
+		case IR::Opcode::CompareFalse:
+		case IR::Opcode::CompareTrue:
+		case IR::Opcode::CompareEqU32:
+		case IR::Opcode::CompareNeU32:
+		case IR::Opcode::CompareGtU32:
+		case IR::Opcode::CompareGeU32:
+		case IR::Opcode::CompareLtU32:
+		case IR::Opcode::CompareLeU32:
+		case IR::Opcode::CompareNeU64:
+		case IR::Opcode::CompareMaskEqU32:
+		case IR::Opcode::CompareMaskNeU32:
+		case IR::Opcode::CompareMaskGtU32:
+		case IR::Opcode::CompareMaskGeU32:
+		case IR::Opcode::CompareMaskLtU32:
+		case IR::Opcode::CompareMaskLeU32:
+		case IR::Opcode::CompareEqI32:
+		case IR::Opcode::CompareNeI32:
+		case IR::Opcode::CompareGtI32:
+		case IR::Opcode::CompareGeI32:
+		case IR::Opcode::CompareLtI32:
+		case IR::Opcode::CompareLeI32:
+		case IR::Opcode::CompareEqI16:
+		case IR::Opcode::CompareNeI16:
+		case IR::Opcode::CompareGtI16:
+		case IR::Opcode::CompareGeI16:
+		case IR::Opcode::CompareLtI16:
+		case IR::Opcode::CompareLeI16:
+		case IR::Opcode::CompareMaskEqI32:
+		case IR::Opcode::CompareMaskNeI32:
+		case IR::Opcode::CompareMaskGtI32:
+		case IR::Opcode::CompareMaskGeI32:
+		case IR::Opcode::CompareMaskLtI32:
+		case IR::Opcode::CompareMaskLeI32:
+		case IR::Opcode::CompareEqU16:
+		case IR::Opcode::CompareNeU16:
+		case IR::Opcode::CompareGtU16:
+		case IR::Opcode::CompareGeU16:
+		case IR::Opcode::CompareLtU16:
+		case IR::Opcode::CompareLeU16:
+		case IR::Opcode::CompareEqF32:
+		case IR::Opcode::CompareNeF32:
+		case IR::Opcode::CompareGtF32:
+		case IR::Opcode::CompareGeF32:
+		case IR::Opcode::CompareLtF32:
+		case IR::Opcode::CompareLeF32:
+		case IR::Opcode::CompareOrderedF32:
+		case IR::Opcode::CompareUnorderedF32:
+		case IR::Opcode::CompareUnordEqF32:
+		case IR::Opcode::CompareUnordNeF32:
+		case IR::Opcode::CompareUnordGtF32:
+		case IR::Opcode::CompareUnordGeF32:
+		case IR::Opcode::CompareUnordLtF32:
+		case IR::Opcode::CompareUnordLeF32:
+		case IR::Opcode::CompareClassF32:
+		case IR::Opcode::CompareEqF16:
+		case IR::Opcode::CompareNeF16:
+		case IR::Opcode::CompareGtF16:
+		case IR::Opcode::CompareGeF16:
+		case IR::Opcode::CompareLtF16:
+		case IR::Opcode::CompareLeF16:
+		case IR::Opcode::CompareUnordNeF16:
+		case IR::Opcode::CompareMaskEqF16:
+		case IR::Opcode::CompareMaskNeF16:
+		case IR::Opcode::CompareMaskGtF16:
+		case IR::Opcode::CompareMaskGeF16:
+		case IR::Opcode::CompareMaskLtF16:
+		case IR::Opcode::CompareMaskLeF16:
+		case IR::Opcode::CompareMaskUnordNeF16:
+		case IR::Opcode::CompareMaskUnordGeF16:
+		case IR::Opcode::CompareMaskEqF32:
+		case IR::Opcode::CompareMaskNeF32:
+		case IR::Opcode::CompareMaskGtF32:
+		case IR::Opcode::CompareMaskGeF32:
+		case IR::Opcode::CompareMaskLtF32:
+		case IR::Opcode::CompareMaskLeF32:
+		case IR::Opcode::CompareMaskUnordEqF32:
+		case IR::Opcode::CompareMaskUnordNeF32:
+		case IR::Opcode::CompareMaskUnordGtF32:
+		case IR::Opcode::CompareMaskUnordGeF32:
+		case IR::Opcode::CompareMaskUnordLtF32:
+		case IR::Opcode::CompareMaskUnordLeF32: return true;
+		default: return false;
+	}
+}
+
 bool ProgramNeedsSubgroupLocalInvocationId(const IR::Program& program) {
 	for (const auto& block: program.blocks) {
 		for (const auto& inst: block.instructions) {
@@ -392,7 +502,7 @@ bool ProgramNeedsSubgroupLocalInvocationId(const IR::Program& program) {
 			    InstructionHasDppSource(inst)) {
 				return true;
 			}
-			if (IR::IsCompareOpcode(inst.op)) {
+			if (IsCompareOpcode(inst.op)) {
 				return true;
 			}
 			if (inst.dst.kind == IR::OperandKind::Register &&
@@ -450,12 +560,21 @@ uint32_t DescriptorElementPointer(EmitterState& state, uint32_t result_ptr_type,
                                  uint32_t variable_id, uint32_t array_index,
                                  IR::DescriptorBindingKind kind, uint32_t resource,
                                  const char* variable_name) {
+	return DescriptorElementPointerId(state, result_ptr_type, variable_id,
+	                                  ConstantU32(state, array_index), kind, resource,
+	                                  variable_name);
+}
+
+uint32_t DescriptorElementPointerId(EmitterState& state, uint32_t result_ptr_type,
+                                    uint32_t variable_id, uint32_t array_index_id,
+                                    IR::DescriptorBindingKind kind, uint32_t resource,
+                                    const char* variable_name) {
 	if (variable_id == 0) {
 		ExitDescriptorBindingFailure(state, kind, resource, variable_name);
 	}
 	const auto pointer = state.builder.AllocateId();
 	state.builder.AddFunction(
-	    {OpAccessChain, result_ptr_type, pointer, variable_id, ConstantU32(state, array_index)});
+	    {OpAccessChain, result_ptr_type, pointer, variable_id, array_index_id});
 	return pointer;
 }

@@ -516,8 +516,7 @@ void EmitInstruction(EmitterState& state, const IR::Instruction& inst) {
 		case IR::Opcode::CompareGeU32: EmitCompareU32(state, inst, OpUGreaterThanEqual); break;
 		case IR::Opcode::CompareLtU32: EmitCompareU32(state, inst, OpULessThan); break;
 		case IR::Opcode::CompareLeU32: EmitCompareU32(state, inst, OpULessThanEqual); break;
-		case IR::Opcode::CompareEqU64:
-		case IR::Opcode::CompareNeU64: EmitCompareU64(state, inst); break;
+		case IR::Opcode::CompareNeU64: EmitCompareNeU64(state, inst); break;
 		case IR::Opcode::CompareMaskEqU32: EmitCompareMaskU32(state, inst, OpIEqual); break;
 		case IR::Opcode::CompareMaskNeU32: EmitCompareMaskU32(state, inst, OpINotEqual); break;
 		case IR::Opcode::CompareMaskGtU32: EmitCompareMaskU32(state, inst, OpUGreaterThan); break;
@@ -775,12 +774,6 @@ void EmitInstruction(EmitterState& state, const IR::Instruction& inst) {
 		case IR::Opcode::AtomicXorU32:
 			EmitGuardedByExec(state, [&]() { EmitAtomicU32(state, inst, OpAtomicXor); });
 			break;
-		case IR::Opcode::AtomicFMinF32:
-			EmitGuardedByExec(state, [&]() { EmitAtomicFMinF32(state, inst); });
-			break;
-		case IR::Opcode::AtomicFMaxF32:
-			EmitGuardedByExec(state, [&]() { EmitAtomicFMaxF32(state, inst); });
-			break;
 		case IR::Opcode::FlatLoadUbyte: EmitFlatLoadUbyte(state, inst); break;
 		case IR::Opcode::FlatLoadSbyte: EmitFlatLoadSbyte(state, inst); break;
 		case IR::Opcode::FlatLoadUshort: EmitFlatLoadUshort(state, inst); break;
@@ -857,13 +850,7 @@ void EmitInstruction(EmitterState& state, const IR::Instruction& inst) {
 			}
 			EmitGuardedByExec(state, [&]() { EmitExport(state, inst); });
 			break;
-		default:
-			if (!state.unsupported_ir_instruction) {
-				state.unsupported_ir_instruction = true;
-				state.unsupported_ir_opcode      = inst.op;
-				state.unsupported_ir_pc          = inst.pc;
-			}
-			break;
+		default: break;
 	}
 }

@@ -33,13 +33,13 @@ uint32_t ConstantImageGatherHorizontalOffsets(EmitterState& state, ImageViewKind
 }

 uint32_t LoadStorageImageDescriptorAtIndex(EmitterState& state, uint32_t resource,
-                                           uint32_t array_index, bool uint_image,
+                                           uint32_t array_index_id, bool uint_image,
                                           ImageViewKind view) {
 	const auto  kind        = StorageBindingKind(uint_image, view);
 	const auto& descriptors = state.storage_images[StorageImageIndex(uint_image, view)];
-	const auto  pointer =
-	    DescriptorElementPointer(state, descriptors.pointer_type, descriptors.variable, array_index,
-	                             kind, resource, "storage image descriptor array was not emitted");
+	const auto  pointer     = DescriptorElementPointerId(
+	    state, descriptors.pointer_type, descriptors.variable, array_index_id, kind, resource,
+	    "storage image descriptor array was not emitted");
 	const auto image = state.builder.AllocateId();
 	state.builder.AddFunction({OpLoad, descriptors.image_type, image, pointer});
 	return image;
@@ -168,12 +168,38 @@ void EmitImageStore(EmitterState& state, const IR::Instruction& inst) {
 	const auto view       = StorageImageViewKind(state, inst.memory, uint_image, inst.pc);
 	const auto binding =
 	    ResourceForDescriptor(state, StorageBindingKind(uint_image, view), inst.memory.resource);
-	const auto image = LoadStorageImageDescriptorAtIndex(state, inst.memory.resource,
-	                                                     binding.array_index, uint_image, view);
+	const auto emit_write = [&](uint32_t descriptor_index, bool non_uniform) {
+		if (non_uniform) {
+			state.builder.AddAnnotation({OpDecorate, descriptor_index, DecorationNonUniform});
+		}
+		const auto image = LoadStorageImageDescriptorAtIndex(state, inst.memory.resource,
+		                                                     descriptor_index, uint_image, view);
+		if (non_uniform) {
+			state.builder.AddAnnotation({OpDecorate, image, DecorationNonUniform});
+		}
+		state.builder.AddFunction({OpImageWrite, image, EmitImageCoordU32(state, inst, view),
+		                           uint_image ? EmitImageStoreTexelU32(state, inst)
+		                                      : EmitImageStoreTexelF32(state, inst)});
+	};
+	if (!inst.memory.image_has_mip) {
+		emit_write(ConstantU32(state, binding.array_index), false);
+		return;
+	}

+	const auto& resource = state.program.info.images[inst.memory.resource];
+	const auto  mip      = EmitImageMipLodU32(state, inst, inst.src[1], view);
+	const auto  in_range = state.builder.AllocateId();
 	state.builder.AddFunction(
-	    {OpImageWrite, image, EmitImageCoordU32(state, inst, view),
-	     uint_image ? EmitImageStoreTexelU32(state, inst) : EmitImageStoreTexelF32(state, inst)});
+	    {OpULessThan, state.bool_type, in_range, mip, ConstantU32(state, resource.mip_levels)});
+	EmitIfCondition(state, in_range, [&] {
+		auto descriptor_index = mip;
+		if (binding.array_index != 0) {
+			descriptor_index = state.builder.AllocateId();
+			state.builder.AddFunction({OpIAdd, state.uint_type, descriptor_index,
+			                           ConstantU32(state, binding.array_index), mip});
+		}
+		emit_write(descriptor_index, true);
+	});
 }

 void EmitImageSampleResult(EmitterState& state, const IR::Instruction& inst, uint32_t sample,
@@ -23,38 +23,40 @@
 namespace Libs::Graphics::ShaderRecompiler::Spirv::Emitter {

 enum : uint32_t {
-	ExecutionModelVertex                     = 0,
-	ExecutionModelFragment                   = 4,
-	ExecutionModelGLCompute                  = 5,
-	ExecutionModeOriginUpperLeft             = 7,
-	ExecutionModeEarlyFragmentTests          = 9,
-	ExecutionModeDepthReplacing              = 12,
-	ExecutionModeLocalSize                   = 17,
-	ExecutionModeDerivativeGroupQuadsKHR     = 5289,
-	AddressingModelLogical                   = 0,
-	MemoryModelGLSL450                       = 1,
-	CapabilityShader                         = 1,
-	CapabilityImageGatherExtended            = 25,
-	CapabilitySampled1D                      = 43,
-	CapabilityImage1D                        = 44,
-	CapabilityImageQuery                     = 50,
-	CapabilityStorageImageReadWithoutFormat  = 55,
-	CapabilityStorageImageWriteWithoutFormat = 56,
-	CapabilityGroupNonUniform                = 61,
-	CapabilityGroupNonUniformBallot          = 64,
-	CapabilityGroupNonUniformShuffle         = 65,
-	CapabilityComputeDerivativeGroupQuadsKHR = 5288,
-	StorageClassUniformConstant              = 0,
-	StorageClassInput                        = 1,
-	StorageClassOutput                       = 3,
-	StorageClassWorkgroup                    = 4,
-	StorageClassFunction                     = 7,
-	StorageClassPushConstant                 = 9,
-	StorageClassImage                        = 11,
-	StorageClassStorageBuffer                = 12,
-	FunctionControlNone                      = 0,
-	SelectionControlNone                     = 0,
-	LoopControlNone                          = 0,
+	ExecutionModelVertex                          = 0,
+	ExecutionModelFragment                        = 4,
+	ExecutionModelGLCompute                       = 5,
+	ExecutionModeOriginUpperLeft                  = 7,
+	ExecutionModeEarlyFragmentTests               = 9,
+	ExecutionModeDepthReplacing                   = 12,
+	ExecutionModeLocalSize                        = 17,
+	ExecutionModeDerivativeGroupQuadsKHR          = 5289,
+	AddressingModelLogical                        = 0,
+	MemoryModelGLSL450                            = 1,
+	CapabilityShader                              = 1,
+	CapabilityImageGatherExtended                 = 25,
+	CapabilitySampled1D                           = 43,
+	CapabilityImage1D                             = 44,
+	CapabilityImageQuery                          = 50,
+	CapabilityStorageImageReadWithoutFormat       = 55,
+	CapabilityStorageImageWriteWithoutFormat      = 56,
+	CapabilityGroupNonUniform                     = 61,
+	CapabilityGroupNonUniformBallot               = 64,
+	CapabilityGroupNonUniformShuffle              = 65,
+	CapabilityShaderNonUniform                    = 5301,
+	CapabilityStorageImageArrayNonUniformIndexing = 5309,
+	CapabilityComputeDerivativeGroupQuadsKHR      = 5288,
+	StorageClassUniformConstant                   = 0,
+	StorageClassInput                             = 1,
+	StorageClassOutput                            = 3,
+	StorageClassWorkgroup                         = 4,
+	StorageClassFunction                          = 7,
+	StorageClassPushConstant                      = 9,
+	StorageClassImage                             = 11,
+	StorageClassStorageBuffer                     = 12,
+	FunctionControlNone                           = 0,
+	SelectionControlNone                          = 0,
+	LoopControlNone                               = 0,
 };

 enum : uint32_t {
@@ -67,6 +69,7 @@ enum : uint32_t {
 	DecorationBinding       = 33,
 	DecorationDescriptorSet = 34,
 	DecorationOffset        = 35,
+	DecorationNonUniform    = 5300,
 };

 enum : uint32_t {
@@ -414,9 +417,6 @@ struct EmitterState {
 	bool                                             needs_image_gather_extended           = false;
 	bool                                             needs_function_lds                    = false;
 	bool                                             needs_pixel_valid_mask                = false;
-	bool                                             unsupported_ir_instruction            = false;
-	IR::Opcode                                       unsupported_ir_opcode = IR::Opcode::Count;
-	uint32_t                                         unsupported_ir_pc     = 0;
 	std::vector<RegisterBinding>                     registers;
 	std::vector<InputBinding>                        inputs;
 	std::vector<OutputBinding>                       outputs;
@@ -428,6 +428,9 @@ struct EmitterState {
 	std::map<uint32_t, uint32_t>                     float_constants;
 };

+constexpr uint32_t PsInputOffsetMask = 0x0000001fu;
+constexpr uint32_t PsInputFlatShade  = 0x00000400u;
+
 enum class VertexInputScalarKind { Float, Sint, Uint };

 constexpr uint32_t NoImageComponent = 0xffffffffu;
@@ -614,6 +617,8 @@ bool IsMaskRegisterFile(IR::RegisterFile file);

 bool IsSccOperand(const IR::Operand& operand);

+bool IsCompareOpcode(IR::Opcode op);
+
 void CollectMaskStateRegisters(std::vector<RegisterBinding>& registers);

 void CollectSequentialRegisters(std::vector<RegisterBinding>& registers, const IR::Operand& base,
@@ -652,6 +657,8 @@ bool ProgramNeedsSubgroupBallot(const IR::Program& program);

 bool ProgramNeedsSubgroupShuffle(const IR::Program& program);

+bool IsCompareOpcode(IR::Opcode op);
+
 bool ProgramNeedsSubgroupLocalInvocationId(const IR::Program& program);

 uint32_t PointerForRegister(const EmitterState& state, IR::Register reg);
@@ -675,6 +682,10 @@ uint32_t DescriptorElementPointer(EmitterState& state, uint32_t result_ptr_type,
                                  uint32_t variable_id, uint32_t array_index,
                                  IR::DescriptorBindingKind kind, uint32_t resource,
                                  const char* variable_name);
+uint32_t DescriptorElementPointerId(EmitterState& state, uint32_t result_ptr_type,
+                                    uint32_t variable_id, uint32_t array_index_id,
+                                    IR::DescriptorBindingKind kind, uint32_t resource,
+                                    const char* variable_name);

 ImageViewKind SampledImageViewKind(const EmitterState& state, const IR::MemoryInfo& mem,
                                   uint32_t use_pc);
@@ -1014,9 +1025,6 @@ void EmitDeviceAtomicMemoryBarrier(EmitterState& state);

 void EmitAtomicU32(EmitterState& state, const IR::Instruction& inst, uint32_t opcode);

-void EmitAtomicFMinF32(EmitterState& state, const IR::Instruction& inst);
-void EmitAtomicFMaxF32(EmitterState& state, const IR::Instruction& inst);
-
 void EmitSLoadDword(EmitterState& state, const IR::Instruction& inst);

 void EmitLoadSrtDword(EmitterState& state, const IR::Instruction& inst);
@@ -1347,7 +1355,7 @@ void EmitCompareI16(EmitterState& state, const IR::Instruction& inst, uint32_t o

 void EmitBitCompareB32(EmitterState& state, const IR::Instruction& inst, bool bit_set);

-void EmitCompareU64(EmitterState& state, const IR::Instruction& inst);
+void EmitCompareNeU64(EmitterState& state, const IR::Instruction& inst);

 void EmitCompareConstant(EmitterState& state, const IR::Instruction& inst, bool value);

@@ -1579,22 +1587,19 @@ uint32_t EmitValueOrZeroIfCondition(EmitterState& state, uint32_t condition, Fn&
 	}

 	const auto then_label  = state.builder.AllocateId();
-	const auto then_exit   = state.builder.AllocateId();
 	const auto else_label  = state.builder.AllocateId();
 	const auto merge_label = state.builder.AllocateId();
 	state.builder.AddFunction({OpSelectionMerge, merge_label, SelectionControlNone});
 	state.builder.AddFunction({OpBranchConditional, condition, then_label, else_label});
 	state.builder.AddFunction({OpLabel, then_label});
 	const auto then_value = fn();
-	state.builder.AddFunction({OpBranch, then_exit});
-	state.builder.AddFunction({OpLabel, then_exit});
 	state.builder.AddFunction({OpBranch, merge_label});
 	state.builder.AddFunction({OpLabel, else_label});
 	state.builder.AddFunction({OpBranch, merge_label});
 	state.builder.AddFunction({OpLabel, merge_label});
 	const auto value = state.builder.AllocateId();
 	state.builder.AddFunction(
-	    {OpPhi, state.uint_type, value, then_value, then_exit, ConstantU32(state, 0), else_label});
+	    {OpPhi, state.uint_type, value, then_value, then_label, ConstantU32(state, 0), else_label});
 	return value;
 }

@@ -640,8 +640,8 @@ void EmitMemoryStoreU32(EmitterState& state, const IR::Instruction& inst, IR::Re
 }

 template <typename Fn>
-uint32_t EmitAtomicUpdateU32(EmitterState& state, uint32_t pointer, IR::ResourceKind kind,
-                             Fn&& desired_value) {
+void EmitAtomicUpdateU32(EmitterState& state, uint32_t pointer, IR::ResourceKind kind,
+                         Fn&& desired_value) {
 	const auto scope          = kind == IR::ResourceKind::Lds ? ScopeWorkgroup : ScopeDevice;
 	const auto memory         = kind == IR::ResourceKind::Lds ? MemorySemanticsWorkgroupMemory
 	                                                          : MemorySemanticsUniformMemory;
@@ -675,7 +675,6 @@ uint32_t EmitAtomicUpdateU32(EmitterState& state, uint32_t pointer, IR::Resource
 	const auto semantics = MemorySemanticsAcquireRelease | memory;
 	state.builder.AddFunction(
 	    {OpMemoryBarrier, ConstantU32(state, scope), ConstantU32(state, semantics)});
-	return observed;
 }

 void EmitMemoryStoreSubDwordU32(EmitterState& state, const IR::Instruction& inst,
@@ -1182,79 +1181,6 @@ void EmitAtomicU32(EmitterState& state, const IR::Instruction& inst, uint32_t op
 	EmitStoreU32(state, inst.dst, old);
 }

-namespace {
-
-uint32_t EmitF32BitsOrderedCompare(EmitterState& state, uint32_t lhs_bits, uint32_t rhs_bits,
-                                   uint32_t comparison_opcode) {
-	struct ClassifiedBits {
-		uint32_t nan  = 0;
-		uint32_t zero = 0;
-		uint32_t key  = 0;
-	};
-	const auto Classify = [&](uint32_t bits) {
-		ClassifiedBits cls;
-		const auto     abs_bits      = EmitAndConstant(state, bits, 0x7fffffffu);
-		const auto     exponent_bits = EmitAndConstant(state, abs_bits, 0x7f800000u);
-		const auto     mantissa_bits = EmitAndConstant(state, abs_bits, 0x007fffffu);
-		const auto     exponent_max =
-		    EmitCompareU32Constant(state, OpIEqual, exponent_bits, 0x7f800000u);
-		const auto mantissa_nonzero = EmitCompareU32Constant(state, OpINotEqual, mantissa_bits, 0);
-		const auto negative = EmitCompareU32Constant(state, OpINotEqual,
-		                                             EmitAndConstant(state, bits, 0x80000000u), 0);
-		const auto negative_key = state.builder.AllocateId();
-		const auto positive_key = state.builder.AllocateId();
-		// Map all non-NaN IEEE-754 encodings to monotonically increasing unsigned keys.
-		state.builder.AddFunction({OpNot, state.uint_type, negative_key, bits});
-		state.builder.AddFunction(
-		    {OpBitwiseXor, state.uint_type, positive_key, bits, ConstantU32(state, 0x80000000u)});
-		cls.nan  = EmitLogicalAndBool(state, exponent_max, mantissa_nonzero);
-		cls.zero = EmitCompareU32Constant(state, OpIEqual, abs_bits, 0);
-		cls.key  = EmitSelectValueU32(state, negative, negative_key, positive_key);
-		return cls;
-	};
-
-	const auto lhs     = Classify(lhs_bits);
-	const auto rhs     = Classify(rhs_bits);
-	const auto any_nan = EmitLogicalOrBool(state, lhs.nan, rhs.nan);
-	// The key transform orders -0 below +0, while the floating comparison treats them as equal.
-	const auto both_zero = EmitLogicalAndBool(state, lhs.zero, rhs.zero);
-	const auto ordered_nonzero =
-	    EmitLogicalNotBool(state, EmitLogicalOrBool(state, any_nan, both_zero));
-	const auto comparison = state.builder.AllocateId();
-	state.builder.AddFunction({comparison_opcode, state.bool_type, comparison, lhs.key, rhs.key});
-	return EmitLogicalAndBool(state, ordered_nonzero, comparison);
-}
-
-void EmitAtomicFMinMaxF32(EmitterState& state, const IR::Instruction& inst,
-                          uint32_t comparison_opcode) {
-	const auto index =
-	    EmitMemoryDwordIndex(state, inst, inst.memory, 1, AddressSourceCount(inst, 1));
-	const auto in_bounds = EmitStorageBufferElementInBounds(state, inst.memory, index, inst.pc);
-	const auto src_u32   = EmitValueLoad(state, inst.src[0]);
-	const auto old       = EmitValueOrZeroIfCondition(state, in_bounds, [&]() {
-		const auto pointer = EmitStorageBufferElementPointer(state, inst.memory, index, inst.pc);
-		return EmitAtomicUpdateU32(state, pointer, inst.memory.kind, [&](uint32_t old_u32) {
-			const auto replace_old = state.builder.AllocateId();
-			const auto replace =
-			    EmitF32BitsOrderedCompare(state, src_u32, old_u32, comparison_opcode);
-			state.builder.AddFunction(
-			    {OpSelect, state.uint_type, replace_old, replace, src_u32, old_u32});
-			return replace_old;
-		});
-	});
-	EmitStoreU32(state, inst.dst, old);
-}
-
-} // namespace
-
-void EmitAtomicFMinF32(EmitterState& state, const IR::Instruction& inst) {
-	EmitAtomicFMinMaxF32(state, inst, OpULessThan);
-}
-
-void EmitAtomicFMaxF32(EmitterState& state, const IR::Instruction& inst) {
-	EmitAtomicFMinMaxF32(state, inst, OpUGreaterThan);
-}
-
 void EmitSLoadDword(EmitterState& state, const IR::Instruction& inst) {
 	if (state.address_memory_variable == 0) {
 		ExitDescriptorBindingFailure(state, IR::DescriptorBindingKind::AddressMemory,
@@ -484,6 +484,13 @@ void EmitHeaderAndTypes(EmitterState& state) {
 	if (state.needs_image_gather_extended) {
 		state.builder.AddCapability({CapabilityImageGatherExtended});
 	}
+	if (std::any_of(
+	        state.program.info.images.begin(), state.program.info.images.end(),
+	        [](const auto& image) { return image.mip_mode == IR::ImageMipMode::DynamicStorage; })) {
+		state.builder.AddCapability({CapabilityShaderNonUniform});
+		state.builder.AddCapability({CapabilityStorageImageArrayNonUniformIndexing});
+		state.builder.AddExtension("SPV_EXT_descriptor_indexing");
+	}
 	if (std::any_of(state.storage_images.begin(),
 	                state.storage_images.begin() + StorageImageViewKindCount,
 	                [](const auto& image) { return image.variable != 0; })) {
@@ -269,7 +269,10 @@ bool AllocateBindings(Program& program, const BindingLayoutOptions& options, std
 			}
 			return false;
 		}
-		image_groups[static_cast<size_t>(group - ImageBindingKinds.begin())].push_back(i);
+		auto& resources = image_groups[static_cast<size_t>(group - ImageBindingKinds.begin())];
+		for (uint32_t binding = 0; binding < program.info.images[i].NumBindings(); binding++) {
+			resources.push_back(i);
+		}
 	}
 	for (uint32_t i = 0; i < image_groups.size(); i++) {
 		if (!image_groups[i].empty()) {
@@ -71,6 +71,17 @@ bool DescriptorIsCube(const DescriptorValue& descriptor) {
 	       Prospero::ImageType::kCube;
 }

+bool DescriptorMipRange(const DescriptorValue& descriptor, uint32_t& count) {
+	const auto base_level = (descriptor.dwords[3] >> 12u) & 0xfu;
+	const auto last_level = (descriptor.dwords[3] >> 16u) & 0xfu;
+	const auto max_mip    = (descriptor.dwords[5] >> 4u) & 0xfu;
+	if (base_level > last_level || last_level > max_mip) {
+		return false;
+	}
+	count = last_level - base_level + 1u;
+	return true;
+}
+
 bool DecodeBufferDescriptor(const DescriptorValue& descriptor, ShaderBufferResource& result) {
 	if (descriptor.dword_count != std::size(result.fields)) {
 		return false;
@@ -196,6 +207,21 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 			}
 			continue;
 		}
+		if (image.mip_mode == ImageMipMode::DynamicStorage) {
+			uint32_t mip_levels = 0;
+			if (!DescriptorMipRange(descriptor, mip_levels) || mip_levels != image.mip_levels) {
+				if (error != nullptr) {
+					*error = fmt::format(
+					    "image descriptor {} no longer matches specialized storage mip count", i);
+				}
+				return false;
+			}
+		} else if (image.mip_levels != 1u) {
+			if (error != nullptr) {
+				*error = fmt::format("image descriptor {} has invalid non-storage mip count", i);
+			}
+			return false;
+		}
 		const auto dimension = DescriptorDimension(descriptor, image.dimension);
 		if (dimension == Decoder::ImageDimension::Unknown || dimension != image.dimension ||
 		    DescriptorIsCube(descriptor) != image.cube) {
@@ -229,12 +255,8 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 			                             image.kind == ResourceKind::StorageImageUint;
 			if (uint_descriptor != uint_program && !(image.atomic && uint_program)) {
 				if (error != nullptr) {
-					*error = fmt::format(
-					    "image descriptor {} no longer matches specialized format: "
-					    "{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x}",
-					    i, descriptor.dwords[0], descriptor.dwords[1], descriptor.dwords[2],
-					    descriptor.dwords[3], descriptor.dwords[4], descriptor.dwords[5],
-					    descriptor.dwords[6], descriptor.dwords[7]);
+					*error =
+					    fmt::format("image descriptor {} no longer matches specialized format", i);
 				}
 				return false;
 			}
@@ -383,8 +405,9 @@ bool SpecializeResources(Program& program, const ResourceSnapshot& snapshot, std
 		const auto& descriptor = snapshot.images[i];
 		auto&       image      = next.images[i];
 		if (NullImageDescriptor(descriptor)) {
-			image.dimension = Decoder::ImageDimension::Dim2D;
-			image.cube      = false;
+			image.dimension  = Decoder::ImageDimension::Dim2D;
+			image.cube       = false;
+			image.mip_levels = 1;
 			switch (image.kind) {
 				case ResourceKind::ImageUint: image.kind = ResourceKind::Image; break;
 				case ResourceKind::StorageImageUint:
@@ -396,6 +419,16 @@ bool SpecializeResources(Program& program, const ResourceSnapshot& snapshot, std
 			}
 			continue;
 		}
+		if (image.mip_mode == ImageMipMode::DynamicStorage) {
+			if (!DescriptorMipRange(descriptor, image.mip_levels)) {
+				if (error != nullptr) {
+					*error = fmt::format("image descriptor {} has invalid storage mip range", i);
+				}
+				return false;
+			}
+		} else {
+			image.mip_levels = 1;
+		}
 		const auto descriptor_dimension = DescriptorDimension(descriptor, image.dimension);
 		if (descriptor_dimension == Decoder::ImageDimension::Unknown) {
 			if (error != nullptr) {
@@ -30,9 +30,7 @@ bool IsAtomic(Opcode op) {
 		case Opcode::AtomicUMaxU32:
 		case Opcode::AtomicAndU32:
 		case Opcode::AtomicOrU32:
-		case Opcode::AtomicXorU32:
-		case Opcode::AtomicFMinF32:
-		case Opcode::AtomicFMaxF32: return true;
+		case Opcode::AtomicXorU32: return true;
 		default: return false;
 	}
 }
@@ -490,26 +490,13 @@ bool IsScalarMinMaxOpcode(Decoder::Opcode opcode) {
 	}
 }

-bool ResolveIrOpcode(Decoder::Opcode decoded, Opcode& lowered, std::string* error) {
-	const auto opcode = LookupIrOpcode(decoded);
-	if (!opcode.has_value()) {
-		if (error != nullptr) {
-			*error = fmt::format("decoded opcode has no IR lowering: {}",
-			                     Decoder::OpcodeToString(decoded));
-		}
-		return false;
-	}
-	lowered = *opcode;
-	return true;
-}
-
 bool LowerScalarMinMaxWithScc(const Decoder::Instruction& decoded, BasicBlock& block,
                              std::string* error) {
 	Instruction result;
 	result.pc        = decoded.pc;
+	result.op        = LookupIrOpcode(decoded.opcode);
 	result.src_count = 2;
-	if (!ResolveIrOpcode(decoded.opcode, result.op, error) ||
-	    !LowerRegisterOperand(decoded.dst, result.dst, error) ||
+	if (!LowerRegisterOperand(decoded.dst, result.dst, error) ||
 	    !LowerSourceOperand(decoded.src0, result.src[0], error) ||
 	    !LowerSourceOperand(decoded.src1, result.src[1], error)) {
 		return false;
@@ -975,12 +962,7 @@ bool LowerControlInstruction(const Decoder::Instruction& decoded, BasicBlock& bl
 			return LowerControlMarker(decoded, block, Opcode::TtraceData, true, error);
 		case Decoder::Opcode::SInstPrefetch:
 			return LowerControlMarker(decoded, block, Opcode::InstPrefetch, true, error);
-		default:
-			if (error != nullptr) {
-				*error = fmt::format("control opcode has no specialized IR lowering: {}",
-				                     Decoder::OpcodeToString(decoded.opcode));
-			}
-			return false;
+		default: return false;
 	}
 }

@@ -1069,18 +1051,6 @@ bool IsTerminatorOpcode(Decoder::Opcode opcode) {

 bool LowerImplemented(const Decoder::Instruction& decoded, BasicBlock& block, std::string* error);

-bool IsMemoryFamily(Decoder::Family family) {
-	switch (family) {
-		case Decoder::Family::SMEM:
-		case Decoder::Family::MUBUF:
-		case Decoder::Family::MTBUF:
-		case Decoder::Family::FLAT:
-		case Decoder::Family::DS:
-		case Decoder::Family::MIMG: return true;
-		default: return false;
-	}
-}
-
 bool LowerDecodedInstruction(const Decoder::Instruction& inst, BasicBlock& block,
                             std::string* error) {
 	switch (inst.opcode) {
@@ -1134,15 +1104,6 @@ bool LowerDecodedInstruction(const Decoder::Instruction& inst, BasicBlock& block
 	if (IsMemoryOpcode(inst.opcode)) {
 		return LowerMemoryInstruction(inst, block, error);
 	}
-	// Memory instructions require specialized lowering to populate MemoryInfo. Never let a
-	// newly decoded memory-family opcode fall through to generic register-only IR.
-	if (IsMemoryFamily(inst.family)) {
-		if (error != nullptr) {
-			*error = fmt::format("decoded memory-family opcode has no specialized IR lowering: {}",
-			                     Decoder::OpcodeToString(inst.opcode));
-		}
-		return false;
-	}
 	if (ScalarShiftLeftAddAmount(inst.opcode) != 0) {
 		return LowerScalarShiftLeftAdd(inst, block, error);
 	}
@@ -1155,16 +1116,23 @@ bool LowerDecodedInstruction(const Decoder::Instruction& inst, BasicBlock& block
 	if (VectorByteConvertIndex(inst.opcode) <= 3u) {
 		return LowerVectorByteConvert(inst, block, error);
 	}
+	if (!IsImplemented(inst.opcode)) {
+		if (error != nullptr) {
+			*error = fmt::format("decoded opcode has no IR lowering yet: {}",
+			                     Decoder::InstructionToString(inst).c_str());
+		}
+		return false;
+	}
 	return LowerImplemented(inst, block, error);
 }

 bool LowerImplemented(const Decoder::Instruction& decoded, BasicBlock& block, std::string* error) {
 	Instruction inst;
 	inst.pc        = decoded.pc;
+	inst.op        = LookupIrOpcode(decoded.opcode);
 	inst.src_count = decoded.src_count;

-	if (!ResolveIrOpcode(decoded.opcode, inst.op, error) ||
-	    !LowerRegisterOperand(decoded.dst, inst.dst, error)) {
+	if (!LowerRegisterOperand(decoded.dst, inst.dst, error)) {
 		return false;
 	}
 	ApplyDppDestinationMask(decoded, inst.dst);
@@ -8,48 +8,350 @@
 #include "graphics/shader/shader.h"

 #include <array>
-#include <string_view>
 #include <vector>

 namespace Libs::Graphics::ShaderRecompiler::IR {

 enum class Opcode {
-#define IR_OPCODE(name, category) name,
-#include "graphics/shader/recompiler/ir/ShaderIROpcodes.inc"
-#undef IR_OPCODE
-	Count,
+	ControlNop,
+	Waitcnt,
+	Barrier,
+	Sendmsg,
+	TtraceData,
+	InstPrefetch,
+	MoveU32,
+	MoveF32Bits,
+	MoveRelDestU32,
+	MoveRelSourceU32,
+	MoveU64,
+	WqmB64,
+	SaveexecB32,
+	SaveexecB64,
+	ReadFirstLaneU32,
+	ReadLaneU32,
+	WriteLaneU32,
+	Permlane16B32,
+	Permlanex16B32,
+	AbsI32,
+	IAddU32,
+	IAddCarryU32,
+	ISubBorrowU32,
+	ScalarAddCarryU32,
+	ScalarSubBorrowU32,
+	ScalarSubBorrowCarryU32,
+	ScalarSignedAddOverflowI32,
+	ScalarSignedSubOverflowI32,
+	ScalarShiftLeftAddCarryU32,
+	ISubU32,
+	IMulU32,
+	UMulHighU32,
+	SMulHighI32,
+	IMadI24U32,
+	UMadU24U32,
+	UMadU64U32,
+	SadU32,
+	IAdd3U32,
+	IMulI24U32,
+	UMulU24U32,
+	IMinI32,
+	IMaxI32,
+	IMin3I32,
+	IMax3I32,
+	IMed3I32,
+	UMinU32,
+	UMaxU32,
+	UMin3U32,
+	UMax3U32,
+	UMed3U32,
+	BitwiseAndU32,
+	BitwiseAndU64,
+	BitwiseAndNotU32,
+	BitwiseAndNotU64,
+	BitwiseOrU32,
+	BitwiseOrU64,
+	BitwiseOrNotU32,
+	BitwiseOrNotU64,
+	BitwiseAndOrU32,
+	BitwiseOr3U32,
+	BitwiseXorU32,
+	BitwiseXorU64,
+	BitwiseXor3U32,
+	BitwiseNandU32,
+	BitwiseNandU64,
+	BitwiseNorU32,
+	BitwiseNorU64,
+	BitwiseXnorU32,
+	BitwiseXnorU64,
+	BitwiseNotU32,
+	BitwiseNotU64,
+	BitClearU32,
+	BitSetU32,
+	BitReverseU32,
+	BitCountU32,
+	BitCountU64,
+	BitReplicateB64B32,
+	BitCountAddU32,
+	MaskedBitCountLowU32,
+	MaskedBitCountHighU32,
+	FindLsbU32,
+	FindMsbFromHighU32,
+	FindMsbFromHighU64,
+	BitFieldMaskU32,
+	BitFieldMaskU64,
+	BitFieldExtractU32,
+	BitFieldExtractU64,
+	BitFieldExtract3U32,
+	BitFieldExtract3I32,
+	BitFieldInsertSelectU32,
+	BitCompare0B32,
+	BitCompare1B32,
+	AlignBitU32,
+	ShiftLeftAddU32,
+	AddShiftLeftU32,
+	XorAddU32,
+	ShiftLeftOrU32,
+	ShiftLeftLogicalU32,
+	ShiftLeftLogicalU64,
+	ShiftLeftLogicalU16,
+	ShiftRightLogicalU32,
+	ShiftRightLogicalU64,
+	ShiftRightLogicalU16,
+	ShiftRightArithmeticI32,
+	ShiftRightArithmeticI16,
+	SelectU32,
+	SelectMaskU32,
+	SelectF32Bits,
+	SelectMaskF32Bits,
+	SelectU64,
+	PackLowLowU16,
+	PackLowHighU16,
+	PackHighHighU16,
+	CompareFalse,
+	CompareTrue,
+	CompareEqU32,
+	CompareNeU32,
+	CompareGtU32,
+	CompareGeU32,
+	CompareLtU32,
+	CompareLeU32,
+	CompareNeU64,
+	CompareMaskEqU32,
+	CompareMaskNeU32,
+	CompareMaskGtU32,
+	CompareMaskGeU32,
+	CompareMaskLtU32,
+	CompareMaskLeU32,
+	CompareEqI32,
+	CompareNeI32,
+	CompareGtI32,
+	CompareGeI32,
+	CompareLtI32,
+	CompareLeI32,
+	CompareEqI16,
+	CompareNeI16,
+	CompareGtI16,
+	CompareGeI16,
+	CompareLtI16,
+	CompareLeI16,
+	CompareMaskEqI32,
+	CompareMaskNeI32,
+	CompareMaskGtI32,
+	CompareMaskGeI32,
+	CompareMaskLtI32,
+	CompareMaskLeI32,
+	CompareEqU16,
+	CompareNeU16,
+	CompareGtU16,
+	CompareGeU16,
+	CompareLtU16,
+	CompareLeU16,
+	CompareEqF32,
+	CompareNeF32,
+	CompareGtF32,
+	CompareGeF32,
+	CompareLtF32,
+	CompareLeF32,
+	CompareOrderedF32,
+	CompareUnorderedF32,
+	CompareUnordEqF32,
+	CompareUnordNeF32,
+	CompareUnordGtF32,
+	CompareUnordGeF32,
+	CompareUnordLtF32,
+	CompareUnordLeF32,
+	CompareClassF32,
+	CompareEqF16,
+	CompareNeF16,
+	CompareGtF16,
+	CompareGeF16,
+	CompareLtF16,
+	CompareLeF16,
+	CompareUnordNeF16,
+	CompareMaskEqF16,
+	CompareMaskNeF16,
+	CompareMaskGtF16,
+	CompareMaskGeF16,
+	CompareMaskLtF16,
+	CompareMaskLeF16,
+	CompareMaskUnordNeF16,
+	CompareMaskUnordGeF16,
+	CompareMaskEqF32,
+	CompareMaskNeF32,
+	CompareMaskGtF32,
+	CompareMaskGeF32,
+	CompareMaskLtF32,
+	CompareMaskLeF32,
+	CompareMaskUnordEqF32,
+	CompareMaskUnordNeF32,
+	CompareMaskUnordGtF32,
+	CompareMaskUnordGeF32,
+	CompareMaskUnordLtF32,
+	CompareMaskUnordLeF32,
+	ConvertByteU32ToF32,
+	ConvertU32ToF32,
+	ConvertI32ToF32,
+	ConvertF32ToU32,
+	ConvertF32ToI32,
+	ConvertF32ToF16,
+	ConvertF16ToF32,
+	ConvertU16ToF16,
+	ConvertF16ToU16,
+	ConvertI16ToF16,
+	ConvertF16ToI16,
+	ConvertRoundPlusInfF32ToI32,
+	ConvertFloorF32ToI32,
+	ConvertI4ToOffsetF32,
+	LdexpF32,
+	PackF32ToF16Rtz,
+	PackSnorm2x16F32,
+	PackUnorm2x16F32,
+	PackU16U32,
+	PackU8F32,
+	PackB32F16,
+	PackedMadI16,
+	PackedMulLoU16,
+	PackedAddI16,
+	PackedSubI16,
+	PackedLshlrevB16,
+	PackedLshrrevB16,
+	PackedAshrrevI16,
+	PackedMaxI16,
+	PackedMinI16,
+	PackedMadU16,
+	PackedAddU16,
+	PackedSubU16,
+	PackedMaxU16,
+	PackedMinU16,
+	PackedAddF16,
+	PackedMulF16,
+	PackedMinF16,
+	PackedMaxF16,
+	PackedFmaF16,
+	AddF16,
+	SubF16,
+	MulF16,
+	MinF16,
+	MaxF16,
+	FmaF16,
+	MadMixF16,
+	IAddU16,
+	ISubI16,
+	IMinI16,
+	IMaxI16,
+	UMinU16,
+	UMaxU16,
+	RcpF32,
+	FractF32,
+	TruncF32,
+	CeilF32,
+	RoundEvenF32,
+	FloorF32,
+	Exp2F32,
+	Log2F32,
+	InverseSqrtF32,
+	SqrtF32,
+	RcpF16,
+	SqrtF16,
+	InverseSqrtF16,
+	Log2F16,
+	Exp2F16,
+	FloorF16,
+	CeilF16,
+	TruncF16,
+	RoundEvenF16,
+	SinF32,
+	CosF32,
+	CubeIdF32,
+	CubeScF32,
+	CubeTcF32,
+	CubeMaF32,
+	FAddF32,
+	FSubF32,
+	FMulF32,
+	FMinF32,
+	FMaxF32,
+	FMadF32,
+	Dot2AccF32F16,
+	FMin3F32,
+	FMax3F32,
+	FMed3F32,
+	Min3F16,
+	Max3F16,
+	Med3F16,
+	LoadSrtDword,
+	SLoadDword,
+	SBufferLoadDword,
+	BufferLoadUbyte,
+	BufferLoadSbyte,
+	BufferLoadUshort,
+	BufferLoadSshort,
+	BufferLoadDword,
+	BufferStoreByte,
+	BufferStoreShort,
+	BufferStoreDword,
+	AtomicSwapU32,
+	AtomicAddU32,
+	AtomicSubU32,
+	AtomicSMinI32,
+	AtomicUMinU32,
+	AtomicSMaxI32,
+	AtomicUMaxU32,
+	AtomicAndU32,
+	AtomicOrU32,
+	AtomicXorU32,
+	FlatLoadUbyte,
+	FlatLoadSbyte,
+	FlatLoadUshort,
+	FlatLoadSshort,
+	FlatLoadDword,
+	FlatStoreByte,
+	FlatStoreShort,
+	FlatStoreDword,
+	DsReadUbyte,
+	DsReadSbyte,
+	DsReadUshort,
+	DsReadSshort,
+	DsReadB32,
+	DsWriteByte,
+	DsWriteShort,
+	DsWriteB32,
+	DsMinF32,
+	DsMaxF32,
+	DsSwizzleB32,
+	DsConsume,
+	DsAppend,
+	DsWriteAddtidB32,
+	DsReadAddtidB32,
+	ImageGetResinfo,
+	ImageGetLod,
+	ImageLoad,
+	ImageStore,
+	ImageSample,
+	ImageGather4,
+	LoadInputF32,
+	Export,
 };

-enum class OpcodeClass { General, Compare, Compare64 };
-
-struct OpcodeInfo {
-	std::string_view name;
-	OpcodeClass      opcode_class = OpcodeClass::General;
-};
-
-inline constexpr OpcodeInfo OPCODE_INFO[] = {
-#define IR_OPCODE(name, category) {#name, OpcodeClass::category},
-#include "graphics/shader/recompiler/ir/ShaderIROpcodes.inc"
-#undef IR_OPCODE
-};
-static_assert(sizeof(OPCODE_INFO) / sizeof(OPCODE_INFO[0]) == static_cast<size_t>(Opcode::Count));
-
-constexpr const OpcodeInfo& GetOpcodeInfo(Opcode opcode) {
-	return OPCODE_INFO[static_cast<size_t>(opcode)];
-}
-
-constexpr std::string_view OpcodeName(Opcode opcode) {
-	return GetOpcodeInfo(opcode).name;
-}
-
-constexpr bool IsCompareOpcode(Opcode opcode) {
-	return GetOpcodeInfo(opcode).opcode_class != OpcodeClass::General;
-}
-
-constexpr bool IsCompare64Opcode(Opcode opcode) {
-	return GetOpcodeInfo(opcode).opcode_class == OpcodeClass::Compare64;
-}
-
 enum class RegisterFile { Scalar, Vector, Vcc, Exec, Scc, M0 };

 struct Register {
@@ -296,11 +598,14 @@ enum class ImageMipMode { None, DynamicStorage };
 constexpr uint32_t StorageImageIdentitySwizzle = 0x00000facu;

 struct ImageResource {
+	static constexpr uint32_t MaxMipLevels = 16;
+
 	uint32_t                source          = 0;
 	uint32_t                first_use_pc    = 0;
 	ResourceKind            kind            = ResourceKind::None;
 	Decoder::ImageDimension dimension       = Decoder::ImageDimension::Unknown;
 	ImageMipMode            mip_mode        = ImageMipMode::None;
+	uint32_t                mip_levels      = 1;
 	uint32_t                storage_swizzle = StorageImageIdentitySwizzle;
 	bool                    read            = false;
 	bool                    written         = false;
@@ -308,6 +613,10 @@ struct ImageResource {
 	bool                    depth_compare   = false;
 	bool                    cube            = false;

+	[[nodiscard]] uint32_t NumBindings() const {
+		return mip_mode == ImageMipMode::DynamicStorage ? mip_levels : 1u;
+	}
+
 	bool operator==(const ImageResource& other) const = default;
 };

@@ -3,17 +3,16 @@

 #include "graphics/shader/recompiler/ir/ShaderIR.h"

-#include <optional>
-
 namespace Libs::Graphics::ShaderRecompiler::IR {

 void SetError(std::string* error, const char* message);

-std::optional<Opcode> LookupIrOpcode(Decoder::Opcode opcode);
-bool                  IsReversedBinary(Decoder::Opcode opcode);
-bool                  IsVectorCarryOutOpcode(Decoder::Opcode opcode);
-bool                  ScalarResultWritesSccNonZero(Decoder::Opcode opcode);
-bool                  ScalarResultIs64Bit(Decoder::Opcode opcode);
+Opcode LookupIrOpcode(Decoder::Opcode opcode);
+bool   IsImplemented(Decoder::Opcode opcode);
+bool   IsReversedBinary(Decoder::Opcode opcode);
+bool   IsVectorCarryOutOpcode(Decoder::Opcode opcode);
+bool   ScalarResultWritesSccNonZero(Decoder::Opcode opcode);
+bool   ScalarResultIs64Bit(Decoder::Opcode opcode);

 Operand  MakeSccOperand();
 Operand  MakeImmediateU32(uint32_t value);
@@ -157,7 +157,345 @@ std::string InstructionToString(const Instruction& inst) {
 		text += ExportInfoToString(inst.export_info);
 		return text;
 	}
-	text += OpcodeName(inst.op);
+	switch (inst.op) {
+		case Opcode::ControlNop: text += "ControlNop"; break;
+		case Opcode::Waitcnt: text += "Waitcnt"; break;
+		case Opcode::Barrier: text += "Barrier"; break;
+		case Opcode::Sendmsg: text += "Sendmsg"; break;
+		case Opcode::TtraceData: text += "TtraceData"; break;
+		case Opcode::InstPrefetch: text += "InstPrefetch"; break;
+		case Opcode::MoveU32: text += "MoveU32"; break;
+		case Opcode::MoveF32Bits: text += "MoveF32Bits"; break;
+		case Opcode::MoveRelDestU32: text += "MoveRelDestU32"; break;
+		case Opcode::MoveRelSourceU32: text += "MoveRelSourceU32"; break;
+		case Opcode::MoveU64: text += "MoveU64"; break;
+		case Opcode::WqmB64: text += "WqmB64"; break;
+		case Opcode::SaveexecB32: text += "SaveexecB32"; break;
+		case Opcode::SaveexecB64: text += "SaveexecB64"; break;
+		case Opcode::ReadFirstLaneU32: text += "ReadFirstLaneU32"; break;
+		case Opcode::ReadLaneU32: text += "ReadLaneU32"; break;
+		case Opcode::WriteLaneU32: text += "WriteLaneU32"; break;
+		case Opcode::Permlane16B32: text += "Permlane16B32"; break;
+		case Opcode::Permlanex16B32: text += "Permlanex16B32"; break;
+		case Opcode::AbsI32: text += "AbsI32"; break;
+		case Opcode::IAddU32: text += "IAddU32"; break;
+		case Opcode::IAddCarryU32: text += "IAddCarryU32"; break;
+		case Opcode::ISubBorrowU32: text += "ISubBorrowU32"; break;
+		case Opcode::ScalarAddCarryU32: text += "ScalarAddCarryU32"; break;
+		case Opcode::ScalarSubBorrowU32: text += "ScalarSubBorrowU32"; break;
+		case Opcode::ScalarSubBorrowCarryU32: text += "ScalarSubBorrowCarryU32"; break;
+		case Opcode::ScalarSignedAddOverflowI32: text += "ScalarSignedAddOverflowI32"; break;
+		case Opcode::ScalarSignedSubOverflowI32: text += "ScalarSignedSubOverflowI32"; break;
+		case Opcode::ScalarShiftLeftAddCarryU32: text += "ScalarShiftLeftAddCarryU32"; break;
+		case Opcode::ISubU32: text += "ISubU32"; break;
+		case Opcode::IMulU32: text += "IMulU32"; break;
+		case Opcode::UMulHighU32: text += "UMulHighU32"; break;
+		case Opcode::SMulHighI32: text += "SMulHighI32"; break;
+		case Opcode::IMadI24U32: text += "IMadI24U32"; break;
+		case Opcode::UMadU24U32: text += "UMadU24U32"; break;
+		case Opcode::UMadU64U32: text += "UMadU64U32"; break;
+		case Opcode::SadU32: text += "SadU32"; break;
+		case Opcode::IAdd3U32: text += "IAdd3U32"; break;
+		case Opcode::IMulI24U32: text += "IMulI24U32"; break;
+		case Opcode::UMulU24U32: text += "UMulU24U32"; break;
+		case Opcode::IMinI32: text += "IMinI32"; break;
+		case Opcode::IMaxI32: text += "IMaxI32"; break;
+		case Opcode::IMin3I32: text += "IMin3I32"; break;
+		case Opcode::IMax3I32: text += "IMax3I32"; break;
+		case Opcode::IMed3I32: text += "IMed3I32"; break;
+		case Opcode::UMinU32: text += "UMinU32"; break;
+		case Opcode::UMaxU32: text += "UMaxU32"; break;
+		case Opcode::UMin3U32: text += "UMin3U32"; break;
+		case Opcode::UMax3U32: text += "UMax3U32"; break;
+		case Opcode::UMed3U32: text += "UMed3U32"; break;
+		case Opcode::BitwiseAndU32: text += "BitwiseAndU32"; break;
+		case Opcode::BitwiseAndU64: text += "BitwiseAndU64"; break;
+		case Opcode::BitwiseAndNotU32: text += "BitwiseAndNotU32"; break;
+		case Opcode::BitwiseAndNotU64: text += "BitwiseAndNotU64"; break;
+		case Opcode::BitwiseOrU32: text += "BitwiseOrU32"; break;
+		case Opcode::BitwiseOrU64: text += "BitwiseOrU64"; break;
+		case Opcode::BitwiseOrNotU32: text += "BitwiseOrNotU32"; break;
+		case Opcode::BitwiseOrNotU64: text += "BitwiseOrNotU64"; break;
+		case Opcode::BitwiseAndOrU32: text += "BitwiseAndOrU32"; break;
+		case Opcode::BitwiseOr3U32: text += "BitwiseOr3U32"; break;
+		case Opcode::BitwiseXorU32: text += "BitwiseXorU32"; break;
+		case Opcode::BitwiseXorU64: text += "BitwiseXorU64"; break;
+		case Opcode::BitwiseXor3U32: text += "BitwiseXor3U32"; break;
+		case Opcode::BitwiseNandU32: text += "BitwiseNandU32"; break;
+		case Opcode::BitwiseNandU64: text += "BitwiseNandU64"; break;
+		case Opcode::BitwiseNorU32: text += "BitwiseNorU32"; break;
+		case Opcode::BitwiseNorU64: text += "BitwiseNorU64"; break;
+		case Opcode::BitwiseXnorU32: text += "BitwiseXnorU32"; break;
+		case Opcode::BitwiseXnorU64: text += "BitwiseXnorU64"; break;
+		case Opcode::BitwiseNotU32: text += "BitwiseNotU32"; break;
+		case Opcode::BitwiseNotU64: text += "BitwiseNotU64"; break;
+		case Opcode::BitClearU32: text += "BitClearU32"; break;
+		case Opcode::BitSetU32: text += "BitSetU32"; break;
+		case Opcode::BitReverseU32: text += "BitReverseU32"; break;
+		case Opcode::BitCountU32: text += "BitCountU32"; break;
+		case Opcode::BitCountU64: text += "BitCountU64"; break;
+		case Opcode::BitReplicateB64B32: text += "BitReplicateB64B32"; break;
+		case Opcode::BitCountAddU32: text += "BitCountAddU32"; break;
+		case Opcode::MaskedBitCountLowU32: text += "MaskedBitCountLowU32"; break;
+		case Opcode::MaskedBitCountHighU32: text += "MaskedBitCountHighU32"; break;
+		case Opcode::FindLsbU32: text += "FindLsbU32"; break;
+		case Opcode::FindMsbFromHighU32: text += "FindMsbFromHighU32"; break;
+		case Opcode::FindMsbFromHighU64: text += "FindMsbFromHighU64"; break;
+		case Opcode::BitFieldMaskU32: text += "BitFieldMaskU32"; break;
+		case Opcode::BitFieldMaskU64: text += "BitFieldMaskU64"; break;
+		case Opcode::BitFieldExtractU32: text += "BitFieldExtractU32"; break;
+		case Opcode::BitFieldExtractU64: text += "BitFieldExtractU64"; break;
+		case Opcode::BitFieldExtract3U32: text += "BitFieldExtract3U32"; break;
+		case Opcode::BitFieldExtract3I32: text += "BitFieldExtract3I32"; break;
+		case Opcode::BitFieldInsertSelectU32: text += "BitFieldInsertSelectU32"; break;
+		case Opcode::BitCompare0B32: text += "BitCompare0B32"; break;
+		case Opcode::BitCompare1B32: text += "BitCompare1B32"; break;
+		case Opcode::AlignBitU32: text += "AlignBitU32"; break;
+		case Opcode::ShiftLeftAddU32: text += "ShiftLeftAddU32"; break;
+		case Opcode::AddShiftLeftU32: text += "AddShiftLeftU32"; break;
+		case Opcode::XorAddU32: text += "XorAddU32"; break;
+		case Opcode::ShiftLeftOrU32: text += "ShiftLeftOrU32"; break;
+		case Opcode::ShiftLeftLogicalU32: text += "ShiftLeftLogicalU32"; break;
+		case Opcode::ShiftLeftLogicalU64: text += "ShiftLeftLogicalU64"; break;
+		case Opcode::ShiftLeftLogicalU16: text += "ShiftLeftLogicalU16"; break;
+		case Opcode::ShiftRightLogicalU32: text += "ShiftRightLogicalU32"; break;
+		case Opcode::ShiftRightLogicalU64: text += "ShiftRightLogicalU64"; break;
+		case Opcode::ShiftRightLogicalU16: text += "ShiftRightLogicalU16"; break;
+		case Opcode::ShiftRightArithmeticI32: text += "ShiftRightArithmeticI32"; break;
+		case Opcode::ShiftRightArithmeticI16: text += "ShiftRightArithmeticI16"; break;
+		case Opcode::SelectU32: text += "SelectU32"; break;
+		case Opcode::SelectMaskU32: text += "SelectMaskU32"; break;
+		case Opcode::SelectF32Bits: text += "SelectF32Bits"; break;
+		case Opcode::SelectMaskF32Bits: text += "SelectMaskF32Bits"; break;
+		case Opcode::SelectU64: text += "SelectU64"; break;
+		case Opcode::PackLowLowU16: text += "PackLowLowU16"; break;
+		case Opcode::PackLowHighU16: text += "PackLowHighU16"; break;
+		case Opcode::PackHighHighU16: text += "PackHighHighU16"; break;
+		case Opcode::CompareFalse: text += "CompareFalse"; break;
+		case Opcode::CompareTrue: text += "CompareTrue"; break;
+		case Opcode::CompareEqU32: text += "CompareEqU32"; break;
+		case Opcode::CompareNeU32: text += "CompareNeU32"; break;
+		case Opcode::CompareGtU32: text += "CompareGtU32"; break;
+		case Opcode::CompareGeU32: text += "CompareGeU32"; break;
+		case Opcode::CompareLtU32: text += "CompareLtU32"; break;
+		case Opcode::CompareLeU32: text += "CompareLeU32"; break;
+		case Opcode::CompareNeU64: text += "CompareNeU64"; break;
+		case Opcode::CompareMaskEqU32: text += "CompareMaskEqU32"; break;
+		case Opcode::CompareMaskNeU32: text += "CompareMaskNeU32"; break;
+		case Opcode::CompareMaskGtU32: text += "CompareMaskGtU32"; break;
+		case Opcode::CompareMaskGeU32: text += "CompareMaskGeU32"; break;
+		case Opcode::CompareMaskLtU32: text += "CompareMaskLtU32"; break;
+		case Opcode::CompareMaskLeU32: text += "CompareMaskLeU32"; break;
+		case Opcode::CompareEqI32: text += "CompareEqI32"; break;
+		case Opcode::CompareNeI32: text += "CompareNeI32"; break;
+		case Opcode::CompareGtI32: text += "CompareGtI32"; break;
+		case Opcode::CompareGeI32: text += "CompareGeI32"; break;
+		case Opcode::CompareLtI32: text += "CompareLtI32"; break;
+		case Opcode::CompareLeI32: text += "CompareLeI32"; break;
+		case Opcode::CompareEqI16: text += "CompareEqI16"; break;
+		case Opcode::CompareNeI16: text += "CompareNeI16"; break;
+		case Opcode::CompareGtI16: text += "CompareGtI16"; break;
+		case Opcode::CompareGeI16: text += "CompareGeI16"; break;
+		case Opcode::CompareLtI16: text += "CompareLtI16"; break;
+		case Opcode::CompareLeI16: text += "CompareLeI16"; break;
+		case Opcode::CompareMaskEqI32: text += "CompareMaskEqI32"; break;
+		case Opcode::CompareMaskNeI32: text += "CompareMaskNeI32"; break;
+		case Opcode::CompareMaskGtI32: text += "CompareMaskGtI32"; break;
+		case Opcode::CompareMaskGeI32: text += "CompareMaskGeI32"; break;
+		case Opcode::CompareMaskLtI32: text += "CompareMaskLtI32"; break;
+		case Opcode::CompareMaskLeI32: text += "CompareMaskLeI32"; break;
+		case Opcode::CompareEqU16: text += "CompareEqU16"; break;
+		case Opcode::CompareNeU16: text += "CompareNeU16"; break;
+		case Opcode::CompareGtU16: text += "CompareGtU16"; break;
+		case Opcode::CompareGeU16: text += "CompareGeU16"; break;
+		case Opcode::CompareLtU16: text += "CompareLtU16"; break;
+		case Opcode::CompareLeU16: text += "CompareLeU16"; break;
+		case Opcode::CompareEqF32: text += "CompareEqF32"; break;
+		case Opcode::CompareNeF32: text += "CompareNeF32"; break;
+		case Opcode::CompareGtF32: text += "CompareGtF32"; break;
+		case Opcode::CompareGeF32: text += "CompareGeF32"; break;
+		case Opcode::CompareLtF32: text += "CompareLtF32"; break;
+		case Opcode::CompareLeF32: text += "CompareLeF32"; break;
+		case Opcode::CompareOrderedF32: text += "CompareOrderedF32"; break;
+		case Opcode::CompareUnorderedF32: text += "CompareUnorderedF32"; break;
+		case Opcode::CompareUnordEqF32: text += "CompareUnordEqF32"; break;
+		case Opcode::CompareUnordNeF32: text += "CompareUnordNeF32"; break;
+		case Opcode::CompareUnordGtF32: text += "CompareUnordGtF32"; break;
+		case Opcode::CompareUnordGeF32: text += "CompareUnordGeF32"; break;
+		case Opcode::CompareUnordLtF32: text += "CompareUnordLtF32"; break;
+		case Opcode::CompareUnordLeF32: text += "CompareUnordLeF32"; break;
+		case Opcode::CompareClassF32: text += "CompareClassF32"; break;
+		case Opcode::CompareEqF16: text += "CompareEqF16"; break;
+		case Opcode::CompareNeF16: text += "CompareNeF16"; break;
+		case Opcode::CompareGtF16: text += "CompareGtF16"; break;
+		case Opcode::CompareGeF16: text += "CompareGeF16"; break;
+		case Opcode::CompareLtF16: text += "CompareLtF16"; break;
+		case Opcode::CompareLeF16: text += "CompareLeF16"; break;
+		case Opcode::CompareUnordNeF16: text += "CompareUnordNeF16"; break;
+		case Opcode::CompareMaskEqF16: text += "CompareMaskEqF16"; break;
+		case Opcode::CompareMaskNeF16: text += "CompareMaskNeF16"; break;
+		case Opcode::CompareMaskGtF16: text += "CompareMaskGtF16"; break;
+		case Opcode::CompareMaskGeF16: text += "CompareMaskGeF16"; break;
+		case Opcode::CompareMaskLtF16: text += "CompareMaskLtF16"; break;
+		case Opcode::CompareMaskLeF16: text += "CompareMaskLeF16"; break;
+		case Opcode::CompareMaskUnordNeF16: text += "CompareMaskUnordNeF16"; break;
+		case Opcode::CompareMaskUnordGeF16: text += "CompareMaskUnordGeF16"; break;
+		case Opcode::CompareMaskEqF32: text += "CompareMaskEqF32"; break;
+		case Opcode::CompareMaskNeF32: text += "CompareMaskNeF32"; break;
+		case Opcode::CompareMaskGtF32: text += "CompareMaskGtF32"; break;
+		case Opcode::CompareMaskGeF32: text += "CompareMaskGeF32"; break;
+		case Opcode::CompareMaskLtF32: text += "CompareMaskLtF32"; break;
+		case Opcode::CompareMaskLeF32: text += "CompareMaskLeF32"; break;
+		case Opcode::CompareMaskUnordEqF32: text += "CompareMaskUnordEqF32"; break;
+		case Opcode::CompareMaskUnordNeF32: text += "CompareMaskUnordNeF32"; break;
+		case Opcode::CompareMaskUnordGtF32: text += "CompareMaskUnordGtF32"; break;
+		case Opcode::CompareMaskUnordGeF32: text += "CompareMaskUnordGeF32"; break;
+		case Opcode::CompareMaskUnordLtF32: text += "CompareMaskUnordLtF32"; break;
+		case Opcode::CompareMaskUnordLeF32: text += "CompareMaskUnordLeF32"; break;
+		case Opcode::ConvertByteU32ToF32: text += "ConvertByteU32ToF32"; break;
+		case Opcode::ConvertU32ToF32: text += "ConvertU32ToF32"; break;
+		case Opcode::ConvertI32ToF32: text += "ConvertI32ToF32"; break;
+		case Opcode::ConvertF32ToU32: text += "ConvertF32ToU32"; break;
+		case Opcode::ConvertF32ToI32: text += "ConvertF32ToI32"; break;
+		case Opcode::ConvertF32ToF16: text += "ConvertF32ToF16"; break;
+		case Opcode::ConvertF16ToF32: text += "ConvertF16ToF32"; break;
+		case Opcode::ConvertU16ToF16: text += "ConvertU16ToF16"; break;
+		case Opcode::ConvertF16ToU16: text += "ConvertF16ToU16"; break;
+		case Opcode::ConvertI16ToF16: text += "ConvertI16ToF16"; break;
+		case Opcode::ConvertF16ToI16: text += "ConvertF16ToI16"; break;
+		case Opcode::ConvertRoundPlusInfF32ToI32: text += "ConvertRoundPlusInfF32ToI32"; break;
+		case Opcode::ConvertFloorF32ToI32: text += "ConvertFloorF32ToI32"; break;
+		case Opcode::ConvertI4ToOffsetF32: text += "ConvertI4ToOffsetF32"; break;
+		case Opcode::LdexpF32: text += "LdexpF32"; break;
+		case Opcode::PackF32ToF16Rtz: text += "PackF32ToF16Rtz"; break;
+		case Opcode::PackSnorm2x16F32: text += "PackSnorm2x16F32"; break;
+		case Opcode::PackUnorm2x16F32: text += "PackUnorm2x16F32"; break;
+		case Opcode::PackU16U32: text += "PackU16U32"; break;
+		case Opcode::PackU8F32: text += "PackU8F32"; break;
+		case Opcode::PackB32F16: text += "PackB32F16"; break;
+		case Opcode::PackedMadI16: text += "PackedMadI16"; break;
+		case Opcode::PackedMulLoU16: text += "PackedMulLoU16"; break;
+		case Opcode::PackedAddI16: text += "PackedAddI16"; break;
+		case Opcode::PackedSubI16: text += "PackedSubI16"; break;
+		case Opcode::PackedLshlrevB16: text += "PackedLshlrevB16"; break;
+		case Opcode::PackedLshrrevB16: text += "PackedLshrrevB16"; break;
+		case Opcode::PackedAshrrevI16: text += "PackedAshrrevI16"; break;
+		case Opcode::PackedMaxI16: text += "PackedMaxI16"; break;
+		case Opcode::PackedMinI16: text += "PackedMinI16"; break;
+		case Opcode::PackedMadU16: text += "PackedMadU16"; break;
+		case Opcode::PackedAddU16: text += "PackedAddU16"; break;
+		case Opcode::PackedSubU16: text += "PackedSubU16"; break;
+		case Opcode::PackedMaxU16: text += "PackedMaxU16"; break;
+		case Opcode::PackedMinU16: text += "PackedMinU16"; break;
+		case Opcode::PackedAddF16: text += "PackedAddF16"; break;
+		case Opcode::PackedMulF16: text += "PackedMulF16"; break;
+		case Opcode::PackedMinF16: text += "PackedMinF16"; break;
+		case Opcode::PackedMaxF16: text += "PackedMaxF16"; break;
+		case Opcode::PackedFmaF16: text += "PackedFmaF16"; break;
+		case Opcode::AddF16: text += "AddF16"; break;
+		case Opcode::SubF16: text += "SubF16"; break;
+		case Opcode::MulF16: text += "MulF16"; break;
+		case Opcode::MinF16: text += "MinF16"; break;
+		case Opcode::MaxF16: text += "MaxF16"; break;
+		case Opcode::FmaF16: text += "FmaF16"; break;
+		case Opcode::MadMixF16: text += "MadMixF16"; break;
+		case Opcode::IAddU16: text += "IAddU16"; break;
+		case Opcode::ISubI16: text += "ISubI16"; break;
+		case Opcode::IMinI16: text += "IMinI16"; break;
+		case Opcode::IMaxI16: text += "IMaxI16"; break;
+		case Opcode::UMinU16: text += "UMinU16"; break;
+		case Opcode::UMaxU16: text += "UMaxU16"; break;
+		case Opcode::RcpF32: text += "RcpF32"; break;
+		case Opcode::FractF32: text += "FractF32"; break;
+		case Opcode::TruncF32: text += "TruncF32"; break;
+		case Opcode::CeilF32: text += "CeilF32"; break;
+		case Opcode::RoundEvenF32: text += "RoundEvenF32"; break;
+		case Opcode::FloorF32: text += "FloorF32"; break;
+		case Opcode::Exp2F32: text += "Exp2F32"; break;
+		case Opcode::Log2F32: text += "Log2F32"; break;
+		case Opcode::InverseSqrtF32: text += "InverseSqrtF32"; break;
+		case Opcode::SqrtF32: text += "SqrtF32"; break;
+		case Opcode::RcpF16: text += "RcpF16"; break;
+		case Opcode::SqrtF16: text += "SqrtF16"; break;
+		case Opcode::InverseSqrtF16: text += "InverseSqrtF16"; break;
+		case Opcode::Log2F16: text += "Log2F16"; break;
+		case Opcode::Exp2F16: text += "Exp2F16"; break;
+		case Opcode::FloorF16: text += "FloorF16"; break;
+		case Opcode::CeilF16: text += "CeilF16"; break;
+		case Opcode::TruncF16: text += "TruncF16"; break;
+		case Opcode::RoundEvenF16: text += "RoundEvenF16"; break;
+		case Opcode::SinF32: text += "SinF32"; break;
+		case Opcode::CosF32: text += "CosF32"; break;
+		case Opcode::CubeIdF32: text += "CubeIdF32"; break;
+		case Opcode::CubeScF32: text += "CubeScF32"; break;
+		case Opcode::CubeTcF32: text += "CubeTcF32"; break;
+		case Opcode::CubeMaF32: text += "CubeMaF32"; break;
+		case Opcode::FAddF32: text += "FAddF32"; break;
+		case Opcode::FSubF32: text += "FSubF32"; break;
+		case Opcode::FMulF32: text += "FMulF32"; break;
+		case Opcode::FMinF32: text += "FMinF32"; break;
+		case Opcode::FMaxF32: text += "FMaxF32"; break;
+		case Opcode::FMadF32: text += "FMadF32"; break;
+		case Opcode::Dot2AccF32F16: text += "Dot2AccF32F16"; break;
+		case Opcode::FMin3F32: text += "FMin3F32"; break;
+		case Opcode::FMax3F32: text += "FMax3F32"; break;
+		case Opcode::FMed3F32: text += "FMed3F32"; break;
+		case Opcode::Min3F16: text += "Min3F16"; break;
+		case Opcode::Max3F16: text += "Max3F16"; break;
+		case Opcode::Med3F16: text += "Med3F16"; break;
+		case Opcode::LoadSrtDword: text += "LoadSrtDword"; break;
+		case Opcode::SLoadDword: text += "SLoadDword"; break;
+		case Opcode::SBufferLoadDword: text += "SBufferLoadDword"; break;
+		case Opcode::BufferLoadUbyte: text += "BufferLoadUbyte"; break;
+		case Opcode::BufferLoadSbyte: text += "BufferLoadSbyte"; break;
+		case Opcode::BufferLoadUshort: text += "BufferLoadUshort"; break;
+		case Opcode::BufferLoadSshort: text += "BufferLoadSshort"; break;
+		case Opcode::BufferLoadDword: text += "BufferLoadDword"; break;
+		case Opcode::BufferStoreByte: text += "BufferStoreByte"; break;
+		case Opcode::BufferStoreShort: text += "BufferStoreShort"; break;
+		case Opcode::BufferStoreDword: text += "BufferStoreDword"; break;
+		case Opcode::AtomicSwapU32: text += "AtomicSwapU32"; break;
+		case Opcode::AtomicAddU32: text += "AtomicAddU32"; break;
+		case Opcode::AtomicSubU32: text += "AtomicSubU32"; break;
+		case Opcode::AtomicSMinI32: text += "AtomicSMinI32"; break;
+		case Opcode::AtomicUMinU32: text += "AtomicUMinU32"; break;
+		case Opcode::AtomicSMaxI32: text += "AtomicSMaxI32"; break;
+		case Opcode::AtomicUMaxU32: text += "AtomicUMaxU32"; break;
+		case Opcode::AtomicAndU32: text += "AtomicAndU32"; break;
+		case Opcode::AtomicOrU32: text += "AtomicOrU32"; break;
+		case Opcode::AtomicXorU32: text += "AtomicXorU32"; break;
+		case Opcode::FlatLoadUbyte: text += "FlatLoadUbyte"; break;
+		case Opcode::FlatLoadSbyte: text += "FlatLoadSbyte"; break;
+		case Opcode::FlatLoadUshort: text += "FlatLoadUshort"; break;
+		case Opcode::FlatLoadSshort: text += "FlatLoadSshort"; break;
+		case Opcode::FlatLoadDword: text += "FlatLoadDword"; break;
+		case Opcode::FlatStoreByte: text += "FlatStoreByte"; break;
+		case Opcode::FlatStoreShort: text += "FlatStoreShort"; break;
+		case Opcode::FlatStoreDword: text += "FlatStoreDword"; break;
+		case Opcode::DsReadUbyte: text += "DsReadUbyte"; break;
+		case Opcode::DsReadSbyte: text += "DsReadSbyte"; break;
+		case Opcode::DsReadUshort: text += "DsReadUshort"; break;
+		case Opcode::DsReadSshort: text += "DsReadSshort"; break;
+		case Opcode::DsReadB32: text += "DsReadB32"; break;
+		case Opcode::DsWriteByte: text += "DsWriteByte"; break;
+		case Opcode::DsWriteShort: text += "DsWriteShort"; break;
+		case Opcode::DsWriteB32: text += "DsWriteB32"; break;
+		case Opcode::DsMinF32: text += "DsMinF32"; break;
+		case Opcode::DsMaxF32: text += "DsMaxF32"; break;
+		case Opcode::DsSwizzleB32: text += "DsSwizzleB32"; break;
+		case Opcode::DsConsume: text += "DsConsume"; break;
+		case Opcode::DsAppend: text += "DsAppend"; break;
+		case Opcode::DsWriteAddtidB32: text += "DsWriteAddtidB32"; break;
+		case Opcode::DsReadAddtidB32: text += "DsReadAddtidB32"; break;
+		case Opcode::ImageGetResinfo: text += "ImageGetResinfo"; break;
+		case Opcode::ImageGetLod: text += "ImageGetLod"; break;
+		case Opcode::ImageLoad: text += "ImageLoad"; break;
+		case Opcode::ImageStore: text += "ImageStore"; break;
+		case Opcode::ImageSample: text += "ImageSample"; break;
+		case Opcode::ImageGather4: text += "ImageGather4"; break;
+		case Opcode::LoadInputF32: text += "LoadInputF32"; break;
+		case Opcode::Export: text += "Export"; break;
+	}
 	text += " ";
 	text += OperandToString(inst.dst);
 	if (inst.dst2.kind != OperandKind::Null) {
@@ -569,10 +569,6 @@ bool LowerMemoryInstruction(const Decoder::Instruction& decoded, BasicBlock& blo
 			return LowerBufferAtomicDword(decoded, block, Opcode::AtomicOrU32, error);
 		case Decoder::Opcode::BufferAtomicXor:
 			return LowerBufferAtomicDword(decoded, block, Opcode::AtomicXorU32, error);
-		case Decoder::Opcode::BufferAtomicFMin:
-			return LowerBufferAtomicDword(decoded, block, Opcode::AtomicFMinF32, error);
-		case Decoder::Opcode::BufferAtomicFMax:
-			return LowerBufferAtomicDword(decoded, block, Opcode::AtomicFMaxF32, error);
 		case Decoder::Opcode::FlatLoadUbyte:
 		case Decoder::Opcode::FlatLoadSbyte:
 		case Decoder::Opcode::FlatLoadUshort:
@@ -677,12 +673,7 @@ bool LowerMemoryInstruction(const Decoder::Instruction& decoded, BasicBlock& blo
 		case Decoder::Opcode::ImageAtomicAnd:
 		case Decoder::Opcode::ImageAtomicOr:
 		case Decoder::Opcode::ImageAtomicXor: return LowerImageAtomicU32(decoded, block, error);
-		default:
-			if (error != nullptr) {
-				*error = fmt::format("memory opcode has no specialized IR lowering: {}",
-				                     Decoder::OpcodeToString(decoded.opcode));
-			}
-			return false;
+		default: return false;
 	}
 }

@@ -738,8 +729,6 @@ bool IsMemoryOpcode(Decoder::Opcode opcode) {
 		case Decoder::Opcode::BufferAtomicAnd:
 		case Decoder::Opcode::BufferAtomicOr:
 		case Decoder::Opcode::BufferAtomicXor:
-		case Decoder::Opcode::BufferAtomicFMin:
-		case Decoder::Opcode::BufferAtomicFMax:
 		case Decoder::Opcode::FlatLoadUbyte:
 		case Decoder::Opcode::FlatLoadSbyte:
 		case Decoder::Opcode::FlatLoadUshort:
@@ -82,7 +82,6 @@ constexpr LowerMap LOWER_OPS[] = {
    {Decoder::Opcode::SCmpGeU32, Opcode::CompareGeU32},
    {Decoder::Opcode::SCmpLtU32, Opcode::CompareLtU32},
    {Decoder::Opcode::SCmpLeU32, Opcode::CompareLeU32},
-    {Decoder::Opcode::SCmpEqU64, Opcode::CompareEqU64},
    {Decoder::Opcode::SCmpLgU64, Opcode::CompareNeU64},
    {Decoder::Opcode::VReadfirstlaneB32, Opcode::ReadFirstLaneU32},
    {Decoder::Opcode::VReadlaneB32, Opcode::ReadLaneU32},
@@ -326,7 +325,6 @@ constexpr LowerMap LOWER_OPS[] = {
    {Decoder::Opcode::VCmpNeU32, Opcode::CompareNeU32},
    {Decoder::Opcode::VCmpGeU32, Opcode::CompareGeU32},
    {Decoder::Opcode::VCmpTU32, Opcode::CompareTrue},
-    {Decoder::Opcode::VCmpEqI64, Opcode::CompareEqU64},
    {Decoder::Opcode::VCmpNeU64, Opcode::CompareNeU64},
    {Decoder::Opcode::VCmpxLtU32, Opcode::CompareMaskLtU32},
    {Decoder::Opcode::VCmpxEqU32, Opcode::CompareMaskEqU32},
@@ -352,8 +350,6 @@ constexpr LowerMap LOWER_OPS[] = {
    {Decoder::Opcode::BufferAtomicAnd, Opcode::AtomicAndU32},
    {Decoder::Opcode::BufferAtomicOr, Opcode::AtomicOrU32},
    {Decoder::Opcode::BufferAtomicXor, Opcode::AtomicXorU32},
-    {Decoder::Opcode::BufferAtomicFMin, Opcode::AtomicFMinF32},
-    {Decoder::Opcode::BufferAtomicFMax, Opcode::AtomicFMaxF32},
    {Decoder::Opcode::FlatLoadUbyte, Opcode::FlatLoadUbyte},
    {Decoder::Opcode::FlatLoadSbyte, Opcode::FlatLoadSbyte},
    {Decoder::Opcode::FlatLoadSshort, Opcode::FlatLoadSshort},
@@ -436,13 +432,22 @@ void SetError(std::string* error, const char* message) {
 	}
 }

-std::optional<Opcode> LookupIrOpcode(Decoder::Opcode opcode) {
+Opcode LookupIrOpcode(Decoder::Opcode opcode) {
 	for (const auto& op: LOWER_OPS) {
 		if (op.decoded == opcode) {
 			return op.ir;
 		}
 	}
-	return std::nullopt;
+	return Opcode::MoveU32;
+}
+
+bool IsImplemented(Decoder::Opcode opcode) {
+	for (const auto& op: LOWER_OPS) {
+		if (op.decoded == opcode) {
+			return true;
+		}
+	}
+	return false;
 }

 bool IsReversedBinary(Decoder::Opcode opcode) {
@@ -1,342 +0,0 @@
-// Central IR opcode catalog. Keep semantic categories here so enum identity, logging,
-// and generic analysis cannot drift apart.
-IR_OPCODE(ControlNop, General)
-IR_OPCODE(Waitcnt, General)
-IR_OPCODE(Barrier, General)
-IR_OPCODE(Sendmsg, General)
-IR_OPCODE(TtraceData, General)
-IR_OPCODE(InstPrefetch, General)
-IR_OPCODE(MoveU32, General)
-IR_OPCODE(MoveF32Bits, General)
-IR_OPCODE(MoveRelDestU32, General)
-IR_OPCODE(MoveRelSourceU32, General)
-IR_OPCODE(MoveU64, General)
-IR_OPCODE(WqmB64, General)
-IR_OPCODE(SaveexecB32, General)
-IR_OPCODE(SaveexecB64, General)
-IR_OPCODE(ReadFirstLaneU32, General)
-IR_OPCODE(ReadLaneU32, General)
-IR_OPCODE(WriteLaneU32, General)
-IR_OPCODE(Permlane16B32, General)
-IR_OPCODE(Permlanex16B32, General)
-IR_OPCODE(AbsI32, General)
-IR_OPCODE(IAddU32, General)
-IR_OPCODE(IAddCarryU32, General)
-IR_OPCODE(ISubBorrowU32, General)
-IR_OPCODE(ScalarAddCarryU32, General)
-IR_OPCODE(ScalarSubBorrowU32, General)
-IR_OPCODE(ScalarSubBorrowCarryU32, General)
-IR_OPCODE(ScalarSignedAddOverflowI32, General)
-IR_OPCODE(ScalarSignedSubOverflowI32, General)
-IR_OPCODE(ScalarShiftLeftAddCarryU32, General)
-IR_OPCODE(ISubU32, General)
-IR_OPCODE(IMulU32, General)
-IR_OPCODE(UMulHighU32, General)
-IR_OPCODE(SMulHighI32, General)
-IR_OPCODE(IMadI24U32, General)
-IR_OPCODE(UMadU24U32, General)
-IR_OPCODE(UMadU64U32, General)
-IR_OPCODE(SadU32, General)
-IR_OPCODE(IAdd3U32, General)
-IR_OPCODE(IMulI24U32, General)
-IR_OPCODE(UMulU24U32, General)
-IR_OPCODE(IMinI32, General)
-IR_OPCODE(IMaxI32, General)
-IR_OPCODE(IMin3I32, General)
-IR_OPCODE(IMax3I32, General)
-IR_OPCODE(IMed3I32, General)
-IR_OPCODE(UMinU32, General)
-IR_OPCODE(UMaxU32, General)
-IR_OPCODE(UMin3U32, General)
-IR_OPCODE(UMax3U32, General)
-IR_OPCODE(UMed3U32, General)
-IR_OPCODE(BitwiseAndU32, General)
-IR_OPCODE(BitwiseAndU64, General)
-IR_OPCODE(BitwiseAndNotU32, General)
-IR_OPCODE(BitwiseAndNotU64, General)
-IR_OPCODE(BitwiseOrU32, General)
-IR_OPCODE(BitwiseOrU64, General)
-IR_OPCODE(BitwiseOrNotU32, General)
-IR_OPCODE(BitwiseOrNotU64, General)
-IR_OPCODE(BitwiseAndOrU32, General)
-IR_OPCODE(BitwiseOr3U32, General)
-IR_OPCODE(BitwiseXorU32, General)
-IR_OPCODE(BitwiseXorU64, General)
-IR_OPCODE(BitwiseXor3U32, General)
-IR_OPCODE(BitwiseNandU32, General)
-IR_OPCODE(BitwiseNandU64, General)
-IR_OPCODE(BitwiseNorU32, General)
-IR_OPCODE(BitwiseNorU64, General)
-IR_OPCODE(BitwiseXnorU32, General)
-IR_OPCODE(BitwiseXnorU64, General)
-IR_OPCODE(BitwiseNotU32, General)
-IR_OPCODE(BitwiseNotU64, General)
-IR_OPCODE(BitClearU32, General)
-IR_OPCODE(BitSetU32, General)
-IR_OPCODE(BitReverseU32, General)
-IR_OPCODE(BitCountU32, General)
-IR_OPCODE(BitCountU64, General)
-IR_OPCODE(BitReplicateB64B32, General)
-IR_OPCODE(BitCountAddU32, General)
-IR_OPCODE(MaskedBitCountLowU32, General)
-IR_OPCODE(MaskedBitCountHighU32, General)
-IR_OPCODE(FindLsbU32, General)
-IR_OPCODE(FindMsbFromHighU32, General)
-IR_OPCODE(FindMsbFromHighU64, General)
-IR_OPCODE(BitFieldMaskU32, General)
-IR_OPCODE(BitFieldMaskU64, General)
-IR_OPCODE(BitFieldExtractU32, General)
-IR_OPCODE(BitFieldExtractU64, General)
-IR_OPCODE(BitFieldExtract3U32, General)
-IR_OPCODE(BitFieldExtract3I32, General)
-IR_OPCODE(BitFieldInsertSelectU32, General)
-IR_OPCODE(BitCompare0B32, General)
-IR_OPCODE(BitCompare1B32, General)
-IR_OPCODE(AlignBitU32, General)
-IR_OPCODE(ShiftLeftAddU32, General)
-IR_OPCODE(AddShiftLeftU32, General)
-IR_OPCODE(XorAddU32, General)
-IR_OPCODE(ShiftLeftOrU32, General)
-IR_OPCODE(ShiftLeftLogicalU32, General)
-IR_OPCODE(ShiftLeftLogicalU64, General)
-IR_OPCODE(ShiftLeftLogicalU16, General)
-IR_OPCODE(ShiftRightLogicalU32, General)
-IR_OPCODE(ShiftRightLogicalU64, General)
-IR_OPCODE(ShiftRightLogicalU16, General)
-IR_OPCODE(ShiftRightArithmeticI32, General)
-IR_OPCODE(ShiftRightArithmeticI16, General)
-IR_OPCODE(SelectU32, General)
-IR_OPCODE(SelectMaskU32, General)
-IR_OPCODE(SelectF32Bits, General)
-IR_OPCODE(SelectMaskF32Bits, General)
-IR_OPCODE(SelectU64, General)
-IR_OPCODE(PackLowLowU16, General)
-IR_OPCODE(PackLowHighU16, General)
-IR_OPCODE(PackHighHighU16, General)
-IR_OPCODE(CompareFalse, Compare)
-IR_OPCODE(CompareTrue, Compare)
-IR_OPCODE(CompareEqU32, Compare)
-IR_OPCODE(CompareNeU32, Compare)
-IR_OPCODE(CompareGtU32, Compare)
-IR_OPCODE(CompareGeU32, Compare)
-IR_OPCODE(CompareLtU32, Compare)
-IR_OPCODE(CompareLeU32, Compare)
-IR_OPCODE(CompareEqU64, Compare64)
-IR_OPCODE(CompareNeU64, Compare64)
-IR_OPCODE(CompareMaskEqU32, Compare)
-IR_OPCODE(CompareMaskNeU32, Compare)
-IR_OPCODE(CompareMaskGtU32, Compare)
-IR_OPCODE(CompareMaskGeU32, Compare)
-IR_OPCODE(CompareMaskLtU32, Compare)
-IR_OPCODE(CompareMaskLeU32, Compare)
-IR_OPCODE(CompareEqI32, Compare)
-IR_OPCODE(CompareNeI32, Compare)
-IR_OPCODE(CompareGtI32, Compare)
-IR_OPCODE(CompareGeI32, Compare)
-IR_OPCODE(CompareLtI32, Compare)
-IR_OPCODE(CompareLeI32, Compare)
-IR_OPCODE(CompareEqI16, Compare)
-IR_OPCODE(CompareNeI16, Compare)
-IR_OPCODE(CompareGtI16, Compare)
-IR_OPCODE(CompareGeI16, Compare)
-IR_OPCODE(CompareLtI16, Compare)
-IR_OPCODE(CompareLeI16, Compare)
-IR_OPCODE(CompareMaskEqI32, Compare)
-IR_OPCODE(CompareMaskNeI32, Compare)
-IR_OPCODE(CompareMaskGtI32, Compare)
-IR_OPCODE(CompareMaskGeI32, Compare)
-IR_OPCODE(CompareMaskLtI32, Compare)
-IR_OPCODE(CompareMaskLeI32, Compare)
-IR_OPCODE(CompareEqU16, Compare)
-IR_OPCODE(CompareNeU16, Compare)
-IR_OPCODE(CompareGtU16, Compare)
-IR_OPCODE(CompareGeU16, Compare)
-IR_OPCODE(CompareLtU16, Compare)
-IR_OPCODE(CompareLeU16, Compare)
-IR_OPCODE(CompareEqF32, Compare)
-IR_OPCODE(CompareNeF32, Compare)
-IR_OPCODE(CompareGtF32, Compare)
-IR_OPCODE(CompareGeF32, Compare)
-IR_OPCODE(CompareLtF32, Compare)
-IR_OPCODE(CompareLeF32, Compare)
-IR_OPCODE(CompareOrderedF32, Compare)
-IR_OPCODE(CompareUnorderedF32, Compare)
-IR_OPCODE(CompareUnordEqF32, Compare)
-IR_OPCODE(CompareUnordNeF32, Compare)
-IR_OPCODE(CompareUnordGtF32, Compare)
-IR_OPCODE(CompareUnordGeF32, Compare)
-IR_OPCODE(CompareUnordLtF32, Compare)
-IR_OPCODE(CompareUnordLeF32, Compare)
-IR_OPCODE(CompareClassF32, Compare)
-IR_OPCODE(CompareEqF16, Compare)
-IR_OPCODE(CompareNeF16, Compare)
-IR_OPCODE(CompareGtF16, Compare)
-IR_OPCODE(CompareGeF16, Compare)
-IR_OPCODE(CompareLtF16, Compare)
-IR_OPCODE(CompareLeF16, Compare)
-IR_OPCODE(CompareUnordNeF16, Compare)
-IR_OPCODE(CompareMaskEqF16, Compare)
-IR_OPCODE(CompareMaskNeF16, Compare)
-IR_OPCODE(CompareMaskGtF16, Compare)
-IR_OPCODE(CompareMaskGeF16, Compare)
-IR_OPCODE(CompareMaskLtF16, Compare)
-IR_OPCODE(CompareMaskLeF16, Compare)
-IR_OPCODE(CompareMaskUnordNeF16, Compare)
-IR_OPCODE(CompareMaskUnordGeF16, Compare)
-IR_OPCODE(CompareMaskEqF32, Compare)
-IR_OPCODE(CompareMaskNeF32, Compare)
-IR_OPCODE(CompareMaskGtF32, Compare)
-IR_OPCODE(CompareMaskGeF32, Compare)
-IR_OPCODE(CompareMaskLtF32, Compare)
-IR_OPCODE(CompareMaskLeF32, Compare)
-IR_OPCODE(CompareMaskUnordEqF32, Compare)
-IR_OPCODE(CompareMaskUnordNeF32, Compare)
-IR_OPCODE(CompareMaskUnordGtF32, Compare)
-IR_OPCODE(CompareMaskUnordGeF32, Compare)
-IR_OPCODE(CompareMaskUnordLtF32, Compare)
-IR_OPCODE(CompareMaskUnordLeF32, Compare)
-IR_OPCODE(ConvertByteU32ToF32, General)
-IR_OPCODE(ConvertU32ToF32, General)
-IR_OPCODE(ConvertI32ToF32, General)
-IR_OPCODE(ConvertF32ToU32, General)
-IR_OPCODE(ConvertF32ToI32, General)
-IR_OPCODE(ConvertF32ToF16, General)
-IR_OPCODE(ConvertF16ToF32, General)
-IR_OPCODE(ConvertU16ToF16, General)
-IR_OPCODE(ConvertF16ToU16, General)
-IR_OPCODE(ConvertI16ToF16, General)
-IR_OPCODE(ConvertF16ToI16, General)
-IR_OPCODE(ConvertRoundPlusInfF32ToI32, General)
-IR_OPCODE(ConvertFloorF32ToI32, General)
-IR_OPCODE(ConvertI4ToOffsetF32, General)
-IR_OPCODE(LdexpF32, General)
-IR_OPCODE(PackF32ToF16Rtz, General)
-IR_OPCODE(PackSnorm2x16F32, General)
-IR_OPCODE(PackUnorm2x16F32, General)
-IR_OPCODE(PackU16U32, General)
-IR_OPCODE(PackU8F32, General)
-IR_OPCODE(PackB32F16, General)
-IR_OPCODE(PackedMadI16, General)
-IR_OPCODE(PackedMulLoU16, General)
-IR_OPCODE(PackedAddI16, General)
-IR_OPCODE(PackedSubI16, General)
-IR_OPCODE(PackedLshlrevB16, General)
-IR_OPCODE(PackedLshrrevB16, General)
-IR_OPCODE(PackedAshrrevI16, General)
-IR_OPCODE(PackedMaxI16, General)
-IR_OPCODE(PackedMinI16, General)
-IR_OPCODE(PackedMadU16, General)
-IR_OPCODE(PackedAddU16, General)
-IR_OPCODE(PackedSubU16, General)
-IR_OPCODE(PackedMaxU16, General)
-IR_OPCODE(PackedMinU16, General)
-IR_OPCODE(PackedAddF16, General)
-IR_OPCODE(PackedMulF16, General)
-IR_OPCODE(PackedMinF16, General)
-IR_OPCODE(PackedMaxF16, General)
-IR_OPCODE(PackedFmaF16, General)
-IR_OPCODE(AddF16, General)
-IR_OPCODE(SubF16, General)
-IR_OPCODE(MulF16, General)
-IR_OPCODE(MinF16, General)
-IR_OPCODE(MaxF16, General)
-IR_OPCODE(FmaF16, General)
-IR_OPCODE(MadMixF16, General)
-IR_OPCODE(IAddU16, General)
-IR_OPCODE(ISubI16, General)
-IR_OPCODE(IMinI16, General)
-IR_OPCODE(IMaxI16, General)
-IR_OPCODE(UMinU16, General)
-IR_OPCODE(UMaxU16, General)
-IR_OPCODE(RcpF32, General)
-IR_OPCODE(FractF32, General)
-IR_OPCODE(TruncF32, General)
-IR_OPCODE(CeilF32, General)
-IR_OPCODE(RoundEvenF32, General)
-IR_OPCODE(FloorF32, General)
-IR_OPCODE(Exp2F32, General)
-IR_OPCODE(Log2F32, General)
-IR_OPCODE(InverseSqrtF32, General)
-IR_OPCODE(SqrtF32, General)
-IR_OPCODE(RcpF16, General)
-IR_OPCODE(SqrtF16, General)
-IR_OPCODE(InverseSqrtF16, General)
-IR_OPCODE(Log2F16, General)
-IR_OPCODE(Exp2F16, General)
-IR_OPCODE(FloorF16, General)
-IR_OPCODE(CeilF16, General)
-IR_OPCODE(TruncF16, General)
-IR_OPCODE(RoundEvenF16, General)
-IR_OPCODE(SinF32, General)
-IR_OPCODE(CosF32, General)
-IR_OPCODE(CubeIdF32, General)
-IR_OPCODE(CubeScF32, General)
-IR_OPCODE(CubeTcF32, General)
-IR_OPCODE(CubeMaF32, General)
-IR_OPCODE(FAddF32, General)
-IR_OPCODE(FSubF32, General)
-IR_OPCODE(FMulF32, General)
-IR_OPCODE(FMinF32, General)
-IR_OPCODE(FMaxF32, General)
-IR_OPCODE(FMadF32, General)
-IR_OPCODE(Dot2AccF32F16, General)
-IR_OPCODE(FMin3F32, General)
-IR_OPCODE(FMax3F32, General)
-IR_OPCODE(FMed3F32, General)
-IR_OPCODE(Min3F16, General)
-IR_OPCODE(Max3F16, General)
-IR_OPCODE(Med3F16, General)
-IR_OPCODE(LoadSrtDword, General)
-IR_OPCODE(SLoadDword, General)
-IR_OPCODE(SBufferLoadDword, General)
-IR_OPCODE(BufferLoadUbyte, General)
-IR_OPCODE(BufferLoadSbyte, General)
-IR_OPCODE(BufferLoadUshort, General)
-IR_OPCODE(BufferLoadSshort, General)
-IR_OPCODE(BufferLoadDword, General)
-IR_OPCODE(BufferStoreByte, General)
-IR_OPCODE(BufferStoreShort, General)
-IR_OPCODE(BufferStoreDword, General)
-IR_OPCODE(AtomicSwapU32, General)
-IR_OPCODE(AtomicAddU32, General)
-IR_OPCODE(AtomicSubU32, General)
-IR_OPCODE(AtomicSMinI32, General)
-IR_OPCODE(AtomicUMinU32, General)
-IR_OPCODE(AtomicSMaxI32, General)
-IR_OPCODE(AtomicUMaxU32, General)
-IR_OPCODE(AtomicAndU32, General)
-IR_OPCODE(AtomicOrU32, General)
-IR_OPCODE(AtomicXorU32, General)
-IR_OPCODE(AtomicFMinF32, General)
-IR_OPCODE(AtomicFMaxF32, General)
-IR_OPCODE(FlatLoadUbyte, General)
-IR_OPCODE(FlatLoadSbyte, General)
-IR_OPCODE(FlatLoadUshort, General)
-IR_OPCODE(FlatLoadSshort, General)
-IR_OPCODE(FlatLoadDword, General)
-IR_OPCODE(FlatStoreByte, General)
-IR_OPCODE(FlatStoreShort, General)
-IR_OPCODE(FlatStoreDword, General)
-IR_OPCODE(DsReadUbyte, General)
-IR_OPCODE(DsReadSbyte, General)
-IR_OPCODE(DsReadUshort, General)
-IR_OPCODE(DsReadSshort, General)
-IR_OPCODE(DsReadB32, General)
-IR_OPCODE(DsWriteByte, General)
-IR_OPCODE(DsWriteShort, General)
-IR_OPCODE(DsWriteB32, General)
-IR_OPCODE(DsMinF32, General)
-IR_OPCODE(DsMaxF32, General)
-IR_OPCODE(DsSwizzleB32, General)
-IR_OPCODE(DsConsume, General)
-IR_OPCODE(DsAppend, General)
-IR_OPCODE(DsWriteAddtidB32, General)
-IR_OPCODE(DsReadAddtidB32, General)
-IR_OPCODE(ImageGetResinfo, General)
-IR_OPCODE(ImageGetLod, General)
-IR_OPCODE(ImageLoad, General)
-IR_OPCODE(ImageStore, General)
-IR_OPCODE(ImageSample, General)
-IR_OPCODE(ImageGather4, General)
-IR_OPCODE(LoadInputF32, General)
-IR_OPCODE(Export, General)
@@ -562,7 +562,8 @@ static bool EvaluateRuntimeSourcesImpl(const Program&
 		const auto  dynamic =
 		    std::find(program.srt.dynamic_sources.begin(), program.srt.dynamic_sources.end(),
 		              request.source) != program.srt.dynamic_sources.end();
-		if (descriptor == nullptr || dynamic) {
+		if (descriptor == nullptr || dynamic ||
+		    !DescriptorSourceResolved(program, request.source)) {
 			if (error != nullptr) {
 				*error = Diagnostic(program, request.use_pc,
 				                    fmt::format("descriptor source {} is {}", request.source,
@@ -1,397 +0,0 @@
-#include "graphics/shader/rectListShader.h"
-
-#include "common/assert.h"
-#include "graphics/shader/recompiler/emitter/SpirvBuilder.h"
-#include "graphics/shader/recompiler/ir/ShaderIR.h"
-#include "graphics/shader/shader.h"
-#include "spirv/unified1/spirv.hpp11"
-
-#include <array>
-#include <bit>
-#include <cstdint>
-#include <utility>
-
-namespace Libs::Graphics {
-
-namespace {
-
-using ShaderRecompiler::Spirv::Builder;
-
-constexpr uint32_t SpirvVersion15 = 0x00010500u;
-
-template <typename T>
-constexpr uint32_t Word(T value) {
-	return static_cast<uint32_t>(value);
-}
-
-struct Parameter {
-	uint32_t input_location  = 0;
-	uint32_t output_location = 0;
-	bool     flat            = false;
-};
-
-std::vector<Parameter> GetParameters(const ShaderVertexInputInfo& vertex_info,
-                                     const ShaderPixelInputInfo*  pixel_info) {
-	if (pixel_info == nullptr) {
-		return {};
-	}
-	EXIT_IF(pixel_info->input_num > ShaderVertexInputInfo::RES_MAX);
-	EXIT_IF(pixel_info->stage.program == nullptr);
-
-	std::vector<uint32_t> active_inputs;
-	for (const auto& input: pixel_info->stage.program->info.inputs) {
-		if (input.kind == ShaderRecompiler::IR::StageInputKind::Parameter) {
-			active_inputs.push_back(input.location);
-		}
-	}
-
-	std::vector<Parameter> parameters;
-	for (const auto input: active_inputs) {
-		const auto input_location = ShaderPixelParameterMappedLocation(*pixel_info, input);
-		if ((vertex_info.param_export_mask & (1u << input_location)) != 0) {
-			parameters.push_back({input_location,
-			                      ShaderPixelParameterLocation(*pixel_info, active_inputs, input),
-			                      ShaderPixelParameterIsFlat(*pixel_info, input)});
-		}
-	}
-	return parameters;
-}
-
-class RectListEmitter {
-public:
-	RectListEmitter(const std::vector<Parameter>& parameters_, spv::ExecutionModel model)
-	    : parameters(parameters_) {
-		builder.AddMemoryModel(
-		    {Word(spv::AddressingModel::Logical), Word(spv::MemoryModel::GLSL450)});
-
-		void_type       = Type(spv::Op::OpTypeVoid);
-		uint_type       = Type(spv::Op::OpTypeInt, 32u, 0u);
-		int_type        = Type(spv::Op::OpTypeInt, 32u, 1u);
-		float_type      = Type(spv::Op::OpTypeFloat, 32u);
-		vec4_float_type = Type(spv::Op::OpTypeVector, float_type, 4u);
-		function_type   = Type(spv::Op::OpTypeFunction, void_type);
-
-		per_vertex_type = Type(spv::Op::OpTypeStruct, vec4_float_type);
-		builder.AddAnnotation({Word(spv::Op::OpMemberDecorate), per_vertex_type, 0u,
-		                       Word(spv::Decoration::BuiltIn), Word(spv::BuiltIn::Position)});
-		builder.AddAnnotation(
-		    {Word(spv::Op::OpDecorate), per_vertex_type, Word(spv::Decoration::Block)});
-
-		ptr_input_vec4_float  = Pointer(spv::StorageClass::Input, vec4_float_type);
-		ptr_output_vec4_float = Pointer(spv::StorageClass::Output, vec4_float_type);
-		if (model == spv::ExecutionModel::TessellationControl) {
-			bool_type        = Type(spv::Op::OpTypeBool);
-			vec2_bool_type   = Type(spv::Op::OpTypeVector, bool_type, 2u);
-			vec2_float_type  = Type(spv::Op::OpTypeVector, float_type, 2u);
-			ptr_output_float = Pointer(spv::StorageClass::Output, float_type);
-		} else {
-			vec3_float_type = Type(spv::Op::OpTypeVector, float_type, 3u);
-			ptr_input_float = Pointer(spv::StorageClass::Input, float_type);
-		}
-	}
-
-	std::vector<uint32_t> EmitControl() {
-		DefineEntry(spv::ExecutionModel::TessellationControl);
-		const auto float_one = Constant(float_type, std::bit_cast<uint32_t>(1.0f));
-
-		for (uint32_t i = 0; i < 4; i++) {
-			Store(Access(ptr_output_float, tess_outer, Int(i)), float_one);
-		}
-		for (uint32_t i = 0; i < 2; i++) {
-			Store(Access(ptr_output_float, tess_inner, Int(i)), float_one);
-		}
-
-		std::array<uint32_t, 3> positions {};
-		for (uint32_t i = 0; i < positions.size(); i++) {
-			positions[i] =
-			    Load(vec4_float_type, Access(ptr_input_vec4_float, gl_in, Int(i), Int(0)));
-		}
-
-		std::array<uint32_t, 3> coordinate_equal {};
-		for (uint32_t i = 0; i < coordinate_equal.size(); i++) {
-			const auto left  = Result(spv::Op::OpVectorShuffle, vec2_float_type, positions[i],
-			                          positions[i], 0u, 1u);
-			const auto right = Result(spv::Op::OpVectorShuffle, vec2_float_type,
-			                          positions[(i + 1u) % 3u], positions[(i + 1u) % 3u], 0u, 1u);
-			coordinate_equal[i] = Result(spv::Op::OpFOrdEqual, vec2_bool_type, left, right);
-		}
-
-		std::array<uint32_t, 3> barycentric {};
-		std::array<uint32_t, 3> edge_vertex {};
-		const auto float_minus_one = Constant(float_type, std::bit_cast<uint32_t>(-1.0f));
-		for (uint32_t i = 0; i < edge_vertex.size(); i++) {
-			const auto previous = (i + 2u) % 3u;
-			const auto xy       = Result(
-			    spv::Op::OpLogicalAnd, bool_type,
-			    Result(spv::Op::OpCompositeExtract, bool_type, coordinate_equal[i], 0u),
-			    Result(spv::Op::OpCompositeExtract, bool_type, coordinate_equal[previous], 1u));
-			const auto yx = Result(
-			    spv::Op::OpLogicalAnd, bool_type,
-			    Result(spv::Op::OpCompositeExtract, bool_type, coordinate_equal[i], 1u),
-			    Result(spv::Op::OpCompositeExtract, bool_type, coordinate_equal[previous], 0u));
-			edge_vertex[i] = Result(spv::Op::OpLogicalOr, bool_type, xy, yx);
-			barycentric[i] =
-			    Result(spv::Op::OpSelect, float_type, edge_vertex[i], float_minus_one, float_one);
-		}
-
-		auto vertex_index = Result(spv::Op::OpSelect, int_type, edge_vertex[2], Int(2), Int(0));
-		vertex_index = Result(spv::Op::OpSelect, int_type, edge_vertex[1], Int(1), vertex_index);
-		const auto invocation = Load(int_type, invocation_id);
-		const auto is_fourth  = Result(spv::Op::OpIEqual, bool_type, invocation, Int(3));
-		const auto index =
-		    Result(spv::Op::OpSMod, int_type,
-		           Result(spv::Op::OpIAdd, int_type, vertex_index, invocation), Int(3));
-
-		const auto position3 = Interpolate(positions[0], positions[1], positions[2], barycentric);
-		const auto position =
-		    Result(spv::Op::OpSelect, vec4_float_type, is_fourth, position3,
-		           Load(vec4_float_type, Access(ptr_input_vec4_float, gl_in, index, Int(0))));
-		Store(Access(ptr_output_vec4_float, gl_out, invocation, Int(0)), position);
-
-		for (uint32_t i = 0; i < parameters.size(); i++) {
-			const auto input0 =
-			    Load(vec4_float_type, Access(ptr_input_vec4_float, inputs[i], Int(0)));
-			if (parameters[i].flat) {
-				Store(Access(ptr_output_vec4_float, outputs[i], invocation), input0);
-				continue;
-			}
-			const auto input1 =
-			    Load(vec4_float_type, Access(ptr_input_vec4_float, inputs[i], Int(1)));
-			const auto input2 =
-			    Load(vec4_float_type, Access(ptr_input_vec4_float, inputs[i], Int(2)));
-			const auto input3 = Interpolate(input0, input1, input2, barycentric);
-			const auto value =
-			    Result(spv::Op::OpSelect, vec4_float_type, is_fourth, input3,
-			           Load(vec4_float_type, Access(ptr_input_vec4_float, inputs[i], index)));
-			Store(Access(ptr_output_vec4_float, outputs[i], invocation), value);
-		}
-
-		Emit(spv::Op::OpReturn);
-		Emit(spv::Op::OpFunctionEnd);
-		return builder.Build();
-	}
-
-	std::vector<uint32_t> EmitEvaluation() {
-		DefineEntry(spv::ExecutionModel::TessellationEvaluation);
-
-		const auto x     = Load(float_type, Access(ptr_input_float, tess_coord, Int(0)));
-		const auto y     = Load(float_type, Access(ptr_input_float, tess_coord, Int(1)));
-		const auto index = Result(
-		    spv::Op::OpIAdd, int_type,
-		    Result(spv::Op::OpIMul, int_type, Result(spv::Op::OpConvertFToS, int_type, y), Int(2)),
-		    Result(spv::Op::OpConvertFToS, int_type, x));
-
-		const auto position =
-		    Load(vec4_float_type, Access(ptr_input_vec4_float, gl_in, index, Int(0)));
-		Store(Access(ptr_output_vec4_float, gl_out, Int(0)), position);
-		for (uint32_t i = 0; i < parameters.size(); i++) {
-			Store(outputs[i],
-			      Load(vec4_float_type, Access(ptr_input_vec4_float, inputs[i], index)));
-		}
-
-		Emit(spv::Op::OpReturn);
-		Emit(spv::Op::OpFunctionEnd);
-		return builder.Build();
-	}
-
-private:
-	template <typename... Args>
-	uint32_t Type(spv::Op opcode, Args... operands) {
-		const auto id = builder.AllocateId();
-		builder.AddType({Word(opcode), id, Word(operands)...});
-		return id;
-	}
-
-	uint32_t Constant(uint32_t type, uint32_t value) {
-		const auto id = builder.AllocateId();
-		builder.AddType({Word(spv::Op::OpConstant), type, id, value});
-		return id;
-	}
-
-	uint32_t Pointer(spv::StorageClass storage, uint32_t type) {
-		return Type(spv::Op::OpTypePointer, storage, type);
-	}
-
-	uint32_t Array(uint32_t type, uint32_t size) {
-		return Type(spv::Op::OpTypeArray, type, Uint(size));
-	}
-
-	template <typename... Args>
-	uint32_t Result(spv::Op opcode, uint32_t type, Args... operands) {
-		const auto id = builder.AllocateId();
-		builder.AddFunction({Word(opcode), type, id, Word(operands)...});
-		return id;
-	}
-
-	template <typename... Args>
-	uint32_t ResultWithoutType(spv::Op opcode, Args... operands) {
-		const auto id = builder.AllocateId();
-		builder.AddFunction({Word(opcode), id, Word(operands)...});
-		return id;
-	}
-
-	template <typename... Args>
-	void Emit(spv::Op opcode, Args... operands) {
-		builder.AddFunction({Word(opcode), Word(operands)...});
-	}
-
-	template <typename... Args>
-	uint32_t Access(uint32_t pointer_type, uint32_t base, Args... indices) {
-		return Result(spv::Op::OpAccessChain, pointer_type, base, Word(indices)...);
-	}
-
-	uint32_t Load(uint32_t type, uint32_t pointer) {
-		return Result(spv::Op::OpLoad, type, pointer);
-	}
-
-	void Store(uint32_t pointer, uint32_t value) { Emit(spv::Op::OpStore, pointer, value); }
-
-	uint32_t Int(uint32_t value) {
-		auto& id = int_constants[value];
-		if (id == 0) {
-			id = Constant(int_type, value);
-		}
-		return id;
-	}
-
-	uint32_t Uint(uint32_t value) {
-		auto& id = uint_constants[value];
-		if (id == 0) {
-			id = Constant(uint_type, value);
-		}
-		return id;
-	}
-
-	uint32_t AddInterface(spv::StorageClass storage, uint32_t type) {
-		const auto variable = builder.AllocateId();
-		builder.AddType(
-		    {Word(spv::Op::OpVariable), Pointer(storage, type), variable, Word(storage)});
-		interfaces.push_back(variable);
-		return variable;
-	}
-
-	void Decorate(uint32_t target, spv::Decoration decoration, uint32_t value) {
-		builder.AddAnnotation({Word(spv::Op::OpDecorate), target, Word(decoration), value});
-	}
-
-	void DefineEntry(spv::ExecutionModel model) {
-		builder.AddCapability({Word(spv::Capability::Shader)});
-		builder.AddCapability({Word(spv::Capability::Tessellation)});
-		main = Result(spv::Op::OpFunction, void_type, spv::FunctionControlMask::MaskNone,
-		              function_type);
-		if (model == spv::ExecutionModel::TessellationControl) {
-			builder.AddExecutionMode({main, Word(spv::ExecutionMode::OutputVertices), 4u});
-		} else {
-			builder.AddExecutionMode({main, Word(spv::ExecutionMode::Quads)});
-			builder.AddExecutionMode({main, Word(spv::ExecutionMode::SpacingEqual)});
-			builder.AddExecutionMode({main, Word(spv::ExecutionMode::VertexOrderCw)});
-		}
-		DefineInputs(model);
-		DefineOutputs(model);
-		builder.AddEntryPoint(Word(model), main, "main", interfaces);
-		ResultWithoutType(spv::Op::OpLabel);
-	}
-
-	void DefineInputs(spv::ExecutionModel model) {
-		const auto tess_control = model == spv::ExecutionModel::TessellationControl;
-		if (tess_control) {
-			invocation_id = AddInterface(spv::StorageClass::Input, int_type);
-			Decorate(invocation_id, spv::Decoration::BuiltIn, Word(spv::BuiltIn::InvocationId));
-		} else {
-			tess_coord = AddInterface(spv::StorageClass::Input, vec3_float_type);
-			Decorate(tess_coord, spv::Decoration::BuiltIn, Word(spv::BuiltIn::TessCoord));
-		}
-		gl_in =
-		    AddInterface(spv::StorageClass::Input, Array(per_vertex_type, tess_control ? 3u : 4u));
-
-		inputs.resize(parameters.size());
-		std::array<uint32_t, ShaderVertexInputInfo::RES_MAX> locations {};
-		for (uint32_t i = 0; i < parameters.size(); i++) {
-			const auto location =
-			    tess_control ? parameters[i].input_location : parameters[i].output_location;
-			if (tess_control && locations[location] != 0) {
-				inputs[i] = locations[location];
-				continue;
-			}
-			inputs[i] = AddInterface(spv::StorageClass::Input,
-			                         Array(vec4_float_type, tess_control ? 3u : 4u));
-			Decorate(inputs[i], spv::Decoration::Location, location);
-			locations[location] = inputs[i];
-		}
-	}
-
-	void DefineOutputs(spv::ExecutionModel model) {
-		const auto tess_control = model == spv::ExecutionModel::TessellationControl;
-		if (tess_control) {
-			gl_out     = AddInterface(spv::StorageClass::Output, Array(per_vertex_type, 4u));
-			tess_inner = AddInterface(spv::StorageClass::Output, Array(float_type, 2u));
-			Decorate(tess_inner, spv::Decoration::BuiltIn, Word(spv::BuiltIn::TessLevelInner));
-			builder.AddAnnotation(
-			    {Word(spv::Op::OpDecorate), tess_inner, Word(spv::Decoration::Patch)});
-			tess_outer = AddInterface(spv::StorageClass::Output, Array(float_type, 4u));
-			Decorate(tess_outer, spv::Decoration::BuiltIn, Word(spv::BuiltIn::TessLevelOuter));
-			builder.AddAnnotation(
-			    {Word(spv::Op::OpDecorate), tess_outer, Word(spv::Decoration::Patch)});
-		} else {
-			gl_out = AddInterface(spv::StorageClass::Output, per_vertex_type);
-		}
-
-		outputs.resize(parameters.size());
-		for (uint32_t i = 0; i < parameters.size(); i++) {
-			outputs[i] = AddInterface(spv::StorageClass::Output,
-			                          tess_control ? Array(vec4_float_type, 4u) : vec4_float_type);
-			Decorate(outputs[i], spv::Decoration::Location, parameters[i].output_location);
-		}
-	}
-
-	uint32_t Interpolate(uint32_t v0, uint32_t v1, uint32_t v2,
-	                     const std::array<uint32_t, 3>& barycentric) {
-		const auto p0 = Result(spv::Op::OpVectorTimesScalar, vec4_float_type, v0, barycentric[0]);
-		const auto p1 = Result(spv::Op::OpVectorTimesScalar, vec4_float_type, v1, barycentric[1]);
-		const auto p2 = Result(spv::Op::OpVectorTimesScalar, vec4_float_type, v2, barycentric[2]);
-		return Result(spv::Op::OpFAdd, vec4_float_type, p0,
-		              Result(spv::Op::OpFAdd, vec4_float_type, p1, p2));
-	}
-
-	Builder                       builder {SpirvVersion15};
-	const std::vector<Parameter>& parameters;
-	std::vector<uint32_t>         interfaces;
-	std::vector<uint32_t>         inputs;
-	std::vector<uint32_t>         outputs;
-	std::array<uint32_t, 5>       int_constants {};
-	std::array<uint32_t, 5>       uint_constants {};
-	uint32_t                      main                  = 0;
-	uint32_t                      void_type             = 0;
-	uint32_t                      bool_type             = 0;
-	uint32_t                      uint_type             = 0;
-	uint32_t                      int_type              = 0;
-	uint32_t                      float_type            = 0;
-	uint32_t                      vec2_bool_type        = 0;
-	uint32_t                      vec2_float_type       = 0;
-	uint32_t                      vec3_float_type       = 0;
-	uint32_t                      vec4_float_type       = 0;
-	uint32_t                      function_type         = 0;
-	uint32_t                      per_vertex_type       = 0;
-	uint32_t                      ptr_input_float       = 0;
-	uint32_t                      ptr_input_vec4_float  = 0;
-	uint32_t                      ptr_output_float      = 0;
-	uint32_t                      ptr_output_vec4_float = 0;
-	uint32_t                      gl_in                 = 0;
-	uint32_t                      gl_out                = 0;
-	uint32_t                      tess_inner            = 0;
-	uint32_t                      tess_outer            = 0;
-	uint32_t                      tess_coord            = 0;
-	uint32_t                      invocation_id         = 0;
-};
-
-} // namespace
-
-RectListShaders BuildRectListShaders(const ShaderVertexInputInfo& vertex_info,
-                                     const ShaderPixelInputInfo*  pixel_info) {
-	const auto      parameters = GetParameters(vertex_info, pixel_info);
-	RectListEmitter control(parameters, spv::ExecutionModel::TessellationControl);
-	RectListEmitter evaluation(parameters, spv::ExecutionModel::TessellationEvaluation);
-	return {control.EmitControl(), evaluation.EmitEvaluation()};
-}
-
-} // namespace Libs::Graphics
@@ -1,22 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_SHADER_RECTLISTSHADER_H_
-#define EMULATOR_SRC_GRAPHICS_SHADER_RECTLISTSHADER_H_
-
-#include <cstdint>
-#include <vector>
-
-namespace Libs::Graphics {
-
-struct ShaderPixelInputInfo;
-struct ShaderVertexInputInfo;
-
-struct RectListShaders {
-	std::vector<uint32_t> control;
-	std::vector<uint32_t> evaluation;
-};
-
-RectListShaders BuildRectListShaders(const ShaderVertexInputInfo& vertex_info,
-                                     const ShaderPixelInputInfo*  pixel_info);
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_SHADER_RECTLISTSHADER_H_
Author	SHA1	Message	Date
nmzik	83152c8cad	guest_gpu: remove memory-unmap submission deadlock + remove legacy agc buffering	2026-08-02 13:17:53 +02:00
nmzik	35a89d616a	implement dynamic	2026-08-02 10:50:28 +02:00