input: PC-style DualSense mouse/keyboard mapping (#213)

input: add mouse-to-right-stick mapping and sensitivity

Co-authored-by: nmzik <Nmzik@mail.ru>

.github/workflows/build.yml

@@ -208,34 +208,66 @@ jobs:
         run: |
           archive="$RUNNER_TEMP/MoltenVK-macos.tar"
           package="$RUNNER_TEMP/MoltenVK"
+          install_dir="_Build/macos/install"
+          app_dir="$install_dir/KytyPS5.app"
+          moltenvk="$install_dir/libMoltenVK.dylib"
           curl --fail --location --retry 3 \
             --output "$archive" \
             "https://github.com/KhronosGroup/MoltenVK/releases/download/$MOLTENVK_VERSION/MoltenVK-macos.tar"
           echo "$MOLTENVK_SHA256  $archive" | shasum -a 256 --check
           tar -xf "$archive" -C "$RUNNER_TEMP"
+          test -d "$app_dir"
           install -m 755 \
             "$package/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" \
-            _Build/macos/install/libMoltenVK.dylib
-          install -m 644 "$package/LICENSE" _Build/macos/install/LICENSE.MoltenVK
-          codesign --force --sign - --timestamp=none _Build/macos/install/libMoltenVK.dylib
+            "$moltenvk"
+          install -m 644 "$package/LICENSE" "$install_dir/LICENSE.MoltenVK"
+          codesign --force --sign - --timestamp=none "$moltenvk"
+          install -d -m 755 "$app_dir/Contents/Frameworks" "$app_dir/Contents/Resources"
+          install -m 755 "$moltenvk" "$app_dir/Contents/Frameworks/libMoltenVK.dylib"
+          install -m 644 "$package/LICENSE" "$app_dir/Contents/Resources/LICENSE.MoltenVK"
+          codesign --force --sign - --timestamp=none "$app_dir"
 
       - name: Verify artifacts
         shell: bash
         run: |
-          file _Build/macos/install/launcher
-          file _Build/macos/install/kyty_emulator
-          file _Build/macos/install/libMoltenVK.dylib
-          lipo _Build/macos/install/launcher -verify_arch x86_64
-          lipo _Build/macos/install/kyty_emulator -verify_arch x86_64
-          lipo _Build/macos/install/libMoltenVK.dylib -verify_arch x86_64
-          codesign --verify --strict _Build/macos/install/kyty_emulator
-          codesign --verify --strict _Build/macos/install/libMoltenVK.dylib
+          install_dir="_Build/macos/install"
+          app_dir="$install_dir/KytyPS5.app"
+          test -d "$app_dir"
+          for binary in \
+            "$install_dir/kyty_emulator" \
+            "$install_dir/libMoltenVK.dylib" \
+            "$app_dir/Contents/MacOS/KytyPS5" \
+            "$app_dir/Contents/MacOS/kyty_emulator" \
+            "$app_dir/Contents/Frameworks/libMoltenVK.dylib"; do
+            file "$binary"
+            lipo "$binary" -verify_arch x86_64
+          done
+          for binary in \
+            "$install_dir/kyty_emulator" \
+            "$install_dir/libMoltenVK.dylib" \
+            "$app_dir/Contents/MacOS/KytyPS5" \
+            "$app_dir/Contents/MacOS/kyty_emulator" \
+            "$app_dir/Contents/Frameworks/libMoltenVK.dylib"; do
+            codesign --verify --strict "$binary"
+          done
+          codesign --verify --deep --strict --verbose=2 "$app_dir"
+
+      - name: Package macOS artifacts
+        shell: bash
+        run: |
+          install_dir="_Build/macos/install"
+          archive="$RUNNER_TEMP/KytyPS5-macOS-x86_64.zip"
+          (
+            cd "$install_dir"
+            zip -qry "$archive" .
+          )
+          unzip -t "$archive"
 
       - name: Upload macOS artifacts
         uses: actions/upload-artifact@v4
         with:
           name: KytyPS5-macOS-x86_64
-          path: _Build/macos/install/**
+          path: ${{ runner.temp }}/KytyPS5-macOS-x86_64.zip
           if-no-files-found: error
 
   linux:
@@ -424,16 +456,9 @@ jobs:
         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" .
-          )
+          macos_archive="artifacts/KytyPS5-macOS-x86_64/KytyPS5-macOS-x86_64.zip"
+          test -f "$macos_archive"
+          cp "$macos_archive" "$RELEASE_NAME-macOS-x86_64.zip"
 
       - name: Package Linux build
         if: needs.linux.result == 'success'

.gitignore

@@ -5,3 +5,4 @@ build/
 _Build/vscode-clang/
 _Build/
 cmake-build-debug/
+_PipelineCache/

README.md

@@ -220,17 +220,23 @@ cmake --install _Build/macos --prefix _Build/macos/install
 ```
 
 The build re-signs `kyty_emulator` with the JIT entitlements it needs to execute translated
-guest code; no manual signing step is required.
+guest code; no manual signing step is required. When the launcher is built, the install
+also produces `_Build/macos/install/KytyPS5.app` — double-click to launch the GUI.
+A flat `kyty_emulator` is kept for CLI usage.
 
 Vulkan comes from MoltenVK. Download `MoltenVK-macos.tar` from the
 [MoltenVK releases](https://github.com/KhronosGroup/MoltenVK/releases), then copy
-`MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib` next to `kyty_emulator` and ad-hoc sign it:
+`MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib` next to the flat `kyty_emulator`
+(and, for the bundle, into `KytyPS5.app/Contents/Frameworks/`) and ad-hoc sign it:
 
 ```bash
 codesign --force --sign - _Build/macos/install/libMoltenVK.dylib
+# For the bundle (if present):
+codesign --force --sign - _Build/macos/install/KytyPS5.app/Contents/Frameworks/libMoltenVK.dylib
+codesign --force --sign - _Build/macos/install/KytyPS5.app
 ```
 
-Release archives already include a signed `libMoltenVK.dylib`.
+Release archives already include a signed `libMoltenVK.dylib` (both flat and inside the bundle).
 
 ### Regression tests
 
@@ -274,6 +280,10 @@ To use the graphical launcher:
 ./_Build/linux/install/launcher
 ```
 
+```bash
+open _Build/macos/install/KytyPS5.app  # or double-click in Finder
+```
+
 On first launch, add one or more game folders in the global settings. The launcher searches those
 folders recursively for game directories containing `eboot.bin`. Select a detected game and run it
 from the game list.
@@ -288,12 +298,17 @@ The emulator can also be started directly with a legally obtained game directory
 ./_Build/linux/install/kyty_emulator --game "/games/ExampleGame"
 ```
 
-On macOS, point SDL at the MoltenVK library explicitly; the hardened runtime prevents it from
-being picked up from the executable's directory:
+On macOS, the adjacent flat or app-bundled `libMoltenVK.dylib` is found automatically; no
+environment variable is required:
 
 ```bash
-cd _Build/macos/install
-SDL_VULKAN_LIBRARY="$PWD/libMoltenVK.dylib" ./kyty_emulator --game "/games/ExampleGame"
+./_Build/macos/install/kyty_emulator --game "/games/ExampleGame"
+```
+
+To override the Vulkan loader, set `SDL_VULKAN_LIBRARY`:
+
+```bash
+SDL_VULKAN_LIBRARY=/path/to/libMoltenVK.dylib ./kyty_emulator --game "/games/ExampleGame"
 ```
 
 Run `kyty_emulator --help` to see the available graphics, logging, validation, profiling, and

src/common/emulatorConfig.h

@@ -59,7 +59,7 @@ struct ConfigOptions {
 	bool                   command_buffer_dump_enabled = false;
 	std::filesystem::path  command_buffer_dump_folder  = "_Buffers";
 	bool                   graphics_debug_dump_enabled = false;
-	OutputDirection        printf_direction            = OutputDirection::Console;
+	OutputDirection        printf_direction            = OutputDirection::Silent;
 	std::filesystem::path  printf_output_file          = "_kyty.txt";
 	ProfilerDirection      profiler_direction          = ProfilerDirection::None;
 	bool                   spirv_debug_printf_enabled  = false;

src/common/file.cpp

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

src/common/file.h

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

src/common/platform/sysFileIO.h

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

src/common/platform/sysLinuxFileIO.cpp

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

src/common/platform/sysWindowsFileIO.cpp

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

src/generate_version.cmake

@@ -1,5 +1,6 @@
 set(KYTY_GIT_VERSION "unknown")
 set(KYTY_GIT_HASH "unknown")
+set(KYTY_GIT_REVISION "unknown")
 if(GIT_EXECUTABLE)
 	execute_process(
 		COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty
@@ -14,16 +15,18 @@ if(GIT_EXECUTABLE)
 	endif()
 
 	execute_process(
-		COMMAND "${GIT_EXECUTABLE}" rev-parse --short=7 HEAD
+		COMMAND "${GIT_EXECUTABLE}" rev-parse HEAD
 		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
-		OUTPUT_VARIABLE KYTY_GIT_HASH
+		OUTPUT_VARIABLE KYTY_GIT_REVISION
 		OUTPUT_STRIP_TRAILING_WHITESPACE
 		RESULT_VARIABLE GIT_HASH_RESULT
 		ERROR_QUIET
 	)
 	if(NOT GIT_HASH_RESULT EQUAL 0)
 		set(KYTY_GIT_HASH "unknown")
+		set(KYTY_GIT_REVISION "unknown")
 	else()
+		string(SUBSTRING "${KYTY_GIT_REVISION}" 0 7 KYTY_GIT_HASH)
 		execute_process(
 			COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
 			WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"

src/graphics/host_gpu/renderer/colorRenderTarget.cpp

@@ -219,8 +219,9 @@ void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, CommandBuffer&
 		     rt.attrib.num_fragments, bytes_per_element, rt.cmask.addr, rt.fmask.addr,
 		     rt.dcc_addr.addr);
 	}
-	if ((standard64 || depth_tile) && (rt.attrib3.dimension != 1 || rt.attrib3.depth != 0 ||
-	                                   view.base_layer != 0 || view.image_layers != 1)) {
+	if ((standard64 || depth_tile) &&
+	    (rt.attrib3.dimension != 1 || rt.attrib3.depth != 0 ||
+	     (depth_tile && (view.base_layer != 0 || view.image_layers != 1)))) {
 		EXIT("unsupported 64KB texture-tiled render-target view: dimension=%u depth=%u"
 		     " layer=%u/%u\n",
 		     rt.attrib3.dimension, rt.attrib3.depth, view.base_layer, view.image_layers);

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

@@ -1,6 +1,7 @@
 #include "graphics/host_gpu/renderer/pipeline/pipelineCache.h"
 
 #include "common/assert.h"
+#include "common/file.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
 #include "graphics/guest_gpu/hardwareContext.h"
@@ -11,18 +12,64 @@
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/shader/shaderCompiler.h"
+#include "kytyGitVersion.h"
+#include "loader/systemContent.h"
 
+#include <algorithm>
 #include <atomic>
+#include <cctype>
 #include <cstdio>
 #include <cstring>
+#include <limits>
 #include <span>
+#include <string_view>
 #include <utility>
 #include <vector>
 
+#include <fmt/format.h>
+#include <xxhash.h>
+
 namespace Libs::Graphics {
 
 namespace {
 
+std::string DriverCacheSignature(const vk::PhysicalDeviceProperties& properties) {
+	constexpr char hex[] = "0123456789abcdef";
+	std::string    uuid(VK_UUID_SIZE * 2, '0');
+	for (size_t i = 0; i < VK_UUID_SIZE; i++) {
+		uuid[i * 2]     = hex[properties.pipelineCacheUUID[i] >> 4u];
+		uuid[i * 2 + 1] = hex[properties.pipelineCacheUUID[i] & 0xfu];
+	}
+	return fmt::format("KytyPC1:{}:{:08x}:{:08x}:{:08x}:{}\n", KYTY_GIT_REVISION,
+	                   properties.vendorID, properties.deviceID, properties.driverVersion, uuid);
+}
+
+std::string PipelineCacheTitleId() {
+	std::string title_id;
+	if ((!Loader::SystemContentParamSfoGetString("TITLE_ID", &title_id) || title_id.empty()) &&
+	    (!Loader::SystemContentParamSfoGetString("CONTENT_ID", &title_id) || title_id.empty())) {
+		return {};
+	}
+	if (!std::ranges::all_of(title_id, [](unsigned char c) {
+		    return std::isalnum(c) != 0 || c == '-' || c == '_';
+	    })) {
+		return {};
+	}
+	return title_id;
+}
+
+template <typename... Args>
+void PipelineCacheLog(fmt::format_string<Args...> format, Args&&... args) {
+	auto message = fmt::format(format, std::forward<Args>(args)...);
+	message += '\n';
+	if (Log::GetDirection() != Log::Direction::Console) {
+		std::fwrite(message.data(), 1, message.size(), stdout);
+		std::fflush(stdout);
+	}
+	Log::Write(message);
+	Log::Flush();
+}
+
 void NormalizeStaticParamsForDynamicState(PipelineStaticParameters& static_params) {
 	static_params.viewport_scale[0]  = 0.5f;
 	static_params.viewport_scale[1]  = 0.5f;
@@ -119,9 +166,11 @@ struct PipelineCache::ProgramCache {
 PipelineCache::PipelineCache(GraphicContext& graphics)
     : m_graphics(graphics), m_program_cache(std::make_unique<ProgramCache>(graphics.device)) {
 	EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
+	InitializeDriverCache();
 }
 
 PipelineCache::~PipelineCache() {
+	Save();
 	auto destroy = [this](const auto& pipelines) {
 		for (const auto& [key, pipeline]: pipelines) {
 			(void)key;
@@ -138,6 +187,155 @@ PipelineCache::~PipelineCache() {
 			m_graphics.device.destroyShaderModule(permutation.handle.module, nullptr);
 		}
 	}
+	if (m_driver_cache != nullptr) {
+		m_graphics.device.destroyPipelineCache(m_driver_cache, nullptr);
+	}
+}
+
+void PipelineCache::InitializeDriverCache() {
+	const auto title_id = PipelineCacheTitleId();
+	if (title_id.empty()) {
+		return;
+	}
+	if (KYTY_BUILD != KYTY_BUILD_RELEASE) {
+		PipelineCacheLog("Vulkan pipeline cache: disabled (non-Release build)");
+		return;
+	}
+	const std::string_view git_hash     = KYTY_GIT_HASH;
+	const std::string_view git_revision = KYTY_GIT_REVISION;
+	if (git_hash == "unknown" || git_revision == "unknown") {
+		PipelineCacheLog("Vulkan pipeline cache: disabled (unknown git revision)");
+		return;
+	}
+	if (git_hash.ends_with("-dirty")) {
+		PipelineCacheLog("Vulkan pipeline cache: disabled (dirty build)");
+		return;
+	}
+
+	m_driver_cache_path = std::filesystem::path("_PipelineCache") / (title_id + ".bin");
+	const auto path         = Common::PathToString(m_driver_cache_path);
+	const bool cache_exists = Common::File::IsFileExisting(m_driver_cache_path);
+	if (cache_exists) {
+		PipelineCacheLog("Vulkan pipeline cache: loading {}", path);
+	} else {
+		PipelineCacheLog("Vulkan pipeline cache: initializing {}", path);
+	}
+	std::vector<uint8_t> initial_data;
+	if (cache_exists) {
+		Common::File file(m_driver_cache_path, Common::File::Mode::Read);
+		const auto   file_size = file.IsInvalid() ? 0 : file.Size();
+		const auto signature = DriverCacheSignature(m_graphics.GetPhysicalDeviceProperties());
+		if (file_size >= signature.size() + sizeof(uint64_t) &&
+		    file_size <= std::numeric_limits<uint32_t>::max()) {
+			std::string cached_signature(signature.size(), '\0');
+			uint64_t    payload_hash = 0;
+			initial_data.resize(file_size - signature.size() - sizeof(payload_hash));
+			uint32_t signature_read = 0;
+			uint32_t hash_read      = 0;
+			uint32_t payload_read   = 0;
+			file.Read(cached_signature.data(), static_cast<uint32_t>(cached_signature.size()),
+			          &signature_read);
+			file.Read(&payload_hash, sizeof(payload_hash), &hash_read);
+			file.Read(initial_data.data(), static_cast<uint32_t>(initial_data.size()), &payload_read);
+			file.Close();
+			if (signature_read != cached_signature.size() || hash_read != sizeof(payload_hash) ||
+			    payload_read != initial_data.size() || cached_signature != signature ||
+			    XXH3_64bits(initial_data.data(), initial_data.size()) != payload_hash) {
+				initial_data.clear();
+				PipelineCacheLog(
+				    "Vulkan pipeline cache: invalidating {} (driver, emulator, or data mismatch)",
+				    path);
+			}
+		} else {
+			file.Close();
+			PipelineCacheLog("Vulkan pipeline cache: invalidating {} (invalid file size)",
+			                 path);
+		}
+	}
+
+	vk::PipelineCacheCreateInfo create {};
+	create.sType           = vk::StructureType::ePipelineCacheCreateInfo;
+	create.initialDataSize = initial_data.size();
+	create.pInitialData    = initial_data.empty() ? nullptr : initial_data.data();
+	auto result = m_graphics.device.createPipelineCache(&create, nullptr, &m_driver_cache);
+	if (result != vk::Result::eSuccess && !initial_data.empty()) {
+		PipelineCacheLog("Vulkan pipeline cache: driver rejected {} ({}); starting empty", path,
+		                 VulkanToString(result));
+		initial_data.clear();
+		create.initialDataSize = 0;
+		create.pInitialData    = nullptr;
+		result = m_graphics.device.createPipelineCache(&create, nullptr, &m_driver_cache);
+	}
+	if (result != vk::Result::eSuccess) {
+		PipelineCacheLog("Vulkan pipeline cache: disabled ({})", VulkanToString(result));
+		m_driver_cache = nullptr;
+		return;
+	}
+	if (!initial_data.empty()) {
+		PipelineCacheLog("Vulkan pipeline cache: loaded {} bytes from {}", initial_data.size(),
+		                 path);
+	} else {
+		PipelineCacheLog("Vulkan pipeline cache: initialized empty");
+	}
+}
+
+void PipelineCache::Save() {
+	Common::LockGuard lock(m_mutex);
+	if (m_driver_cache == nullptr) {
+		return;
+	}
+
+	size_t               size = 0;
+	vk::Result           result;
+	std::vector<uint8_t> payload;
+	for (uint32_t attempt = 0; attempt < 3; attempt++) {
+		size   = 0;
+		result = m_graphics.device.getPipelineCacheData(m_driver_cache, &size, nullptr);
+		if (result != vk::Result::eSuccess || size == 0 ||
+		    size > std::numeric_limits<uint32_t>::max()) {
+			break;
+		}
+		payload.resize(size);
+		result = m_graphics.device.getPipelineCacheData(m_driver_cache, &size, payload.data());
+		if (result != vk::Result::eIncomplete) {
+			break;
+		}
+	}
+	if (result != vk::Result::eSuccess || size == 0 ||
+	    size > std::numeric_limits<uint32_t>::max()) {
+		PipelineCacheLog("Vulkan pipeline cache: save failed ({}, {} bytes)",
+		                 VulkanToString(result), size);
+		return;
+	}
+	payload.resize(size);
+	auto prefix = DriverCacheSignature(m_graphics.GetPhysicalDeviceProperties());
+	const auto payload_hash = XXH3_64bits(payload.data(), payload.size());
+	prefix.append(reinterpret_cast<const char*>(&payload_hash), sizeof(payload_hash));
+	if (!Common::File::CreateDirectories(m_driver_cache_path.parent_path())) {
+		PipelineCacheLog("Vulkan pipeline cache: failed to create cache directory");
+		return;
+	}
+	auto temp_path = m_driver_cache_path;
+	temp_path += ".tmp";
+	Common::File file;
+	uint32_t     prefix_written  = 0;
+	uint32_t     payload_written = 0;
+	if (file.Create(temp_path)) {
+		file.Write(prefix.data(), static_cast<uint32_t>(prefix.size()), &prefix_written);
+		file.Write(payload.data(), static_cast<uint32_t>(payload.size()), &payload_written);
+	}
+	const bool flushed = !file.IsInvalid() && file.Flush();
+	file.Close();
+	if (prefix_written != prefix.size() || payload_written != payload.size() || !flushed ||
+	    !Common::File::RenameFile(temp_path, m_driver_cache_path)) {
+		PipelineCacheLog("Vulkan pipeline cache: failed to write {}",
+		                 Common::PathToString(m_driver_cache_path));
+		return;
+	}
+	PipelineCacheLog("Vulkan pipeline cache: saved {} bytes to {}", payload.size(),
+	                 Common::PathToString(m_driver_cache_path));
+	m_graphics.device.destroyPipelineCache(m_driver_cache, nullptr);
+	m_driver_cache = nullptr;
 }
 
 ShaderProgram PipelineCache::GetVertexProgram(const HW::VertexShaderInfo& regs,
@@ -324,7 +522,7 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 	auto cached = std::make_unique<GraphicsPipeline>(p);
 	LogPipelineTrace("CreatePipelineInternal begin", vs_id, ps_id);
 	CreatePipelineInternal(m_graphics, *cached, rendering, vs_input_info, vertex_program.module,
-	                       ps_input_info, pixel_program.module, static_params);
+	                       ps_input_info, pixel_program.module, static_params, m_driver_cache);
 	LogPipelineTrace("CreatePipelineInternal done", vs_id, ps_id);
 
 	EXIT_NOT_IMPLEMENTED(cached->pipeline == nullptr);
@@ -360,7 +558,7 @@ PipelineCache::CreateComputePipeline(ShaderComputeInputInfo& input_info,
 	}
 
 	auto cached = std::make_unique<ComputePipeline>(p);
-	CreatePipelineInternal(m_graphics, *cached, input_info, compute_program.module);
+	CreatePipelineInternal(m_graphics, *cached, input_info, compute_program.module, m_driver_cache);
 
 	EXIT_NOT_IMPLEMENTED(cached->pipeline == nullptr);
 	EXIT_NOT_IMPLEMENTED(cached->pipeline_layout == nullptr);

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

@@ -10,6 +10,7 @@
 #include "graphics/shader/shader.h"
 
 #include <cstddef>
+#include <filesystem>
 #include <memory>
 #include <span>
 #include <type_traits>
@@ -109,6 +110,7 @@ public:
 	explicit PipelineCache(GraphicContext& graphics);
 	~PipelineCache();
 	KYTY_CLASS_NO_COPY(PipelineCache);
+	void Save();
 
 	struct Pipeline {
 		vk::PipelineLayout      pipeline_layout       = nullptr;
@@ -214,12 +216,16 @@ private:
 
 	GraphicContext&                m_graphics;
 	std::unique_ptr<ProgramCache> m_program_cache;
+	vk::PipelineCache             m_driver_cache = nullptr;
+	std::filesystem::path         m_driver_cache_path;
 	std::unordered_map<GraphicsPipelineKey, std::unique_ptr<GraphicsPipeline>,
 	                   GraphicsPipelineKeyHash>
 	    m_graphics_pipelines;
 	std::unordered_map<ComputePipelineKey, std::unique_ptr<ComputePipeline>, ComputePipelineKeyHash>
 	              m_compute_pipelines;
 	Common::Mutex m_mutex;
+
+	void InitializeDriverCache();
 };
 
 void LogPipelineTrace(const char* phase, uint64_t vertex_program_id, uint64_t pixel_program_id);
@@ -227,10 +233,11 @@ void CreatePipelineInternal(
     GraphicContext& graphics, PipelineCache::GraphicsPipeline& pipeline,
     const PipelineRenderingState& rendering, const ShaderVertexInputInfo& vs_input_info,
     vk::ShaderModule vertex_module, const ShaderPixelInputInfo* ps_input_info,
-	vk::ShaderModule pixel_module, const PipelineStaticParameters& static_params);
+	vk::ShaderModule pixel_module, const PipelineStaticParameters& static_params,
+	vk::PipelineCache driver_cache);
 void CreatePipelineInternal(GraphicContext& graphics, PipelineCache::ComputePipeline& pipeline,
                             const ShaderComputeInputInfo& input_info,
-                            vk::ShaderModule              compute_module);
+	vk::ShaderModule compute_module, vk::PipelineCache driver_cache);
 
 } // namespace Libs::Graphics
 

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

@@ -423,7 +423,8 @@ void CreatePipelineInternal(
     GraphicContext& graphics, PipelineCache::GraphicsPipeline& pipeline,
     const PipelineRenderingState& rendering, const ShaderVertexInputInfo& vs_input_info,
     vk::ShaderModule vertex_module, const ShaderPixelInputInfo* ps_input_info,
-	vk::ShaderModule pixel_module, const PipelineStaticParameters& static_params) {
+	vk::ShaderModule pixel_module, const PipelineStaticParameters& static_params,
+	vk::PipelineCache driver_cache) {
 	const bool ps_active = ps_input_info != nullptr;
 	EXIT_IF(vertex_module == nullptr || (ps_active && pixel_module == nullptr));
 
@@ -940,7 +941,7 @@ void CreatePipelineInternal(
 		     viewport.y, viewport.width, viewport.height, scissor.offset.x, scissor.offset.y,
 		     scissor.extent.width, scissor.extent.height);
 	}
-	result = graphics.device.createGraphicsPipelines(nullptr, 1, &pipeline_info, nullptr,
+	result = graphics.device.createGraphicsPipelines(driver_cache, 1, &pipeline_info, nullptr,
 	                                                 &pipeline.pipeline);
 	if (graphics_debug_dump_enabled()) {
 		LOGF("PipelineTrace: vkCreateGraphicsPipelines done result=%s pipeline=%p\n",
@@ -961,7 +962,7 @@ void CreatePipelineInternal(
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
 void CreatePipelineInternal(GraphicContext& graphics, PipelineCache::ComputePipeline& pipeline,
                             const ShaderComputeInputInfo& input_info,
-                            vk::ShaderModule              compute_module) {
+	vk::ShaderModule compute_module, vk::PipelineCache driver_cache) {
 	EXIT_IF(compute_module == nullptr);
 
 	vk::PipelineShaderStageCreateInfo                     comp_shader_stage_info {};
@@ -1024,7 +1025,8 @@ void CreatePipelineInternal(GraphicContext& graphics, PipelineCache::ComputePipe
 
 	LOGF("PipelineTrace: vkCreateComputePipelines begin layout=%p\n",
 	     static_cast<void*>(pipeline.pipeline_layout));
-	result = graphics.device.createComputePipelines(nullptr, 1, &info, nullptr, &pipeline.pipeline);
+	result = graphics.device.createComputePipelines(driver_cache, 1, &info, nullptr,
+	                                                &pipeline.pipeline);
 	LOGF("PipelineTrace: vkCreateComputePipelines done result=%s pipeline=%p\n",
 	     VulkanToString(result).c_str(), static_cast<void*>(pipeline.pipeline));
 	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);

src/graphics/presentation/window/hostInput.cpp

@@ -1,18 +1,24 @@
 #include "graphics/presentation/window/hostInput.h"
 
+#include "SDL_error.h"
+#include "SDL_events.h"
 #include "SDL_keyboard.h"
 #include "SDL_keycode.h"
 #include "SDL_mouse.h"
+#include "SDL_timer.h"
+#include "SDL_video.h"
 #include "common/assert.h"
 #include "common/emulatorConfig.h"
+#include "common/logging/log.h"
 #include "libs/controller.h"
 
 #include <algorithm>
 #include <array>
+#include <cmath>
 #include <cstddef>
+#include <cstdlib>
 #include <string>
 #include <string_view>
-#include <utility>
 
 namespace Libs::Graphics {
 
@@ -60,6 +66,17 @@ struct Binding {
 	std::size_t control      = INVALID_CONTROL;
 };
 
+constexpr int              MOUSE_POLL_INTERVAL_MS = 33;
+constexpr std::string_view MOUSE_SENSITIVITY      = "MouseSensitivity=";
+
+struct MouseJoystickState {
+	bool     enabled   = false;
+	bool     output    = false;
+	uint64_t next_poll = 0;
+};
+
+MouseJoystickState g_mouse;
+
 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; });
@@ -103,10 +120,17 @@ bool Conflicts(const Binding& first, const Binding& second) {
 
 class InputMap {
 public:
-	InputMap(): m_custom(!Config::GetKeymap().empty()) {
+	InputMap() {
 		for (const auto& value: Config::GetKeymap()) {
 			const std::string_view entry = value;
-			const auto             split = entry.find('=');
+			if (entry.starts_with(MOUSE_SENSITIVITY)) {
+				const float sensitivity =
+				    std::strtof(value.c_str() + MOUSE_SENSITIVITY.size(), nullptr);
+				m_mouse_sensitivity =
+				    std::clamp(std::isfinite(sensitivity) ? sensitivity : 1.0f, 0.1f, 5.0f);
+				continue;
+			}
+			const auto split = entry.find('=');
 
 			Binding binding;
 			if (split != std::string_view::npos) {
@@ -118,9 +142,9 @@ public:
 				}
 			}
 
-			const bool reserved =
-			    binding.key == SDLK_ESCAPE || binding.key == SDLK_SPACE || binding.key == SDLK_F1 ||
-			    binding.key == SDLK_F11;
+			const bool reserved = binding.key == SDLK_ESCAPE || binding.key == SDLK_SPACE ||
+			                      binding.key == SDLK_F1 || binding.key == SDLK_F7 ||
+			                      binding.key == SDLK_F11;
 			if (binding.control == INVALID_CONTROL || reserved ||
 			    (binding.key == SDLK_UNKNOWN && binding.mouse_button == 0)) {
 				EXIT("Invalid input mapping: %s\n", value.c_str());
@@ -128,7 +152,8 @@ public:
 			Add(binding);
 		}
 	}
-	[[nodiscard]] bool Custom() const { return m_custom; }
+	[[nodiscard]] bool  Custom() const { return m_size != 0; }
+	[[nodiscard]] float MouseSensitivity() const { return m_mouse_sensitivity; }
 
 	[[nodiscard]] std::size_t FindKey(int key_code) const {
 		key_code = NormalizeKey(static_cast<SDL_Keycode>(key_code));
@@ -159,8 +184,8 @@ private:
 	}
 
 	std::array<Binding, CONTROL_INFO.size()> m_bindings {};
-	std::size_t                              m_size = 0;
-	bool                                     m_custom;
+	std::size_t                              m_size              = 0;
+	float                                    m_mouse_sensitivity = 1.0f;
 };
 
 const InputMap& GetInputMap() {
@@ -281,6 +306,33 @@ void DefaultKeyboardInput(int key_code, bool down) {
 		default: SetButton(DefaultKeyboardButton(key_code), down); return;
 	}
 }
+
+void MouseToJoystick(int delta_x, int delta_y) {
+	const double distance = std::hypot(delta_x, delta_y);
+	const double scale =
+	    std::clamp(distance * GetInputMap().MouseSensitivity() + 16.0, 64.0, 128.0) / distance;
+	const auto map_axis = [scale](int delta) {
+		return std::clamp(128 + static_cast<int>(std::lround(delta * scale)), 0, 255);
+	};
+	Controller::ControllerRightStick(Controller::HOST_INPUT_CONTROLLER_ID, map_axis(delta_x),
+	                                 map_axis(delta_y));
+}
+
+void CenterMouseStick() {
+	if (!g_mouse.output) {
+		return;
+	}
+	Controller::ControllerRightStick(Controller::HOST_INPUT_CONTROLLER_ID, 128, 128);
+	g_mouse.output = false;
+}
+
+bool SetRelativeMouseMode(bool enabled) {
+	if (SDL_SetRelativeMouseMode(enabled ? SDL_TRUE : SDL_FALSE) == 0) {
+		return true;
+	}
+	LOGF("Mouse-to-joystick relative mode failed: %s\n", SDL_GetError());
+	return false;
+}
 } // namespace
 
 void HostInputInit() {
@@ -303,4 +355,63 @@ void HostInputMouseButton(uint8_t mouse_button, bool down) {
 	}
 }
 
+void HostInputToggleMouseToJoystick() {
+	if (g_mouse.enabled) {
+		SetRelativeMouseMode(false);
+		CenterMouseStick();
+		g_mouse = {};
+		LOGF("Mouse to right stick: disabled\n");
+		return;
+	}
+
+	if (!SetRelativeMouseMode(true)) {
+		return;
+	}
+	int ignored_x = 0;
+	int ignored_y = 0;
+	SDL_GetRelativeMouseState(&ignored_x, &ignored_y);
+	g_mouse.enabled   = true;
+	g_mouse.next_poll = SDL_GetTicks64() + MOUSE_POLL_INTERVAL_MS;
+	LOGF("Mouse to right stick: enabled (F7 to release)\n");
+}
+
+int PollMouse(uint64_t now_ms) {
+	if (now_ms < g_mouse.next_poll) {
+		return static_cast<int>(g_mouse.next_poll - now_ms);
+	}
+	g_mouse.next_poll = now_ms + MOUSE_POLL_INTERVAL_MS;
+
+	int delta_x = 0;
+	int delta_y = 0;
+	SDL_GetRelativeMouseState(&delta_x, &delta_y);
+	if (delta_x == 0 && delta_y == 0) {
+		CenterMouseStick();
+		return MOUSE_POLL_INTERVAL_MS;
+	}
+
+	MouseToJoystick(delta_x, delta_y);
+	g_mouse.output = true;
+	return MOUSE_POLL_INTERVAL_MS;
+}
+
+bool HostInputWaitEvent(SDL_Event* event) {
+	if (!g_mouse.enabled || SDL_GetKeyboardFocus() == nullptr) {
+		CenterMouseStick();
+		if (SDL_WaitEvent(event) == 0) {
+			EXIT("%s\n", SDL_GetError());
+		}
+		return true;
+	}
+
+	const int timeout_ms = PollMouse(SDL_GetTicks64());
+	SDL_ClearError();
+	if (SDL_WaitEventTimeout(event, timeout_ms) != 0) {
+		return true;
+	}
+	if (SDL_GetError()[0] != '\0') {
+		EXIT("%s\n", SDL_GetError());
+	}
+	return false;
+}
+
 } // namespace Libs::Graphics

src/graphics/presentation/window/hostInput.h

@@ -3,11 +3,15 @@
 
 #include <cstdint>
 
+union SDL_Event;
+
 namespace Libs::Graphics {
 
-void HostInputInit();
-void HostInputKey(int key_code, bool down);
-void HostInputMouseButton(uint8_t mouse_button, bool down);
+void               HostInputInit();
+void               HostInputKey(int key_code, bool down);
+void               HostInputMouseButton(uint8_t mouse_button, bool down);
+void               HostInputToggleMouseToJoystick();
+[[nodiscard]] bool HostInputWaitEvent(SDL_Event* event);
 
 } // namespace Libs::Graphics
 

src/graphics/presentation/window/vulkanWindow.cpp

@@ -942,6 +942,18 @@ void WindowContext::CreateVulkan() {
 	inst_info.sType                   = vk::StructureType::eInstanceCreateInfo;
 	inst_info.pNext                   = (r.enable_validation_layers ? &dbg_create_info : nullptr);
 	inst_info.flags                   = {};
+#if defined(__APPLE__)
+	// MoltenVK requires VK_KHR_portability_enumeration + flag to surface
+	// portability devices. Without this, enumeratePhysicalDevices hides the
+	// MoltenVK adapter on some driver versions.
+	if (HasExtension(r.available_extensions, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)) {
+		if (!HasExtension(r.required_extensions, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)) {
+			r.required_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+		}
+		inst_info.flags |= vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR;
+		LOGF("Vulkan instance: enabled %s\n", VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+	}
+#endif
 	inst_info.pApplicationInfo        = &app_info;
 	inst_info.enabledExtensionCount   = static_cast<uint32_t>(r.required_extensions.size());
 	inst_info.ppEnabledExtensionNames = r.required_extensions.data();

src/graphics/presentation/window/window.cpp

@@ -3,6 +3,7 @@
 #include "SDL.h"
 #include "SDL_error.h"
 #include "SDL_events.h"
+#include "SDL_filesystem.h"
 #include "SDL_gamecontroller.h"
 #include "SDL_hints.h"
 #include "SDL_joystick.h"
@@ -28,6 +29,7 @@
 #include "common/timer.h"
 #include "graphics/host_gpu/graphicContext.h"
 #include "graphics/host_gpu/renderer/render.h"
+#include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vma.h"
 #include "graphics/host_gpu/vulkanCommon.h"
 #include "graphics/presentation/imeOverlay.h"
@@ -39,13 +41,12 @@
 #include "loader/systemContent.h"
 
 #include <cstdlib>
+#include <fmt/format.h>
 #include <memory>
 #include <string>
 #include <vector>
 #include <vulkan/vk_platform.h>
 
-#include <fmt/format.h>
-
 #define STB_IMAGE_IMPLEMENTATION
 #define STBI_NO_SIMD
 #include "stb_image.h"
@@ -506,6 +507,13 @@ void WindowContext::ProcessEvent(double time_s) {
 	auto& game  = loop;
 	auto* event = &game.event;
 	EXIT_IF(SDL_GetEventState(SDL_DISPLAYEVENT) != SDL_ENABLE);
+	if ((event->type == SDL_KEYDOWN || event->type == SDL_KEYUP) &&
+	    event->key.keysym.sym == SDLK_F7) {
+		if (event->type == SDL_KEYDOWN && event->key.repeat == 0) {
+			HostInputToggleMouseToJoystick();
+		}
+		return;
+	}
 	if (ProcessImeInput(*event)) {
 		return;
 	}
@@ -782,8 +790,8 @@ void WindowContext::Run() {
 			timer.Resume();
 		}
 
-		if (SDL_WaitEvent(&loop.event) == 0) {
-			EXIT("%s\n", SDL_GetError());
+		if (!HostInputWaitEvent(&loop.event)) {
+			continue;
 		}
 		ProcessEvent(timer.GetTimeS());
 	}
@@ -811,6 +819,24 @@ static void WindowCreate(WindowContext& context) {
 
 	uint32_t window_flags = WindowContext::InitialWindowFlags(Config::FullscreenEnabled());
 #if defined(__APPLE__)
+	// SDL loads Vulkan while creating a Vulkan window, so select the bundled
+	// MoltenVK loader before calling SDL_CreateWindow. Keep an explicit user
+	// override, and fall back to SDL's normal loader search when no bundle is present.
+	if (std::getenv("SDL_VULKAN_LIBRARY") == nullptr) {
+		if (char* base_path = SDL_GetBasePath(); base_path != nullptr) {
+			const std::string base_path_str = base_path;
+			SDL_free(base_path);
+			std::string moltenvk_path = base_path_str + "libMoltenVK.dylib";
+			if (!Common::File::IsFileExisting(moltenvk_path)) {
+				moltenvk_path = base_path_str + "../Frameworks/libMoltenVK.dylib";
+			}
+			if (Common::File::IsFileExisting(moltenvk_path) &&
+			    SDL_setenv("SDL_VULKAN_LIBRARY", moltenvk_path.c_str(), 0) == 0) {
+				LOGF("Vulkan loader: %s\n", moltenvk_path.c_str());
+			}
+		}
+	}
+
 	// macOS 26 window chrome (CoreUI asset decode, SwiftUI titlebar) has been observed
 	// throwing NSExceptions under Rosetta during the first CATransaction commit. A
 	// borderless window skips that machinery entirely.
@@ -858,6 +884,7 @@ void WindowRun() {
 	EXIT_IF(g_window == nullptr);
 
 	g_window->Run();
+	g_window->render_context->GetPipelineCache().Save();
 }
 
 void WindowShutdown() {

src/graphics/shader/recompiler/backend/spirv/spirvEmitterImage.cpp

@@ -439,6 +439,49 @@ uint32_t UnpackImageGather(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uin
 	return result;
 }
 
+uint32_t EmitOneDimensionalGatherLz(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uint32_t pc,
+	                                 uint32_t coord, bool integer) {
+	auto& state = ctx.state;
+	state.builder.RequireCapability(CapabilityImageQuery);
+	const auto image = LoadSampledImageDescriptor(state, mem, pc, ImageViewKind::Dim1D);
+	const auto width = state.builder.AllocateId();
+	state.builder.AddFunction(
+	    {OpImageQuerySizeLod, TypeU32(state), width, image, ConstantU32(state, 0)});
+	const auto width_f32 = state.builder.AllocateId();
+	state.builder.AddFunction({OpConvertUToF, TypeF32(state), width_f32, width});
+	const auto left = state.builder.AllocateId();
+	state.builder.AddFunction(
+	    {OpExtInst, TypeF32(state), left, GlslStd450(state), GlslFloor,
+	     Binary(state, OpFSub, TypeF32(state),
+	            Binary(state, OpFMul, TypeF32(state), coord, width_f32),
+	            ConstantF32(state, 0x3f000000u))});
+
+	const auto sampled = MakeSampledImage(state, mem, pc, ImageViewKind::Dim1D);
+	const auto vector_type = integer ? TypeU32Vector(state, 4) : TypeF32Vector(state, 4);
+	const auto scalar_type = integer ? TypeU32(state) : TypeF32(state);
+	const auto component = ImageConversionFormat(state, mem).format == Prospero::BufferFormat::kInvalid
+	                           ? ImageGatherComponent(mem.dmask)
+	                           : 0u;
+	uint32_t values[2] {};
+	for (uint32_t index = 0; index < 2u; index++) {
+		const auto sample_coord = Binary(
+		    state, OpFDiv, TypeF32(state),
+		    Binary(state, OpFAdd, TypeF32(state), left,
+		           ConstantF32(state, index == 0u ? 0x3f000000u : 0x3fc00000u)),
+		    width_f32);
+		const auto texel = state.builder.AllocateId();
+		state.builder.AddFunction({OpImageSampleExplicitLod, vector_type, texel, sampled, sample_coord,
+		                           ImageOperandsLodMask, ZeroF32(state)});
+		values[index] = state.builder.AllocateId();
+		state.builder.AddFunction(
+		    {OpCompositeExtract, scalar_type, values[index], texel, component});
+	}
+	const auto result = state.builder.AllocateId();
+	state.builder.AddFunction({OpCompositeConstruct, vector_type, result, values[0], values[1],
+	                           values[1], values[0]});
+	return result;
+}
+
 uint32_t PackImageTexel(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uint32_t texel) {
 	const auto info = ImageConversionFormat(ctx.state, mem);
 	if (info.format == Prospero::BufferFormat::kInvalid) return texel;
@@ -613,6 +656,22 @@ bool EmitValueImage(ValueEmitContext& ctx, const IR::Inst& inst) {
 		const auto coord =
 		    CoordF32(ctx, mem, *address, layout.coord, ImageViewCoordinateComponents(view));
 		if (op == IR::ValueOpcode::ImageGatherRaw) {
+			if (view == ImageViewKind::Dim1D) {
+				if (dref || !HasFlag(mem, Decoder::ImageSampleFlagLevelZero) ||
+				    HasFlag(mem, Decoder::ImageSampleFlagOffset) ||
+				    HasFlag(mem, Decoder::ImageSampleFlagGatherHorizontal)) {
+					ctx.Fail(inst, "has an unsupported 1D gather variant");
+					return true;
+				}
+				const auto sample = EmitOneDimensionalGatherLz(ctx, mem, pc, coord, integer);
+				ctx.Define(inst, ResultVector(ctx, UnpackImageGather(ctx, mem, sample), integer,
+				                              false, mem, true));
+				return true;
+			}
+			if (view == ImageViewKind::Dim1DArray) {
+				ctx.Fail(inst, "has an unsupported 1D-array gather");
+				return true;
+			}
 			const auto            sampled = MakeSampledImage(state, mem, pc, view);
 			const auto            sample  = state.builder.AllocateId();
 			std::vector<uint32_t> words =

src/graphics/shader/recompiler/frontend/decode/MemoryOps.cpp

@@ -103,7 +103,9 @@ constexpr MemoryOpcodeInfo DS_OPCODE_LIST[] = {
     {0x4du, Opcode::DS_WRITE_B64, 2, 32},        {0x4eu, Opcode::DS_WRITE2_B64, 4, 32},
     {0x4fu, Opcode::DS_WRITE2ST64_B64, 4, 32},   {0x76u, Opcode::DS_READ_B64, 2, 32},
     {0x77u, Opcode::DS_READ2_B64, 4, 32},        {0x78u, Opcode::DS_READ2ST64_B64, 4, 32},
+    {0xa1u, Opcode::DS_WRITE_B16_D16_HI, 1, 16},
     {0xa6u, Opcode::DS_READ_U16_D16, 1, 16},
+    {0xa7u, Opcode::DS_READ_U16_D16_HI, 1, 16},
     {0xb0u, Opcode::DS_WRITE_ADDTID_B32, 1, 32}, {0xb1u, Opcode::DS_READ_ADDTID_B32, 1, 32},
     {0xdeu, Opcode::DS_WRITE_B96, 3, 32},        {0xdfu, Opcode::DS_WRITE_B128, 4, 32},
     {0xfeu, Opcode::DS_READ_B96, 3, 32},         {0xffu, Opcode::DS_READ_B128, 4, 32},
@@ -147,6 +149,7 @@ bool IsDsWriteOpcode(Opcode opcode) {
 	switch (opcode) {
 		case Opcode::DS_WRITE_B8:
 		case Opcode::DS_WRITE_B16:
+		case Opcode::DS_WRITE_B16_D16_HI:
 		case Opcode::DS_WRITE2_B32:
 		case Opcode::DS_WRITE2ST64_B32:
 		case Opcode::DS_WRITE2_B64:
@@ -421,13 +424,17 @@ void DecodeDs(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index,
 	}
 
 	DecodeVectorGpr(vdst, inst.dst);
-	if (inst.opcode == Opcode::DS_READ_U16_D16) {
+	if (inst.opcode == Opcode::DS_READ_U16_D16 ||
+	    inst.opcode == Opcode::DS_READ_U16_D16_HI) {
 		// Native D16 reads update only the selected destination half. Reuse the partial
-		// destination representation so typed IR translation preserves the upper word.
-		inst.dst.sdwa_sel = 4u;
+		// destination representation so typed IR translation preserves the other half.
+		inst.dst.sdwa_sel = inst.opcode == Opcode::DS_READ_U16_D16 ? 4u : 5u;
 	}
 	DecodeVectorGpr(addr, inst.src0);
 	DecodeVectorGpr(data0, inst.src1);
+	if (inst.opcode == Opcode::DS_WRITE_B16_D16_HI) {
+		inst.src1.sdwa_sel = 5u;
+	}
 	DecodeVectorGpr(data1, inst.src2);
 	inst.src_count = DsSourceCount(inst.opcode);
 }

src/graphics/shader/recompiler/frontend/decode/ShaderDecoder.cpp

@@ -675,6 +675,7 @@ std::string InstructionToString(const Instruction& inst) {
 		case Opcode::DS_READ_B128:
 		case Opcode::DS_WRITE_B8:
 		case Opcode::DS_WRITE_B16:
+		case Opcode::DS_WRITE_B16_D16_HI:
 		case Opcode::DS_WRITE2_B32:
 		case Opcode::DS_WRITE2ST64_B32:
 		case Opcode::DS_WRITE2_B64:

src/graphics/shader/recompiler/frontend/decode/ShaderDecoder.h

@@ -185,6 +185,7 @@ enum class Opcode {
 	V_BFREV_B32,
 	V_FFBH_U32,
 	V_FFBL_B32,
+	V_FFBH_I32,
 	V_ADD_F32,
 	V_SUB_F32,
 	V_SUBREV_F32,
@@ -391,6 +392,7 @@ enum class Opcode {
 	V_CMP_GE_U32,
 	V_CMP_T_U32,
 	V_CMP_EQ_I64,
+	V_CMP_EQ_U64,
 	V_CMP_GT_U64,
 	V_CMP_NE_U64,
 	V_CMPX_NE_I64,
@@ -497,6 +499,7 @@ enum class Opcode {
 	DS_READ_I16,
 	DS_READ_U16,
 	DS_READ_U16_D16,
+	DS_READ_U16_D16_HI,
 	DS_READ2_B32,
 	DS_READ2ST64_B32,
 	DS_READ_B32,
@@ -507,6 +510,7 @@ enum class Opcode {
 	DS_READ_B128,
 	DS_WRITE_B8,
 	DS_WRITE_B16,
+	DS_WRITE_B16_D16_HI,
 	DS_WRITE2_B32,
 	DS_WRITE2ST64_B32,
 	DS_WRITE2_B64,

src/graphics/shader/recompiler/frontend/decode/VectorAluOps.cpp

@@ -59,7 +59,7 @@ constexpr Vop2OpcodeInfo VOP2_OPCODE_LIST[] = {
     {0x23u, Opcode::V_MBCNT_LO_U32_B32},
     {0x24u, Opcode::V_MBCNT_HI_U32_B32},
     {0x25u, Opcode::V_ADD_NC_U32, Vop2SdwaProfile::IntegerPartialDestination},
-    {0x28u, Opcode::V_ADDC_U32},
+    {0x28u, Opcode::V_ADDC_U32, Vop2SdwaProfile::IntegerFullDestination},
     {0x2au, Opcode::V_SUBREV_CO_CI_U32},
     {0x26u, Opcode::V_SUB_NC_U32, Vop2SdwaProfile::IntegerPartialDestination},
     {0x27u, Opcode::V_SUBREV_NC_U32, Vop2SdwaProfile::IntegerFullDestination},
@@ -119,6 +119,7 @@ constexpr OpcodeMap VOP1_OPCODE_LIST[] = {
     {0x38u, Opcode::V_BFREV_B32},
     {0x39u, Opcode::V_FFBH_U32},
     {0x3au, Opcode::V_FFBL_B32},
+    {0x3bu, Opcode::V_FFBH_I32},
     {0x3fu, Opcode::V_FREXP_EXP_I32_F32},
     {0x40u, Opcode::V_FREXP_MANT_F32},
     {0x42u, Opcode::V_MOVRELD_B32},
@@ -169,6 +170,7 @@ constexpr OpcodeMap VOP3_ENCODED_VOP1_OPCODE_LIST[] = {
     {0x38u, Opcode::V_BFREV_B32},
     {0x39u, Opcode::V_FFBH_U32},
     {0x3au, Opcode::V_FFBL_B32},
+    {0x3bu, Opcode::V_FFBH_I32},
     {0x3fu, Opcode::V_FREXP_EXP_I32_F32},
     {0x40u, Opcode::V_FREXP_MANT_F32},
     {0x42u, Opcode::V_MOVRELD_B32},
@@ -234,7 +236,8 @@ constexpr VopcOpcodeInfo VOPC_OPCODE_LIST[] = {
     {0xd1u, Opcode::V_CMPX_LT_U32},       {0xd2u, Opcode::V_CMPX_EQ_U32},
     {0xd3u, Opcode::V_CMPX_LE_U32},       {0xd4u, Opcode::V_CMPX_GT_U32},
     {0xd5u, Opcode::V_CMPX_NE_U32},       {0xd6u, Opcode::V_CMPX_GE_U32},
-    {0xe4u, Opcode::V_CMP_GT_U64, false}, {0xe5u, Opcode::V_CMP_NE_U64, false},
+    {0xe2u, Opcode::V_CMP_EQ_U64, false}, {0xe4u, Opcode::V_CMP_GT_U64, false},
+    {0xe5u, Opcode::V_CMP_NE_U64, false},
     {0xf5u, Opcode::V_CMPX_NE_U64, false},
     {0xc9u, Opcode::V_CMP_LT_F16},        {0xcau, Opcode::V_CMP_EQ_F16},
     {0xcbu, Opcode::V_CMP_LE_F16},        {0xccu, Opcode::V_CMP_GT_F16},
@@ -515,6 +518,8 @@ constexpr Vop1SdwaRule VOP1_SDWA_RULES[] = {
     {Opcode::V_CVT_F32_U32, SdwaSelBytes() | SdwaSelWords() | SdwaSelFull(), 0, 0, false},
     {Opcode::V_CVT_F32_I32, SdwaSelBytes() | SdwaSelWords() | SdwaSelFull(), 0, 0, false},
     {Opcode::V_CVT_F32_UBYTE0, SdwaSelBytes() | SdwaSelWords() | SdwaSelFull(), 0, 0, false},
+    {Opcode::V_NOT_B32, SdwaSelBytes() | SdwaSelWords() | SdwaSelFull(), 0, 0, false},
+    {Opcode::V_FFBL_B32, SdwaSelBytes() | SdwaSelWords() | SdwaSelFull(), 0, 0, false},
     {Opcode::V_CVT_F32_F16, SdwaSelWords() | SdwaSelFull(), 0, 0, true},
     {Opcode::V_CVT_F16_F32, SdwaSelFull(), SdwaSelWords(), SdwaSelFull(), false},
     {Opcode::V_CVT_F16_U16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords(),
@@ -940,8 +945,8 @@ constexpr Vop2SdwaRule VOP2_SDWA_RULES[] = {
      true, true},
     {SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
     {SdwaSelAll(), SdwaSelAll(), SdwaSelAll(), true, false},
-    {SdwaSelFull(), SdwaSelFull(), SdwaSelWords() | SdwaSelFull(), false, false},
-    {SdwaSelFull(), SdwaSelFull(), SdwaSelAll(), false, false},
+    {SdwaSelFull(), SdwaSelAll(), SdwaSelWords() | SdwaSelFull(), false, false},
+    {SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
     {SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
 };
 static_assert(sizeof(VOP2_SDWA_RULES) / sizeof(VOP2_SDWA_RULES[0]) ==

src/graphics/shader/recompiler/frontend/translate/Integer.cpp

@@ -224,11 +224,14 @@ bool Translator::S_FF1_I32_B64(const Decoder::Instruction& inst) {
 	return true;
 }
 
-bool Translator::V_FFBH_U32(const Decoder::Instruction& inst) {
-	const auto source   = ReadU32(inst.src0);
-	const auto msb      = IR::U32(ir.Emit(IR::ValueOpcode::FindUMsb32, {source}));
+bool Translator::V_FFBH_32(const Decoder::Instruction& inst, bool sign) {
+	const auto source = ReadU32(inst.src0);
+	const auto value  = sign ? ir.BitwiseXor(
+	                              source, ir.ShiftRightArithmetic(source, IR::U32(IR::Value(31u))))
+	                         : source;
+	const auto msb      = IR::U32(ir.Emit(IR::ValueOpcode::FindUMsb32, {value}));
 	const auto position = ir.ISub(IR::U32(IR::Value(31u)), msb);
-	const auto result   = ir.Select(ir.INotEqual(source, IR::U32(IR::Value(0u))), position,
+	const auto result   = ir.Select(ir.INotEqual(value, IR::U32(IR::Value(0u))), position,
 	                                IR::U32(IR::Value(0xffffffffu)));
 	WriteOperand(DestinationOperand(inst), result);
 	return true;

src/graphics/shader/recompiler/frontend/translate/Memory.cpp

@@ -257,6 +257,7 @@ Decoder::Operand MemorySourceAt(const Decoder::Instruction& decoded, uint32_t in
 				return index == 0u ? decoded.src1 : index == 1u ? decoded.src0 : decoded.src2;
 			case Decoder::Opcode::DS_WRITE_B8:
 			case Decoder::Opcode::DS_WRITE_B16:
+			case Decoder::Opcode::DS_WRITE_B16_D16_HI:
 			case Decoder::Opcode::DS_WRITE_B32:
 			case Decoder::Opcode::DS_WRITE_B64:
 			case Decoder::Opcode::DS_WRITE_B96:
@@ -1050,6 +1051,7 @@ bool Translator::EmitMemory(const Decoder::Instruction& inst, std::string* error
 		case Decoder::Opcode::DS_READ_I16:
 		case Decoder::Opcode::DS_READ_U16:
 		case Decoder::Opcode::DS_READ_U16_D16:
+		case Decoder::Opcode::DS_READ_U16_D16_HI:
 		case Decoder::Opcode::DS_READ_B32:
 		case Decoder::Opcode::DS_READ_B64:
 		case Decoder::Opcode::DS_READ_B96:
@@ -1060,6 +1062,7 @@ bool Translator::EmitMemory(const Decoder::Instruction& inst, std::string* error
 		case Decoder::Opcode::DS_WRITE2ST64_B64: return DS_WRITE2(inst);
 		case Decoder::Opcode::DS_WRITE_B8:
 		case Decoder::Opcode::DS_WRITE_B16:
+		case Decoder::Opcode::DS_WRITE_B16_D16_HI:
 		case Decoder::Opcode::DS_WRITE_B32:
 		case Decoder::Opcode::DS_WRITE_B64:
 		case Decoder::Opcode::DS_WRITE_B96:

src/graphics/shader/recompiler/frontend/translate/Translator.h

@@ -182,7 +182,7 @@ private:
 	bool    V_OR3_B32(const Decoder::Instruction& inst);
 	bool    V_XOR3_B32(const Decoder::Instruction& inst);
 	bool    S_FF1_I32_B64(const Decoder::Instruction& inst);
-	bool    V_FFBH_U32(const Decoder::Instruction& inst);
+	bool    V_FFBH_32(const Decoder::Instruction& inst, bool sign);
 	bool    S_FLBIT_I32_B64(const Decoder::Instruction& inst);
 	bool    Integer24(const Decoder::Instruction& inst, bool sign, bool addend);
 	bool    V_MAD_U64_U32(const Decoder::Instruction& inst);

src/graphics/shader/recompiler/frontend/translate/Vector.cpp

@@ -96,6 +96,7 @@ bool Translator::EmitVector(const Decoder::Instruction& inst, std::string* error
 			EmitIntegerCompare(inst, IR::ValueOpcode::SLessThanEqual32, IR::Type::U32, false, true);
 			return true;
 		case O::V_CMP_EQ_I64:
+		case O::V_CMP_EQ_U64:
 			EmitIntegerCompare(inst, IR::ValueOpcode::IEqual64, IR::Type::U64, false, false);
 			return true;
 		case O::V_CMP_GT_U64:
@@ -490,7 +491,8 @@ bool Translator::EmitVector(const Decoder::Instruction& inst, std::string* error
 		case O::V_AND_OR_B32: return V_AND_OR_B32(inst);
 		case O::V_OR3_B32: return V_OR3_B32(inst);
 		case O::V_XOR3_B32: return V_XOR3_B32(inst);
-		case O::V_FFBH_U32: return V_FFBH_U32(inst);
+		case O::V_FFBH_U32: return V_FFBH_32(inst, false);
+		case O::V_FFBH_I32: return V_FFBH_32(inst, true);
 
 		case O::V_MAD_I32_I24: return Integer24(inst, true, true);
 		case O::V_MAD_U32_U24: return Integer24(inst, false, true);

src/kernel/fileSystem.cpp

@@ -1066,7 +1066,7 @@ int KYTY_SYSV_ABI KernelRename(const char* from, const char* to) {
 		Common::File::DeleteFile(real_to);
 	}
 
-	if (!Common::File::MoveFile(real_from, real_to)) {
+	if (!Common::File::RenameFile(real_from, real_to)) {
 		return KERNEL_ERROR_EIO;
 	}
 

src/kernel/memoryAddressSpace.inc

@@ -44,9 +44,9 @@ public:
 
 	explicit GuestBackingStore(uint64_t size): m_size(size) {
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-		m_handle = CreateFileMappingA(INVALID_HANDLE_VALUE, nullptr, PAGE_EXECUTE_READWRITE,
-		                              static_cast<DWORD>(m_size >> 32u),
-		                              static_cast<DWORD>(m_size & 0xffffffffu), nullptr);
+		m_handle = CreateFileMappingA(
+		    INVALID_HANDLE_VALUE, nullptr, PAGE_EXECUTE_READWRITE | SEC_COMMIT,
+		    static_cast<DWORD>(m_size >> 32u), static_cast<DWORD>(m_size & 0xffffffffu), nullptr);
 		if (m_handle == nullptr) {
 			LOGF_COLOR(Log::Color::Red,
 			           "\t direct-memory backing: CreateFileMapping failed: 0x%08" PRIx32 "\n",
@@ -659,7 +659,16 @@ public:
 #endif
 		ReserveGuestRegions();
 		m_backing = new GuestBackingStore(backing_size);
-		EXIT_IF(!m_backing->IsAvailable());
+		if (!m_backing->IsAvailable()) {
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+			EXIT("could not reserve %" PRIu64 " MB for guest direct memory. Windows commits\n"
+			     "this up front, so the paging file is usually what needs to be larger.\n",
+			     backing_size / (1024U * 1024U));
+#else
+			EXIT("could not reserve %" PRIu64 " MB for guest direct memory\n",
+			     backing_size / (1024U * 1024U));
+#endif
+		}
 	}
 
 	~GuestAddressSpace() {

src/kytyGitVersion.h.in

@@ -1,7 +1,10 @@
 #include "cmake_config.h"
 
 #define KYTY_GIT_VERSION "@KYTY_GIT_VERSION@"
+// Short, human-facing commit name used in build labels.
 #define KYTY_GIT_HASH "@KYTY_GIT_HASH@"
+// Full commit identity used for compatibility checks.
+#define KYTY_GIT_REVISION "@KYTY_GIT_REVISION@"
 
 /* Build provenance, shown in the window title and in crash reports. */
 #if defined(KYTY_OFFICIAL_BUILD)

src/launcher/CMakeLists.txt

@@ -66,10 +66,46 @@ if(WIN32)
 endif()
 
 set(launcher_name "launcher")
+if(APPLE)
+	set(launcher_name "KytyPS5")
+endif()
 
 set_target_properties(launcher PROPERTIES OUTPUT_NAME ${launcher_name})
 
-install(TARGETS launcher DESTINATION .)
+if(APPLE)
+	# macOS bundle: KytyPS5.app with launcher as main executable and
+	# kyty_emulator as helper inside Contents/MacOS. MoltenVK is found
+	# next to a flat executable or in the bundle's Contents/Frameworks;
+	# no rpath fixup is needed because SDL loads it by absolute path.
+	# Qt deployment (Frameworks + plugins) is handled by macdeployqt.
+	set_target_properties(launcher PROPERTIES
+		MACOSX_BUNDLE TRUE
+		MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/Info.plist.in"
+		INSTALL_RPATH "@executable_path/../Frameworks"
+		BUILD_WITH_INSTALL_RPATH TRUE
+	)
+endif()
+
+install(TARGETS launcher
+	BUNDLE DESTINATION .
+	RUNTIME DESTINATION .)
+
+if(APPLE)
+	install(TARGETS kyty_emulator DESTINATION "KytyPS5.app/Contents/MacOS")
+	# Deploy and ad-hoc sign the Qt frameworks and plugins in the bundle.
+	find_program(KYTY_MACDEPLOYQT NAMES macdeployqt PATHS "${Qt6_DIR}/../../../bin" NO_DEFAULT_PATH)
+	if(NOT KYTY_MACDEPLOYQT)
+		message(FATAL_ERROR "Could not find macdeployqt")
+	endif()
+	install(CODE "
+		execute_process(COMMAND \"${KYTY_MACDEPLOYQT}\" \"\${CMAKE_INSTALL_PREFIX}/KytyPS5.app\"
+			-codesign=-
+			RESULT_VARIABLE _kyty_deploy_result)
+		if(NOT _kyty_deploy_result EQUAL 0)
+			message(FATAL_ERROR \"macdeployqt failed with \${_kyty_deploy_result}\")
+		endif()
+	")
+endif()
 
 if(WIN32)
     install(CODE "

src/launcher/Info.plist.in

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleName</key><string>KytyPS5</string>
+	<key>CFBundleDisplayName</key><string>KytyPS5</string>
+	<key>CFBundleIdentifier</key><string>org.kytyps5.kytyps5</string>
+	<key>CFBundleVersion</key><string>@PROJECT_VERSION@</string>
+	<key>CFBundleShortVersionString</key><string>@PROJECT_VERSION@</string>
+	<key>CFBundlePackageType</key><string>APPL</string>
+	<key>CFBundleSignature</key><string>????</string>
+	<key>CFBundleExecutable</key><string>KytyPS5</string>
+	<key>LSMinimumSystemVersion</key><string>13.0</string>
+	<key>NSHighResolutionCapable</key><true/>
+	<key>NSRequiresAquaSystemAppearance</key><false/>
+</dict>
+</plist>

src/launcher/include/inputMappingDialog.h

@@ -5,6 +5,7 @@
 #include <QStringList>
 
 class QPushButton;
+class QDoubleSpinBox;
 class QTreeWidget;
 class QTreeWidgetItem;
 class QWidget;
@@ -22,10 +23,11 @@ private:
 	void SetBinding(QTreeWidgetItem* item, const QString& binding);
 	void UpdateButtons();
 
-	QTreeWidget* m_bindings      = nullptr;
-	QPushButton* m_change_button = nullptr;
-	QPushButton* m_clear_button  = nullptr;
-	bool         m_customized    = false;
+	QTreeWidget*    m_bindings        = nullptr;
+	QPushButton*    m_change_button   = nullptr;
+	QPushButton*    m_clear_button    = nullptr;
+	QDoubleSpinBox* m_sensitivity     = nullptr;
+	bool            m_custom_bindings = false;
 };
 
 #endif /* LAUNCHER_INCLUDE_INPUT_MAPPING_DIALOG_H_ */

src/launcher/src/inputMappingDialog.cpp

@@ -2,6 +2,7 @@
 
 #include <QAbstractItemView>
 #include <QDialogButtonBox>
+#include <QDoubleSpinBox>
 #include <QHBoxLayout>
 #include <QHash>
 #include <QHeaderView>
@@ -16,7 +17,9 @@
 
 namespace {
 
-constexpr int BINDING_COLUMN = 1;
+constexpr int  BINDING_COLUMN            = 1;
+constexpr auto DEFAULT_MOUSE_SENSITIVITY = 1.0;
+constexpr char MOUSE_SENSITIVITY[]       = "MouseSensitivity=";
 
 struct PadControl {
 	const char* id;
@@ -128,7 +131,8 @@ public:
 
 		auto* layout = new QVBoxLayout(this);
 		m_label      = new QLabel(
-		    tr("Press a key or mouse button.\nSpace and F1 are reserved; Esc cancels."), this);
+		    tr("Press a key or mouse button.\nSpace, F1, F7, and F11 are reserved; Esc cancels."),
+		    this);
 		m_label->setAlignment(Qt::AlignCenter);
 		layout->addWidget(m_label);
 	}
@@ -144,7 +148,8 @@ protected:
 			reject();
 			return;
 		}
-		if (event->key() == Qt::Key_Space || event->key() == Qt::Key_F1) {
+		if (event->key() == Qt::Key_Space || event->key() == Qt::Key_F1 ||
+		    event->key() == Qt::Key_F7 || event->key() == Qt::Key_F11) {
 			m_label->setText(tr("That key is reserved by the emulator."));
 			return;
 		}
@@ -177,6 +182,9 @@ private:
 QHash<QString, QString> ParseMapping(const QStringList& mapping) {
 	QHash<QString, QString> result;
 	for (const auto& entry: mapping) {
+		if (entry.startsWith(QLatin1String(MOUSE_SENSITIVITY))) {
+			continue;
+		}
 		const auto separator = entry.indexOf(QLatin1Char('='));
 		if (separator > 0 && separator + 1 < entry.size()) {
 			const auto binding = entry.mid(separator + 1);
@@ -193,15 +201,42 @@ QHash<QString, QString> ParseMapping(const QStringList& mapping) {
 	return result;
 }
 
+double ParseMouseSensitivity(const QStringList& mapping) {
+	for (const auto& entry: mapping) {
+		if (entry.startsWith(QLatin1String(MOUSE_SENSITIVITY))) {
+			return entry.mid(sizeof(MOUSE_SENSITIVITY) - 1).toDouble();
+		}
+	}
+	return DEFAULT_MOUSE_SENSITIVITY;
+}
+
 } // namespace
 
 InputMappingDialog::InputMappingDialog(const QStringList& mapping, QWidget* parent)
-    : QDialog(parent), m_customized(!mapping.isEmpty()) {
+    : QDialog(parent) {
 	setWindowTitle(tr("Input Mapping"));
 	resize(460, 650);
 
 	auto* layout = new QVBoxLayout(this);
-	layout->addWidget(new QLabel(tr("Map keyboard or mouse input to DualSense controls."), this));
+	layout->addWidget(
+	    new QLabel(tr("Map keyboard or mouse buttons to DualSense controls.\n"
+	                  "Press F7 in-game to toggle mouse movement on the right stick."),
+	               this));
+
+	const auto parsed = ParseMapping(mapping);
+	m_custom_bindings = !parsed.isEmpty();
+
+	auto* sensitivity_layout = new QHBoxLayout;
+	sensitivity_layout->addWidget(new QLabel(tr("Mouse sensitivity"), this));
+	m_sensitivity = new QDoubleSpinBox(this);
+	m_sensitivity->setRange(0.1, 5.0);
+	m_sensitivity->setSingleStep(0.1);
+	m_sensitivity->setDecimals(1);
+	m_sensitivity->setSuffix(QStringLiteral("x"));
+	m_sensitivity->setValue(ParseMouseSensitivity(mapping));
+	sensitivity_layout->addWidget(m_sensitivity);
+	sensitivity_layout->addStretch();
+	layout->addLayout(sensitivity_layout);
 
 	m_bindings = new QTreeWidget(this);
 	m_bindings->setColumnCount(2);
@@ -212,13 +247,12 @@ InputMappingDialog::InputMappingDialog(const QStringList& mapping, QWidget* pare
 	m_bindings->header()->setSectionResizeMode(1, QHeaderView::Stretch);
 	layout->addWidget(m_bindings);
 
-	const auto parsed = ParseMapping(mapping);
 	for (const auto& control: PAD_CONTROLS) {
 		auto* item = new QTreeWidgetItem(m_bindings);
 		item->setText(0, tr(control.label));
 		item->setData(0, Qt::UserRole, QString::fromLatin1(control.id));
-		SetBinding(item, m_customized ? parsed.value(QString::fromLatin1(control.id))
-		                              : QString::fromLatin1(control.default_binding));
+		SetBinding(item, m_custom_bindings ? parsed.value(QString::fromLatin1(control.id))
+		                                   : QString::fromLatin1(control.default_binding));
 	}
 	m_bindings->setCurrentItem(m_bindings->topLevelItem(0));
 
@@ -248,16 +282,19 @@ InputMappingDialog::InputMappingDialog(const QStringList& mapping, QWidget* pare
 
 QStringList InputMappingDialog::Mapping() const {
 	QStringList result;
-	if (!m_customized) {
-		return result;
-	}
-	for (int index = 0; index < m_bindings->topLevelItemCount(); index++) {
-		const auto* item    = m_bindings->topLevelItem(index);
-		const auto  binding = item->data(BINDING_COLUMN, Qt::UserRole).toString();
-		if (!binding.isEmpty()) {
-			result.append(item->data(0, Qt::UserRole).toString() + QLatin1Char('=') + binding);
+	if (m_custom_bindings) {
+		for (int index = 0; index < m_bindings->topLevelItemCount(); index++) {
+			const auto* item    = m_bindings->topLevelItem(index);
+			const auto  binding = item->data(BINDING_COLUMN, Qt::UserRole).toString();
+			if (!binding.isEmpty()) {
+				result.append(item->data(0, Qt::UserRole).toString() + QLatin1Char('=') + binding);
+			}
 		}
 	}
+	if (m_sensitivity->value() != DEFAULT_MOUSE_SENSITIVITY) {
+		result.append(QLatin1String(MOUSE_SENSITIVITY) +
+		              QString::number(m_sensitivity->value(), 'f', 1));
+	}
 	return result;
 }
 
@@ -281,12 +318,12 @@ void InputMappingDialog::ChangeBinding() {
 		}
 	}
 	SetBinding(item, dialog.Binding());
-	m_customized = true;
+	m_custom_bindings = true;
 }
 
 void InputMappingDialog::ClearBinding() {
 	SetBinding(m_bindings->currentItem(), {});
-	m_customized = true;
+	m_custom_bindings = true;
 }
 
 void InputMappingDialog::RestoreDefaults() {
@@ -294,7 +331,8 @@ void InputMappingDialog::RestoreDefaults() {
 		SetBinding(m_bindings->topLevelItem(index),
 		           QString::fromLatin1(PAD_CONTROLS[index].default_binding));
 	}
-	m_customized = false;
+	m_sensitivity->setValue(DEFAULT_MOUSE_SENSITIVITY);
+	m_custom_bindings = false;
 }
 
 void InputMappingDialog::SetBinding(QTreeWidgetItem* item, const QString& binding) {

src/libs/controller.cpp

@@ -1,5 +1,6 @@
 #include "libs/controller.h"
 
+#include "SDL.h"
 #include "common/assert.h"
 #include "common/common.h"
 #include "common/emulatorConfig.h"
@@ -22,6 +23,9 @@ LIB_NAME("Pad", "Pad");
 constexpr int PAD_ERROR_INVALID_ARG    = -2137915391; /* 0x80920001 */
 constexpr int PAD_ERROR_INVALID_HANDLE = -2137915389; /* 0x80920003 */
 
+// SDL limits rumble commands to 0xffff ms; zero strengths stop immediately.
+constexpr uint32_t RUMBLE_DURATION_MS = 0xffff;
+
 struct PadControllerInformation {
 	float    touch_pixel_density;
 	uint16_t touch_resolution_x;
@@ -57,8 +61,10 @@ public:
 	void Disconnect(int id);
 	void Button(int id, uint32_t button, bool down);
 	void Axis(int id, Axis axis, int value);
+	void RightStick(int id, int x, int y);
 	void ResetInputState();
 	void GetConnectionInfo(bool* flag, int* count);
+	void SetVibration(uint8_t large_motor, uint8_t small_motor);
 	void ReadState(ControllerState* state, bool* flag, int* count);
 	int  ReadStates(ControllerState* states, int states_num, bool* flag, int* count);
 
@@ -260,6 +266,18 @@ void GameController::Axis(int id, Controller::Axis axis, int value) {
 	}
 }
 
+void GameController::RightStick(int id, int x, int y) {
+	Common::LockGuard lock(m_mutex);
+
+	if (m_active_id == id || id == HOST_INPUT_CONTROLLER_ID) {
+		auto state                                 = GetLastState();
+		state.time                                 = LibKernel::KernelGetProcessTime();
+		state.axes[static_cast<int>(Axis::RightX)] = x;
+		state.axes[static_cast<int>(Axis::RightY)] = y;
+		AddState(state);
+	}
+}
+
 void GameController::ResetInputState() {
 	Common::LockGuard lock(m_mutex);
 	ControllerState   state {};
@@ -269,6 +287,25 @@ void GameController::ResetInputState() {
 	AddState(state);
 }
 
+void GameController::SetVibration(uint8_t large_motor, uint8_t small_motor) {
+	Common::LockGuard lock(m_mutex);
+
+	if (m_active_id == HOST_INPUT_CONTROLLER_ID) {
+		return;
+	}
+
+	auto* pad = SDL_GameControllerFromInstanceID(static_cast<SDL_JoystickID>(m_active_id));
+	if (pad == nullptr) {
+		return;
+	}
+
+	const auto large = static_cast<uint16_t>(large_motor * 0x101U);
+	const auto small = static_cast<uint16_t>(small_motor * 0x101U);
+	if (SDL_GameControllerRumble(pad, large, small, RUMBLE_DURATION_MS) != 0) {
+		LOGF("\t rumble failed: %s\n", SDL_GetError());
+	}
+}
+
 void GameController::GetConnectionInfo(bool* flag, int* count) {
 	EXIT_IF(flag == nullptr);
 	EXIT_IF(count == nullptr);
@@ -347,6 +384,12 @@ void ControllerAxis(int id, Axis axis, int value) {
 	g_controller->Axis(id, axis, value);
 }
 
+void ControllerRightStick(int id, int x, int y) {
+	EXIT_IF(g_controller == nullptr);
+
+	g_controller->RightStick(id, x, y);
+}
+
 void ControllerResetInputState() {
 	EXIT_IF(g_controller == nullptr);
 	g_controller->ResetInputState();
@@ -544,6 +587,9 @@ int KYTY_SYSV_ABI PadSetVibration(int handle, const PadVibrationParam* param) {
 	     "\t small_motor = %d\n",
 	     static_cast<int>(param->large_motor), static_cast<int>(param->small_motor));
 
+	EXIT_IF(g_controller == nullptr);
+	g_controller->SetVibration(param->large_motor, param->small_motor);
+
 	return OK;
 }
 

src/libs/controller.h

@@ -58,6 +58,7 @@ void ControllerConnect(int id);
 void ControllerDisconnect(int id);
 void ControllerButton(int id, uint32_t button, bool down);
 void ControllerAxis(int id, Axis axis, int value);
+void ControllerRightStick(int id, int x, int y);
 void ControllerResetInputState();
 
 int KYTY_SYSV_ABI PadInit();

src/libs/libNet.cpp

@@ -113,6 +113,10 @@ int KYTY_SYSV_ABI NetResolverCreate(const char* name, int memid, int flags) {
 	return NET_CALL(Net::NetResolverCreate(name, memid, flags));
 }
 
+int KYTY_SYSV_ABI NetResolverDestroy(int rid) {
+	return NET_CALL(Net::NetResolverDestroy(rid));
+}
+
 int KYTY_SYSV_ABI NetResolverStartNtoa(int rid, const char* hostname, void* addr, int timeout,
                                        int retry, int flags) {
 	return NET_CALL(Net::NetResolverStartNtoa(rid, hostname, addr, timeout, retry, flags));
@@ -194,6 +198,7 @@ LIB_DEFINE(InitNet_1_Net) {
 	LIB_FUNC("dgJBaeJnGpo", LibNet::NetPoolCreate);
 	LIB_FUNC("K7RlrTkI-mw", LibNet::NetPoolDestroy);
 	LIB_FUNC("C4UgDHHPvdw", LibNet::NetResolverCreate);
+	LIB_FUNC("kJlYH5uMAWI", LibNet::NetResolverDestroy);
 	LIB_FUNC("Nd91WaWmG2w", LibNet::NetResolverStartNtoa);
 	LIB_FUNC("8Kcp5d-q1Uo", LibNet::NetInetPton);
 	LIB_FUNC("9vA2aW+CHuA", LibNet::NetInetNtop);

src/libs/network.cpp

@@ -101,6 +101,7 @@ public:
 	int  PoolCreate(const char* name, int size);
 	bool PoolDestroy(int memid);
 	int  ResolverCreate(const char* name, int memid);
+	bool ResolverDestroy(int rid);
 	bool ResolverValid(int rid);
 
 	Id   SslInit(uint64_t pool_size);
@@ -291,6 +292,17 @@ int Network::ResolverCreate(const char* name, int memid) {
 	return -1;
 }
 
+bool Network::ResolverDestroy(int rid) {
+	Common::LockGuard lock(m_mutex);
+
+	if (rid >= 0 && rid < RESOLVERS_MAX && m_resolvers[rid].used) {
+		m_resolvers[rid] = {};
+		return true;
+	}
+
+	return false;
+}
+
 bool Network::ResolverValid(int rid) {
 	Common::LockGuard lock(m_mutex);
 
@@ -1231,6 +1243,19 @@ int KYTY_SYSV_ABI NetResolverCreate(const char* name, int memid, int flags) {
 	return id;
 }
 
+int KYTY_SYSV_ABI NetResolverDestroy(int rid) {
+	PRINT_NAME();
+
+	LOGF("\t rid = %d\n", rid);
+
+	EXIT_IF(g_net == nullptr);
+	if (!g_net->ResolverDestroy(rid)) {
+		return NET_ERROR_EBADF;
+	}
+
+	return OK;
+}
+
 int KYTY_SYSV_ABI NetResolverStartNtoa(int rid, const char* hostname, void* addr, int timeout,
                                        int retry, int flags) {
 	PRINT_NAME();

src/libs/network.h

@@ -40,6 +40,7 @@ int KYTY_SYSV_ABI NetTerm();
 int KYTY_SYSV_ABI NetPoolCreate(const char* name, int size, int flags);
 int KYTY_SYSV_ABI NetPoolDestroy(int memid);
 int KYTY_SYSV_ABI NetResolverCreate(const char* name, int memid, int flags);
+int KYTY_SYSV_ABI NetResolverDestroy(int rid);
 int KYTY_SYSV_ABI NetResolverStartNtoa(int rid, const char* hostname, void* addr, int timeout,
                                        int retry, int flags);
 int KYTY_SYSV_ABI NetInetPton(int af, const char* src, void* dst);

src/loader/runtimeLinker.cpp

@@ -801,7 +801,10 @@ static bool KytyExceptionHandler(const Common::HostException::ExceptionInfo& exc
 			return true;
 		}
 	}
-	return false;
+	EXIT("Unhandled host exception: type=%u code=%u pc=0x%016" PRIx64
+	     " access=%u address=0x%016" PRIx64 "\n",
+	     static_cast<unsigned>(info->type), info->native_code, info->exception_address,
+	     static_cast<unsigned>(info->access_violation_type), info->access_violation_vaddr);
 }
 
 static void EncodeId64(uint16_t in_id, std::string* out_id) {

tests/ShaderRecompilerComputeTests.cpp

@@ -7283,26 +7283,30 @@ public:
     std::printf("[gpu]     %-32s ok\n", name);
   }
 
-  void CheckRenderExecutorColorStandard4TileDiscovery() {
-    constexpr const char *name = "RenderExecutorColorStandard4Tile";
+  void CheckRenderExecutorColorStandardTileDiscovery() {
+    constexpr const char *name = "RenderExecutorColorStandardTile";
     constexpr uintptr_t base = 0x0000000203b00000ull;
-    constexpr uint64_t target_address = base + 0x4000;
-    constexpr uint64_t target_size = 0x180000;
-    constexpr uint64_t allocation_size = 0x184000;
-    constexpr uint64_t allocation_alignment = 0x4000;
+    constexpr uint64_t allocation_size = 0x190000;
+    constexpr uint64_t allocation_alignment = 0x10000;
     constexpr auto format = Prospero::BufferFormat::k32Float;
-    constexpr auto tile = Prospero::TileMode::kStandard4KB;
+    struct TileCase {
+      Prospero::TileMode tile;
+      uint64_t target_offset;
+      uint64_t alignment;
+    };
+    constexpr std::array cases{
+        TileCase{Prospero::TileMode::kStandard4KB, 0x4000, 0x1000},
+        TileCase{Prospero::TileMode::kStandard64KB, 0x10000, 0x10000},
+    };
     EnsureRuntimeContext();
 
-    const auto pitch = TileGetTexturePitch(format, 256, tile);
-    TileSizeAlign slice{};
-    TileGetTextureSize(format, 256, 256, 1, tile, &slice, nullptr, nullptr);
-    const auto odd_pitch = TileGetTexturePitch(format, 257, tile);
+    const auto odd_pitch =
+        TileGetTexturePitch(format, 257, Prospero::TileMode::kStandard4KB);
     TileSizeAlign odd_slice{};
-    TileGetTextureSize(format, 257, 131, 1, tile, &odd_slice, nullptr, nullptr);
+    TileGetTextureSize(format, 257, 131, 1, Prospero::TileMode::kStandard4KB,
+                       &odd_slice, nullptr, nullptr);
     Require(name, "tile layout",
-            pitch == 256 && slice.size == 0x40000 && slice.align == 0x1000 &&
-                odd_pitch == 288 && odd_slice.size == 0x2d000 &&
+            odd_pitch == 288 && odd_slice.size == 0x2d000 &&
                 odd_slice.align == 0x1000,
             "Standard4KB pitch, footprint, or block alignment is incorrect");
 
@@ -7311,17 +7315,29 @@ public:
             Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                 0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                 allocation_size, allocation_alignment, 0, &direct_offset) == 0,
-            "Standard4KB color allocation failed");
+            "standard-tiled color allocation failed");
     void *mapped = reinterpret_cast<void *>(base);
     Require(name, "direct mapping",
             Libs::LibKernel::Memory::KernelMapDirectMemory(
                 &mapped, allocation_size, 0x3, 0x10, direct_offset,
                 allocation_alignment) == 0 &&
                 mapped == reinterpret_cast<void *>(base),
-            "Standard4KB color mapping failed");
+            "standard-tiled color mapping failed");
     std::memset(mapped, 0, allocation_size);
 
-    {
+    for (const auto &tile_case : cases) {
+      const auto pitch = TileGetTexturePitch(format, 256, tile_case.tile);
+      TileSizeAlign slice{};
+      TileGetTextureSize(format, 256, 256, 1, tile_case.tile, &slice, nullptr,
+                         nullptr);
+      Require(
+          name, "tile layout",
+          pitch == 256 && slice.size == 0x40000 &&
+              slice.align == tile_case.alignment,
+          "standard tile pitch, footprint, or block alignment is incorrect");
+
+      const auto target_address = base + tile_case.target_offset;
+      const auto target_size = slice.size * 6ull;
       RenderContext context(m_runtime_context);
       auto &scheduler = context.GetCommandScheduler();
       HW::Context registers{};
@@ -7335,7 +7351,7 @@ public:
       registers.SetColorView(
           0, {.base_array_slice_index = 5, .last_array_slice_index = 5});
       registers.SetColorAttrib2(0, {.height = 255, .width = 255});
-      registers.SetColorAttrib3(0, {.tile_mode = tile,
+      registers.SetColorAttrib3(0, {.tile_mode = tile_case.tile,
                                     .dimension = 1,
                                     .cmask_pipe_aligned = true,
                                     .dcc_pipe_aligned = true});
@@ -7358,7 +7374,7 @@ public:
                   color.base_array_layer == 5 &&
                   color.desc.info.data.address == target_address &&
                   color.desc.info.data.size == target_size &&
-                  color.desc.info.tile_mode == tile &&
+                  color.desc.info.tile_mode == tile_case.tile &&
                   color.desc.info.extent == vk::Extent3D{256, 256, 1} &&
                   color.desc.info.resources == ImageSubresources{1, 6} &&
                   color.desc.info.pitch == pitch &&
@@ -7367,9 +7383,9 @@ public:
                   color.desc.view_info.type == vk::ImageViewType::e2D &&
                   color.desc.view_info.base_layer == 5 &&
                   color.desc.view_info.layer_count == 1 &&
-                  (target_address & 0xffffu) == 0x4000 &&
+                  (target_address & (tile_case.alignment - 1)) == 0 &&
                   image.usage.render_target && image.IsGpuModified(),
-              "slice 5 Standard4KB render target was not resolved");
+              "slice 5 standard-tiled render target was not resolved");
 
       RenderExecutorTestAccess::ResetBindings(executor);
       resources.UnmapMemory(base, allocation_size);
@@ -7378,11 +7394,11 @@ public:
 
     Require(name, "unmap direct backing",
             Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
-            "Standard4KB color mapping release failed");
+            "standard-tiled color mapping release failed");
     Require(name, "release direct backing",
             Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                 direct_offset, allocation_size) == 0,
-            "Standard4KB color allocation release failed");
+            "standard-tiled color allocation release failed");
     std::printf("[gpu]     %-32s ok\n", name);
   }
 
@@ -12018,6 +12034,7 @@ CoverageClass ClassifyOpcode(ShaderOpcode opcode,
   case Opcode::DS_READ_I16:
   case Opcode::DS_READ_U16:
   case Opcode::DS_READ_U16_D16:
+  case Opcode::DS_READ_U16_D16_HI:
   case Opcode::DS_READ2_B32:
   case Opcode::DS_READ_B32:
   case Opcode::DS_READ_B64:
@@ -12026,6 +12043,7 @@ CoverageClass ClassifyOpcode(ShaderOpcode opcode,
   case Opcode::DS_READ_B128:
   case Opcode::DS_WRITE_B8:
   case Opcode::DS_WRITE_B16:
+  case Opcode::DS_WRITE_B16_D16_HI:
   case Opcode::DS_WRITE2_B32:
   case Opcode::DS_WRITE2ST64_B32:
   case Opcode::DS_WRITE_B32:
@@ -13355,6 +13373,83 @@ TestCase VectorIntegerOps() {
            O::S_ENDPGM}};
 }
 
+TestCase VectorFfbhI32NativeAndVop3OnGpu() {
+  using O = ShaderOpcode;
+
+  constexpr std::array inputs = {0x00000000u, 0x40000000u, 0x80000000u,
+                                 0x0fffffffu, 0xffff0000u, 0xfffffffeu,
+                                 0xffffffffu, 0x80000000u};
+  std::vector<u32> code;
+  for (u32 i = 0; i < inputs.size() - 1u; i++) {
+    AppendVMovU32(&code, 30, i * 4u);
+    AppendBufferLoadDword(&code, 14, 30);
+    code.push_back(0x7e1c770eu); // v_ffbh_i32 v14, v14
+    AppendStoreVgpr(&code, 14, i);
+  }
+  AppendVMovU32(&code, 30, (inputs.size() - 1u) * 4u);
+  AppendBufferLoadDword(&code, 14, 30);
+  AppendVop3(&code, 0x1bbu, 15, Vgpr(14), 0);
+  AppendStoreVgpr(&code, 15, inputs.size() - 1u);
+  AppendEnd(&code);
+
+  TestCase test;
+  test.name = "VectorFfbhI32NativeAndVop3OnGpu";
+  test.code = std::move(code);
+  test.initial.assign(inputs.begin(), inputs.end());
+  test.expected = {0xffffffffu, 1u, 1u, 4u, 16u, 31u, 0xffffffffu, 1u};
+  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::V_FFBH_I32,
+                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
+  test.decoded_counts = {{"V_FFBH_I32 v14, v14", inputs.size() - 1u},
+                         {"V_FFBH_I32 v15, v14", 1u}};
+  return test;
+}
+
+TestCase Vop1SdwaFfblCapturedHighWordSource() {
+  using O = ShaderOpcode;
+
+  std::vector<u32> code;
+  AppendBufferLoadDword(&code, 2, 30);
+  code.push_back(0x7e2074f9u);
+  code.push_back(0x00050602u); // v_ffbl_b32 v16, v2.word1
+  AppendStoreVgpr(&code, 16, 0);
+  AppendEnd(&code);
+
+  TestCase test;
+  test.name = "Vop1SdwaFfblCapturedHighWordSource";
+  test.code = std::move(code);
+  test.initial = {0x00400000u};
+  test.expected = {6u};
+  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_FFBL_B32, O::BUFFER_STORE_DWORD,
+                  O::S_ENDPGM};
+  test.decoded_counts = {{"V_FFBL_B32 v16, v2.sdwa(sel=5,sext=0)", 1}};
+  test.ir_counts = {{" = BitFieldUExtract ", 1}, {" = FindILsb32 ", 1}};
+  test.required_spirv = {"OpBitFieldUExtract"};
+  return test;
+}
+
+TestCase Vop1SdwaNotCapturedByte0Source() {
+  using O = ShaderOpcode;
+
+  std::vector<u32> code;
+  AppendBufferLoadDword(&code, 2, 30);
+  code.push_back(0x7e046ef9u);
+  code.push_back(0x00000602u); // v_not_b32 v2, v2.byte0
+  AppendStoreVgpr(&code, 2, 0);
+  AppendEnd(&code);
+
+  TestCase test;
+  test.name = "Vop1SdwaNotCapturedByte0Source";
+  test.code = std::move(code);
+  test.initial = {0x12345678u};
+  test.expected = {0xffffff87u};
+  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_NOT_B32, O::BUFFER_STORE_DWORD,
+                  O::S_ENDPGM};
+  test.decoded_counts = {{"V_NOT_B32 v2, v2.sdwa(sel=0,sext=0)", 1}};
+  test.ir_counts = {{" = BitFieldUExtract ", 1}, {" = BitwiseNot32 ", 1}};
+  test.required_spirv = {"OpBitFieldUExtract", "OpNot"};
+  return test;
+}
+
 TestCase Vop2SdwaSubNcExactByte2Destination() {
   using O = ShaderOpcode;
 
@@ -13862,37 +13957,35 @@ TestCase VectorAddcUsesPerLaneCarryIn() {
 TestCase VectorAddcWritesPerLaneCarryOut() {
   using O = ShaderOpcode;
 
-  std::vector<u32> code = {
-      EncodeVop1(0x01, 1, 0),
-      EncodeVop2(0x1a, 1, InlineU32(2), 1),
-      EncodeVop2(0x25, 1, Vgpr(0), 1),
-      EncodeVopc(0xc0, Vgpr(0), 0),
-  };
-  AppendVMovLiteral(&code, 2, 0xffffffffu);
-  code.push_back(EncodeVop1(0x01, 3, InlineU32(1)));
-  code.push_back(EncodeVop2(0x28, 5, Vgpr(2), 3));
+  std::vector<u32> code = {EncodeVop1(0x01, 1, Vgpr(0)),
+                           EncodeVop2(0x1a, 4, InlineU32(2), 1),
+                           EncodeVopc(0xc7, Vgpr(0), 0)};
+  AppendBufferLoadDword(&code, 26, 4);
+  code.push_back(0x500434f9u);
+  code.push_back(0x0c860680u);
   code.push_back(EncodeVop1(0x01, 6, 106));
-  code.push_back(EncodeVop2(0x1a, 4, InlineU32(2), 1));
   AppendBufferStoreDword(&code, 6, 4);
   AppendEnd(&code);
 
   TestCase test;
   test.name = "VectorAddcWritesPerLaneCarryOut";
   test.code = code;
+  test.initial = {0x0000ffffu, 0u, 0x0000ffffu, 0u};
   // VCC is represented as the current invocation's carry bit, not a shared
   // four-lane ballot word.
-  test.expected = std::vector<u32>(8, 1u);
-  test.opcodes = {O::V_MOV_B32,   O::V_LSHLREV_B32, O::V_ADD_NC_U32,
-                  O::V_CMP_F_U32, O::V_ADDC_U32,    O::BUFFER_STORE_DWORD,
+  test.expected = {1u, 0u, 1u, 0u};
+  test.opcodes = {O::V_MOV_B32,         O::V_LSHLREV_B32, O::V_CMP_T_U32,
+                  O::BUFFER_LOAD_DWORD, O::V_ADDC_U32,    O::BUFFER_STORE_DWORD,
                   O::S_ENDPGM};
+  test.decoded_counts = {
+      {"V_ADDC_U32 v2, vcc_lo, 0, v26.sdwa(sel=4,sext=1), vcc_lo", 1}};
+  test.ir_counts = {{" = BitFieldSExtract ", 1}, {" = IAddCarry32 ", 2}};
+  test.required_spirv = {"OpBitFieldSExtract"};
   test.compute_info.threads_num[0] = 4;
   test.compute_info.threads_num[1] = 1;
   test.compute_info.threads_num[2] = 1;
-  test.compute_info.group_id[0] = true;
   test.compute_info.thread_ids_num = 1;
-  test.compute_info.workgroup_register = 0;
   test.has_compute_info = true;
-  test.dispatch_x = 2;
   return test;
 }
 
@@ -15367,6 +15460,36 @@ TestCase VectorCompareOps() {
            O::V_CMP_T_U32,   O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
 }
 
+TestCase VectorVop3CompareEqU64OnGpu() {
+  using O = ShaderOpcode;
+
+  std::vector<u32> code;
+  code.push_back(EncodeVop1(0x01, 1, InlineU32(1)));
+
+  code.push_back(EncodeSop1(0x04, 106, 126)); // s_mov_b64 vcc, exec
+  code.push_back(0xd4e2006au);
+  code.push_back(0x0000d47eu); // v_cmp_eq_u64 vcc, exec, vcc
+  code.push_back(EncodeVop2(0x01, 2, InlineU32(0), 1));
+  AppendStoreVgpr(&code, 2, 0);
+
+  AppendSMovLiteral(&code, 107, 1); // high-dword mismatch
+  code.push_back(0xd4e2006au);
+  code.push_back(0x0000d47eu); // v_cmp_eq_u64 vcc, exec, vcc
+  code.push_back(EncodeVop2(0x01, 3, InlineU32(0), 1));
+  AppendStoreVgpr(&code, 3, 1);
+  AppendEnd(&code);
+
+  TestCase test{"VectorVop3CompareEqU64OnGpu",
+                code,
+                {},
+                {1, 0},
+                {O::V_MOV_B32, O::S_MOV_B64, O::V_CMP_EQ_U64,
+                 O::V_CNDMASK_B32, O::S_MOV_B32, O::BUFFER_STORE_DWORD,
+                 O::S_ENDPGM}};
+  test.decoded_counts = {{"V_CMP_EQ_U64 vcc_lo, exec_lo, vcc_lo", 2}};
+  return test;
+}
+
 TestCase VectorVop3CompareNeU64OnGpu() {
   using O = ShaderOpcode;
 
@@ -17992,6 +18115,64 @@ TestCase DsReadU16D16CapturedPreservesHighHalf() {
   return test;
 }
 
+TestCase DsWriteB16D16HiCapturedUsesHighHalf() {
+  using O = ShaderOpcode;
+
+  std::vector<u32> code;
+  AppendVMovU32(&code, 1, 0);
+  AppendVMovLiteral(&code, 3, 0xdeadbeefu);
+  code.push_back(EncodeDs0(0x0d));
+  code.push_back(EncodeDs1(0, 3, 1)); // ds_write_b32 v1, v3
+
+  AppendVMovU32(&code, 20, 2);
+  AppendVMovLiteral(&code, 2, 0x1234abcdu);
+  AppendVMovLiteral(&code, 0, 0x87654321u);
+  code.push_back(0xda840000u);
+  code.push_back(0x00000214u); // captured ds_write_b16_d16_hi v20, v2
+
+  code.push_back(EncodeDs0(0x36));
+  code.push_back(EncodeDs1(4, 0, 1)); // ds_read_b32 v4, v1
+  AppendStoreVgpr(&code, 4, 0);
+  AppendStoreVgpr(&code, 0, 1);
+  AppendEnd(&code);
+
+  TestCase test{"DsWriteB16D16HiCapturedUsesHighHalf",
+                code,
+                std::vector<u32>(2, 0),
+                {0x1234beefu, 0x87654321u},
+                {O::V_MOV_B32, O::DS_WRITE_B32, O::DS_WRITE_B16_D16_HI,
+                 O::DS_READ_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
+  test.decoded_counts = {{"DS_WRITE_B16_D16_HI", 1}};
+  return test;
+}
+
+TestCase DsReadU16D16HiCapturedPreservesLowHalf() {
+  using O = ShaderOpcode;
+
+  std::vector<u32> code;
+  AppendVMovU32(&code, 1, 0);
+  AppendVMovLiteral(&code, 2, 0x89abcdefu);
+  code.push_back(EncodeDs0(0x0d));
+  code.push_back(EncodeDs1(0, 2, 1)); // ds_write_b32 v2, v1
+
+  AppendVMovLiteral(&code, 5, 0x12345678u);
+  AppendVMovU32(&code, 6, 0);
+  code.push_back(0xda9c0000u);
+  code.push_back(0x05000006u); // captured ds_read_u16_d16_hi v5, v6
+
+  AppendStoreVgpr(&code, 5, 0);
+  AppendEnd(&code);
+
+  TestCase test{"DsReadU16D16HiCapturedPreservesLowHalf",
+                code,
+                std::vector<u32>(1, 0),
+                {0xcdef5678u},
+                {O::V_MOV_B32, O::DS_WRITE_B32, O::DS_READ_U16_D16_HI,
+                 O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
+  test.decoded_counts = {{"DS_READ_U16_D16_HI", 1}};
+  return test;
+}
+
 TestCase DsReadWrite2Variants() {
   using O = ShaderOpcode;
 
@@ -18936,6 +19117,44 @@ TestCase ImageLoad1DUsesScalarCoordinate() {
   return test;
 }
 
+TestCase ImageGather2DInstructionWith1DDescriptor() {
+  using O = ShaderOpcode;
+
+  std::vector<u32> code;
+  AppendVMovLiteral(&code, 20, 0x3f000000u);
+  AppendVMovLiteral(&code, 21, 0x3f000000u);
+  code.push_back(EncodeMimg0(0x47, 0x1));
+  code.push_back(EncodeMimg1(0, 20));
+  for (u32 i = 0; i < 4u; i++) {
+    AppendStoreVgpr(&code, i, i);
+  }
+  AppendEnd(&code);
+
+  auto image = MakeRgbaImage(4, 1);
+  SetRgbaPixel(&image, 4, 1, 0, 0x40000000u, 0, 0, 0);
+  SetRgbaPixel(&image, 4, 2, 0, 0x40400000u, 0, 0, 0);
+
+  TestCase test;
+  test.name = "ImageGather2DInstructionWith1DDescriptor";
+  test.code = code;
+  test.expected = {0x40000000u, 0x40400000u, 0x40400000u, 0x40000000u};
+  test.opcodes = {O::V_MOV_B32, O::IMAGE_GATHER4_LZ, O::BUFFER_STORE_DWORD,
+                  O::S_ENDPGM};
+  test.image_width = 4;
+  test.image_height = 1;
+  test.sampled_image_rgba = image;
+  test.sampled_image_type = vk::ImageType::e1D;
+  test.sampled_image_view_type = vk::ImageViewType::e1D;
+  test.user_data = MakeSampledTextureData(Prospero::BufferFormat::k32Float);
+  test.user_data[3] = static_cast<uint32_t>(Prospero::ImageType::kColor1D)
+                      << 28u;
+  test.has_user_data = true;
+  test.required_spirv = {"sampled_1d", "OpImageQuerySizeLod",
+                         "OpImageSampleExplicitLod", "Floor"};
+  test.forbidden_spirv = {"OpImageGather"};
+  return test;
+}
+
 TestCase ImageLoad1DArrayUsesLayerCoordinate() {
   using O = ShaderOpcode;
 
@@ -20350,6 +20569,9 @@ std::vector<TestCase> MakeCases() {
   AddCase(VectorMoves);
   AddCase(VectorVop3MoveAppliesFloatSourceModifiers);
   AddCase(VectorIntegerOps);
+  AddCase(VectorFfbhI32NativeAndVop3OnGpu);
+  AddCase(Vop1SdwaFfblCapturedHighWordSource);
+  AddCase(Vop1SdwaNotCapturedByte0Source);
   AddCase(Vop2SdwaSubNcExactByte2Destination);
   AddCase(Vop2SdwaAddNcCapturedHighWordDestination);
   AddCase(Vop2SdwaAshrrevCapturedWord0SignExtends);
@@ -20411,6 +20633,7 @@ std::vector<TestCase> MakeCases() {
   AddCase(VectorSinCosMaxFiniteSpecialCases);
   AddCase(VectorCompareOps);
   AddCase(VectorVop3CompareEqI64OnGpu);
+  AddCase(VectorVop3CompareEqU64OnGpu);
   AddCase(VectorVop3CompareGtU64OnGpu);
   AddCase(VectorVop3CompareNeU64OnGpu);
   AddCase(VectorVopcCmpxNeU64CapturedExecMask);
@@ -20507,7 +20730,9 @@ std::vector<TestCase> MakeCases() {
   AddCase(ScratchIsPrivatePerInvocation);
   AddCase(FlatStoreVariants);
   AddCase(DsReadWriteVariants);
+  AddCase(DsWriteB16D16HiCapturedUsesHighHalf);
   AddCase(DsReadU16D16CapturedPreservesHighHalf);
+  AddCase(DsReadU16D16HiCapturedPreservesLowHalf);
   AddCase(DsAppendConsumeUsesEncodedLdsSelector);
   AddCase(DsAppendUsesEncodedGdsSelector);
   AddCase(DsGdsSubdwordAndAtomicWrites);
@@ -20535,6 +20760,7 @@ std::vector<TestCase> MakeCases() {
   AddCase(ImageSamplePackedUintConvertsSampleAndGather);
   AddCase(ImageLoadR128IgnoresAdjacentMaskSgprs);
   AddCase(ImageLoad1DUsesScalarCoordinate);
+  AddCase(ImageGather2DInstructionWith1DDescriptor);
   AddCase(ImageLoad1DArrayUsesLayerCoordinate);
   AddCase(ImageLoad1DArrayDescriptorUsesSelectedLayer);
   AddCase(ImageLoadMipUsesVaddr2Lod2D);
@@ -24290,6 +24516,11 @@ int main(int argc, char **argv) {
     RunCase(&vulkan, Vop2SdwaAshrrevCapturedWord0SignExtends());
     return 0;
   }
+  if (argc == 2 && std::strcmp(argv[1], "--sdwa-addc-only") == 0) {
+    VulkanHarness vulkan;
+    RunCase(&vulkan, VectorAddcWritesPerLaneCarryOut());
+    return 0;
+  }
   if (argc == 2 && std::strcmp(argv[1], "--cvt-pk-i16-only") == 0) {
     VulkanHarness vulkan;
     RunCase(&vulkan, Vop3CvtPkI16I32Captured());
@@ -24391,9 +24622,9 @@ int main(int argc, char **argv) {
     CheckStandard64RenderTargetTileRoundTrip();
     return 0;
   }
-  if (argc == 2 && std::strcmp(argv[1], "--standard4-rt-only") == 0) {
+  if (argc == 2 && std::strcmp(argv[1], "--standard-tile-rt-only") == 0) {
     VulkanHarness vulkan;
-    vulkan.CheckRenderExecutorColorStandard4TileDiscovery();
+    vulkan.CheckRenderExecutorColorStandardTileDiscovery();
     return 0;
   }
   if (argc == 2 && std::strcmp(argv[1], "--image-view-only") == 0) {
@@ -24514,7 +24745,7 @@ int main(int argc, char **argv) {
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
   vulkan.CheckRenderExecutorColor1DDiscovery();
   vulkan.CheckRenderExecutorColorVolumeDiscovery();
-  vulkan.CheckRenderExecutorColorStandard4TileDiscovery();
+  vulkan.CheckRenderExecutorColorStandardTileDiscovery();
   vulkan.CheckRenderExecutorColorDepthTileDiscovery();
   vulkan.CheckRenderExecutorStencilBindingDiscovery();
   vulkan.CheckUnifiedTextureCacheFlow();

tests/shaderCfgTests.cpp

@@ -4007,6 +4007,30 @@ void TestNewShaderDecoderArchitecture() {
                 program_direct.word_count,
         "program decoder diverged from the single-instruction decoder");
 
+  const uint32_t cmp_eq_u64_code[] = {0xd4e2006au, 0x0000d47eu};
+  Instruction cmp_eq_u64;
+  Check(DecodeInstruction(cmp_eq_u64_code, 0u, cmp_eq_u64, &error),
+        error.c_str());
+  Check(cmp_eq_u64.family == Family::VOP3 &&
+            cmp_eq_u64.opcode == Opcode::V_CMP_EQ_U64 &&
+            cmp_eq_u64.dst.kind == OperandKind::VccLo &&
+            cmp_eq_u64.src_count == 2u &&
+            cmp_eq_u64.src0.kind == OperandKind::ExecLo &&
+            cmp_eq_u64.src1.kind == OperandKind::VccLo,
+        "decoder rejected the captured VOP3 V_CMP_EQ_U64 instruction");
+
+  const uint32_t ffbh_i32_code[] = {0x7e1c770eu};
+  Instruction ffbh_i32;
+  Check(DecodeInstruction(ffbh_i32_code, 0u, ffbh_i32, &error),
+        error.c_str());
+  Check(ffbh_i32.family == Family::VOP1 &&
+            ffbh_i32.opcode == Opcode::V_FFBH_I32 &&
+            ffbh_i32.dst.kind == OperandKind::Vgpr && ffbh_i32.dst.reg == 14u &&
+            ffbh_i32.src_count == 1u &&
+            ffbh_i32.src0.kind == OperandKind::Vgpr &&
+            ffbh_i32.src0.reg == 14u,
+        "decoder rejected the captured VOP1 V_FFBH_I32 instruction");
+
   const uint32_t literal_code[] = {EncodeVop1(0x01, 2, 255u), 0x12345678u};
   Instruction literal;
   Check(DecodeInstruction(literal_code, 0u, literal, &error), error.c_str());
@@ -4043,6 +4067,40 @@ void TestNewShaderDecoderArchitecture() {
         "decoder rejected or misdecoded captured partial-destination "
         "V_ADD_NC_U32");
 
+  const uint32_t vop2_sdwa_byte_shift[] = {
+      0x2c0910f9u,
+      0x86000613u, // v_lshrrev_b32 v4, v19.byte0, 8
+  };
+  Instruction byte_shift;
+  Check(DecodeInstruction(vop2_sdwa_byte_shift, 0u, byte_shift, &error),
+        error.c_str());
+  Check(byte_shift.family == Family::VOP2 &&
+            byte_shift.opcode == Opcode::V_LSHRREV_B32 &&
+            byte_shift.word_count == 2u && byte_shift.dst.reg == 4u &&
+            byte_shift.src0.kind == OperandKind::Vgpr &&
+            byte_shift.src0.reg == 19u && byte_shift.src0.sdwa_sel == 0u &&
+            byte_shift.src1.kind == OperandKind::IntegerInlineConstant &&
+            byte_shift.src1.value == 8u,
+        "decoder rejected or misdecoded captured V_LSHRREV_B32 byte shift");
+
+  const uint32_t vop2_sdwa_byte_left_shift[] = {
+      0x340d02f9u,
+      0x86030607u, // v_lshlrev_b32 v6, v7.byte3, 1
+  };
+  Instruction byte_left_shift;
+  Check(DecodeInstruction(vop2_sdwa_byte_left_shift, 0u, byte_left_shift,
+                          &error),
+        error.c_str());
+  Check(byte_left_shift.family == Family::VOP2 &&
+            byte_left_shift.opcode == Opcode::V_LSHLREV_B32 &&
+            byte_left_shift.word_count == 2u && byte_left_shift.dst.reg == 6u &&
+            byte_left_shift.src0.kind == OperandKind::Vgpr &&
+            byte_left_shift.src0.reg == 7u &&
+            byte_left_shift.src0.sdwa_sel == 3u &&
+            byte_left_shift.src1.kind == OperandKind::IntegerInlineConstant &&
+            byte_left_shift.src1.value == 1u,
+        "decoder rejected or misdecoded captured V_LSHLREV_B32 byte shift");
+
   const uint32_t mimg_nsa[] = {EncodeMimg0(0x20, 0xf) | (3u << 1u),
                                EncodeMimg1(4, 0, 1, 8), 0x03020100u,
                                0x07060504u, 0x0b0a0908u};
@@ -4065,6 +4123,28 @@ void TestNewShaderDecoderArchitecture() {
   Check(boot.opcode == Opcode::DS_SWIZZLE_B32 && boot.offset == 0xc480u,
         "DS decoder rejected a captured boot-shader instruction");
 
+  const uint32_t d16_hi_ds[] = {0xda9c0000u, 0x05000006u};
+  Instruction d16_hi;
+  Check(DecodeInstruction(d16_hi_ds, 0u, d16_hi, &error), error.c_str());
+  Check(d16_hi.opcode == Opcode::DS_READ_U16_D16_HI &&
+            d16_hi.src_count == 1u && d16_hi.data_bits == 16u &&
+            d16_hi.dst.reg == 5u && d16_hi.dst.sdwa_sel == 5u &&
+            d16_hi.dst.sdwa_dst_unused == 2u && d16_hi.src0.reg == 6u,
+        "DS decoder rejected the captured high-half D16 read");
+
+  const uint32_t d16_hi_write_ds[] = {0xda840000u, 0x00000214u};
+  Instruction d16_hi_write;
+  Check(DecodeInstruction(d16_hi_write_ds, 0u, d16_hi_write, &error),
+        error.c_str());
+  Check(d16_hi_write.family == Family::DS &&
+            d16_hi_write.opcode == Opcode::DS_WRITE_B16_D16_HI &&
+            d16_hi_write.word_count == 2u && d16_hi_write.src_count == 2u &&
+            d16_hi_write.data_dwords == 1u && d16_hi_write.data_bits == 16u &&
+            d16_hi_write.offset == 0u && !d16_hi_write.gds &&
+            d16_hi_write.src0.reg == 20u && d16_hi_write.src1.reg == 2u &&
+            d16_hi_write.src1.sdwa_sel == 5u,
+        "DS decoder rejected the captured high-half D16 write");
+
   constexpr uint32_t packed_source_selectors[][2] = {
       {0xcc0e0000u, 0x0c0a0300u}, // Source 0: instruction bit 59.
       {0xcc0e0000u, 0x140a0300u}, // Source 1: instruction bit 60.
@@ -4083,8 +4163,8 @@ void TestNewShaderDecoderArchitecture() {
 
 void TestNewShaderRecompilerRejectsDppOn64BitCompares() {
   const uint32_t opcodes[] = {
-      0xa2u, 0xb5u, 0xe4u, 0xe5u,
-      0xf5u}; // eq_i64, cmpx_ne_i64, gt_u64, ne_u64, cmpx_ne_u64
+      0xa2u, 0xb5u, 0xe2u, 0xe4u, 0xe5u,
+      0xf5u}; // eq_i64, cmpx_ne_i64, eq_u64, gt_u64, ne_u64, cmpx_ne_u64
   for (const auto opcode : opcodes) {
     const uint32_t shader[] = {
         EncodeVopc(opcode, 250u, 0u), // DPP escape in SRC0
@@ -5054,30 +5134,6 @@ void TestNewShaderRecompilerNullImageUsesCanonical2DView() {
         "null image retained the decoded 1D descriptor binding");
 }
 
-void TestNewShaderRecompilerRejectsOneDimensionalGather() {
-  constexpr std::array cases{
-      std::pair{0u, Prospero::ImageType::kColor1D},
-      std::pair{4u, Prospero::ImageType::kColor1DArray},
-  };
-  for (const auto &[dimension, type] : cases) {
-    const uint32_t shader[] = {
-        EncodeMimg0(0x47, 0x1, false, dimension),
-        EncodeMimg1(0, 0, 1, 0),
-        0xbf810000u,
-    };
-    auto user_data = ImageTestUserData(type);
-    auto options = MakeCompileOptions(ShaderType::Compute);
-    options.user_data = user_data.data();
-
-    ShaderRecompiler::CompileResult result;
-    std::string error;
-    Check(!ShaderRecompiler::TryRecompile(shader, options, result, &error) &&
-              Common::ContainsStr(error,
-                                  "1D image gather is not supported by SPIR-V"),
-          "1D image gather escaped as invalid SPIR-V");
-  }
-}
-
 void TestNewShaderRecompilerImageGatherVariants() {
   const uint32_t shader[] = {
       EncodeMimg0(0x47, 0x1),